1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "alsa_lib_common.h"
17 #include <ctype.h>
18 #include <limits.h>
19 #include "audio_common.h"
20 #include "audio_internal.h"
21 #include "cJSON.h"
22 #include "osal_mem.h"
23 #include "securec.h"
24
25 #define HDF_LOG_TAG HDF_AUDIO_HAL_LIB
26
27 #define USB_AUDIO "USB Audio"
28 #define MIXER_CTL_VOLUME "simple_mixer_ctl_volume"
29 #define PLAYBACK "playback"
30 #define CAPTURE "capture"
31 #define MAX_ELEMENT 100
32 #define ALSA_CARD_CONFIG_FILE HDF_CONFIG_DIR "/alsa_adapter.json"
33 #define ALSA_CONFIG_FILE_MAX (2 * 1024) // 2KB
34
35 #define SUPPORT_CAPTURE_OR_RENDER 1
36 #define SUPPORT_CAPTURE_AND_RENDER 2
37
38 struct CardStream {
39 int card;
40 snd_pcm_stream_t stream; /** Playback stream or Capture stream */
41 };
42
43 static struct AudioCardInfo *g_audioCardIns = NULL;
44 struct AlsaDevInfo *g_alsadevInfo = NULL;
45 static bool g_parseFlag = false;
46
47 /* Record the list of sound cards read from the alsa device */
48 static struct AlsaCardsList g_alsaCardsList;
49 /* Record the number of sound cards configured in the sound card configuration file,
50 * which is different from the sound cards read from the alsa device.
51 */
52 static uint8_t g_sndCardsNum = 0;
53
54 char *g_usbSimpleRenderCtlVol[] = {
55 "Earpiece",
56 "Speaker",
57 "Headphone",
58 "PCM",
59 "Mic",
60 };
61
62 char *g_usbSimpleCapCtlVol[] = {
63 "Earpiece",
64 "Headset",
65 "Headphone",
66 "Mic",
67 };
68
69 static struct DevProcInfo *g_sndCardList[SND_CARD_MAX][AUDIO_MAX_CARD_NUM] = {{NULL}};
70
AudioGetSoundCardsInfo(enum SndCardType cardType)71 static struct DevProcInfo **AudioGetSoundCardsInfo(enum SndCardType cardType)
72 {
73 return (struct DevProcInfo **)(g_sndCardList + cardType);
74 }
75
InitCardIns(void)76 int32_t InitCardIns(void)
77 {
78 if (g_audioCardIns == NULL) {
79 g_audioCardIns = (struct AudioCardInfo *)OsalMemCalloc(MAX_CARD_NUM * sizeof(struct AudioCardInfo));
80 if (g_audioCardIns == NULL) {
81 AUDIO_FUNC_LOGE("Failed to allocate memory!");
82 return HDF_FAILURE;
83 }
84 }
85
86 return HDF_SUCCESS;
87 }
88
AddCardIns(const char * cardName)89 static struct AudioCardInfo *AddCardIns(const char *cardName)
90 {
91 int32_t i;
92 int32_t ret;
93
94 if (cardName == NULL || strlen(cardName) == 0) {
95 AUDIO_FUNC_LOGE("Invalid cardName!");
96 return NULL;
97 }
98
99 if (g_audioCardIns == NULL) {
100 AUDIO_FUNC_LOGE("g_audioCardIns is NULL!");
101 return NULL;
102 }
103
104 for (i = 0; i < MAX_CARD_NUM; i++) {
105 if (g_audioCardIns[i].cardStatus == 0) {
106 (void)memset_s(&g_audioCardIns[i], sizeof(struct AudioCardInfo), 0, sizeof(struct AudioCardInfo));
107 ret = strncpy_s(g_audioCardIns[i].cardName, MAX_CARD_NAME_LEN + 1, cardName, strlen(cardName));
108 if (ret != 0) {
109 AUDIO_FUNC_LOGE("strncpy_s failed!");
110 return NULL;
111 }
112 g_audioCardIns[i].cardStatus++;
113 return &(g_audioCardIns[i]);
114 }
115 }
116 AUDIO_FUNC_LOGE("Failed to AddCardIns!");
117
118 return NULL;
119 }
120
FindCardIns(const char * cardName)121 static struct AudioCardInfo *FindCardIns(const char *cardName)
122 {
123 int32_t i;
124
125 if (cardName == NULL || strlen(cardName) == 0) {
126 AUDIO_FUNC_LOGE("Invalid cardName!");
127 return NULL;
128 }
129
130 if (g_audioCardIns == NULL) {
131 AUDIO_FUNC_LOGE("g_audioCardIns is NULL!");
132 return NULL;
133 }
134
135 for (i = 0; i < MAX_CARD_NUM; i++) {
136 if (strcmp(g_audioCardIns[i].cardName, cardName) == 0) {
137 return &(g_audioCardIns[i]);
138 }
139 }
140
141 return NULL;
142 }
143
AudioAddCardIns(const char * cardName)144 static int32_t AudioAddCardIns(const char *cardName)
145 {
146 struct AudioCardInfo *cardInfo = NULL;
147
148 if (cardName == NULL) {
149 AUDIO_FUNC_LOGE("Invalid cardName!");
150 return HDF_FAILURE;
151 }
152
153 cardInfo = FindCardIns(cardName);
154 if (cardInfo == NULL) {
155 cardInfo = AddCardIns(cardName);
156 if (cardInfo == NULL) {
157 AUDIO_FUNC_LOGE("AddCardIns failed!");
158 return HDF_FAILURE;
159 }
160 }
161
162 return HDF_SUCCESS;
163 }
164
GetCardIns(const char * cardName)165 struct AudioCardInfo *GetCardIns(const char *cardName)
166 {
167 if (cardName == NULL) {
168 AUDIO_FUNC_LOGE("Invalid cardName!");
169 return NULL;
170 }
171
172 return FindCardIns(cardName);
173 }
174
CheckCardStatus(struct AudioCardInfo * cardIns)175 void CheckCardStatus(struct AudioCardInfo *cardIns)
176 {
177 int32_t ret;
178 if (cardIns == NULL) {
179 AUDIO_FUNC_LOGE("The parameter is empty!");
180 return;
181 }
182 if (cardIns->cardStatus > 0) {
183 cardIns->cardStatus -= 1;
184 }
185 if (cardIns->cardStatus == 0) {
186 if (cardIns->renderPcmHandle != NULL) {
187 ret = snd_pcm_close(cardIns->renderPcmHandle);
188 if (ret < 0) {
189 AUDIO_FUNC_LOGE("snd_pcm_close fail: %{public}s", snd_strerror(ret));
190 }
191 cardIns->renderPcmHandle = NULL;
192 }
193 if (cardIns->capturePcmHandle != NULL) {
194 ret = snd_pcm_close(cardIns->capturePcmHandle);
195 if (ret < 0) {
196 AUDIO_FUNC_LOGE("snd_pcm_close fail: %{public}s", snd_strerror(ret));
197 }
198 cardIns->capturePcmHandle = NULL;
199 }
200 (void)memset_s(cardIns->cardName, MAX_CARD_NAME_LEN + 1, 0, MAX_CARD_NAME_LEN + 1);
201 }
202 }
203
CardInfoRelease(void)204 static void CardInfoRelease(void)
205 {
206 for (int i = 0; i < SND_CARD_MAX; i++) {
207 for (int j = 0; j < AUDIO_MAX_CARD_NUM; j++) {
208 if (g_sndCardList[i][j] == NULL) {
209 continue;
210 }
211 if (g_sndCardList[i][j]->ctlRenderNameList != NULL) {
212 AudioMemFree((void **)&(g_sndCardList[i][j]->ctlRenderNameList));
213 }
214 if (g_sndCardList[i][j]->ctlCaptureNameList != NULL) {
215 AudioMemFree((void **)&(g_sndCardList[i][j]->ctlCaptureNameList));
216 }
217 AudioMemFree((void **)&(g_sndCardList[i][j]));
218 }
219 }
220 g_parseFlag = false;
221 }
222
DestroyCardList(void)223 int32_t DestroyCardList(void)
224 {
225 int32_t i;
226
227 if (g_audioCardIns != NULL) {
228 for (i = 0; i < MAX_CARD_NUM; i++) {
229 if (g_audioCardIns[i].cardStatus != 0) {
230 AUDIO_FUNC_LOGE("refCount is not zero, Sound card in use!");
231 return HDF_ERR_DEVICE_BUSY;
232 }
233 }
234 AudioMemFree((void **)&g_audioCardIns);
235 g_audioCardIns = NULL;
236
237 /* Release the sound card configuration space */
238 CardInfoRelease();
239 }
240
241 return HDF_SUCCESS;
242 }
243
GetDevIns(struct AlsaCardsList * cardIns,int card,const char * cardId,int dev,const char * pcmInfoId)244 static int32_t GetDevIns(struct AlsaCardsList *cardIns, int card, const char *cardId, int dev, const char *pcmInfoId)
245 {
246 int32_t i;
247 int32_t ret;
248
249 if (cardIns == NULL || cardId == NULL || pcmInfoId == NULL || strlen(cardId) == 0) {
250 AUDIO_FUNC_LOGE("The parameter is empty!");
251 return HDF_FAILURE;
252 }
253
254 for (i = 0; i < MAX_CARD_NUM; i++) {
255 if (strlen(cardIns->alsaDevIns[i].cardId) == 0) {
256 cardIns->alsaDevIns[i].card = card;
257 cardIns->alsaDevIns[i].device = dev;
258 ret = strncpy_s(cardIns->alsaDevIns[i].cardId, MAX_CARD_NAME_LEN + 1, cardId, strlen(cardId));
259 if (ret != 0) {
260 AUDIO_FUNC_LOGE("strncpy_s failed!");
261 return HDF_FAILURE;
262 }
263 ret = strncpy_s(cardIns->alsaDevIns[i].pcmInfoId, MAX_CARD_NAME_LEN + 1, pcmInfoId, strlen(pcmInfoId));
264 if (ret != 0) {
265 AUDIO_FUNC_LOGE("strncpy_s failed!");
266 return HDF_FAILURE;
267 }
268 return HDF_SUCCESS;
269 }
270 }
271 AUDIO_FUNC_LOGE("A maximum of %{public}d sound cards are supported!", MAX_CARD_NUM);
272
273 return HDF_FAILURE;
274 }
275
CloseMixerHandle(snd_mixer_t * alsaMixHandle)276 int32_t CloseMixerHandle(snd_mixer_t *alsaMixHandle)
277 {
278 int32_t ret;
279
280 if (alsaMixHandle == NULL) {
281 return HDF_SUCCESS;
282 }
283
284 ret = snd_mixer_close(alsaMixHandle);
285 if (ret < 0) {
286 AUDIO_FUNC_LOGE("mixer close error: %{public}s.", snd_strerror(ret));
287 return HDF_FAILURE;
288 }
289
290 return HDF_SUCCESS;
291 }
292
InitSound(snd_mixer_t ** mixer,char * hwCtlName)293 void InitSound(snd_mixer_t **mixer, char *hwCtlName)
294 {
295 int32_t ret;
296
297 if (mixer == NULL || hwCtlName == NULL) {
298 AUDIO_FUNC_LOGE("The parameter is null.");
299 return;
300 }
301
302 ret = snd_mixer_open(mixer, 0);
303 if (ret < 0) {
304 AUDIO_FUNC_LOGE("Failed to open mixer: %{public}s.", snd_strerror(ret));
305 return;
306 }
307
308 ret = snd_mixer_attach(*mixer, hwCtlName);
309 if (ret < 0) {
310 AUDIO_FUNC_LOGE("Failed to attach mixer: %{public}s.", snd_strerror(ret));
311 ret = snd_mixer_close(*mixer);
312 if (ret < 0) {
313 AUDIO_FUNC_LOGE("mixer close error: %{public}s.", snd_strerror(ret));
314 }
315 return;
316 }
317
318 ret = snd_mixer_selem_register(*mixer, NULL, NULL);
319 if (ret < 0) {
320 AUDIO_FUNC_LOGE("Failed to register mixer element: %{public}s.", snd_strerror(ret));
321 ret = snd_mixer_close(*mixer);
322 if (ret < 0) {
323 AUDIO_FUNC_LOGE("mixer close error: %{public}s.", snd_strerror(ret));
324 }
325 return;
326 }
327
328 ret = snd_mixer_load(*mixer);
329 if (ret < 0) {
330 AUDIO_FUNC_LOGE("Failed to load mixer element: %{public}s.", snd_strerror(ret));
331 ret = snd_mixer_close(*mixer);
332 if (ret < 0) {
333 AUDIO_FUNC_LOGE("mixer close error: %{public}s.", snd_strerror(ret));
334 }
335 return;
336 }
337 }
338
HdfIoServiceBindName(const char * serviceName)339 struct HdfIoService *HdfIoServiceBindName(const char *serviceName)
340 {
341 (void)serviceName;
342 /* Nothing to do */
343 static struct HdfIoService hdfIoService;
344 return &hdfIoService;
345 }
346
GetDevCardsInfo(snd_ctl_t * handle,snd_ctl_card_info_t * info,snd_pcm_info_t * pcmInfo,struct AlsaCardsList * cardIns,struct CardStream cardStream)347 static void GetDevCardsInfo(snd_ctl_t *handle, snd_ctl_card_info_t *info, snd_pcm_info_t *pcmInfo,
348 struct AlsaCardsList *cardIns, struct CardStream cardStream)
349 {
350 int dev = -1;
351 int32_t ret;
352
353 if (handle == NULL || info == NULL || pcmInfo == NULL || cardIns == NULL) {
354 AUDIO_FUNC_LOGE("The parameter is empty.");
355 return;
356 }
357
358 while (1) {
359 ret = snd_ctl_pcm_next_device(handle, &dev);
360 if (ret < 0) {
361 AUDIO_FUNC_LOGE("snd_ctl_pcm_next_device error: %{public}s.", snd_strerror(ret));
362 }
363 if (dev < 0) {
364 break;
365 }
366
367 snd_pcm_info_set_device(pcmInfo, dev);
368 snd_pcm_info_set_subdevice(pcmInfo, 0);
369 snd_pcm_info_set_stream(pcmInfo, cardStream.stream);
370 if ((ret = snd_ctl_pcm_info(handle, pcmInfo)) < 0) {
371 if (ret != -ENOENT) {
372 AUDIO_FUNC_LOGE(
373 "control digital audio info (%{public}d): %{public}s", cardStream.card, snd_strerror(ret));
374 }
375 continue;
376 }
377
378 const char *cardId = snd_ctl_card_info_get_id(info);
379 const char *pcmInfoId = snd_pcm_info_get_id(pcmInfo);
380 ret = GetDevIns(cardIns, cardStream.card, cardId, dev, pcmInfoId);
381 if (ret < 0) {
382 AUDIO_FUNC_LOGE("GetDevIns error.");
383 return;
384 }
385 }
386 }
387
GetDeviceList(struct AlsaCardsList * cardIns,snd_pcm_stream_t stream)388 static void GetDeviceList(struct AlsaCardsList *cardIns, snd_pcm_stream_t stream)
389 {
390 int32_t ret;
391 snd_ctl_t *handle;
392 int card = -1;
393 snd_ctl_card_info_t *info = NULL;
394 snd_pcm_info_t *pcminfo = NULL;
395 char deviceName[MAX_CARD_NAME_LEN] = {0};
396 struct CardStream cardStream;
397
398 if (cardIns == NULL) {
399 AUDIO_FUNC_LOGE("The parameter is empty.");
400 return;
401 }
402 snd_ctl_card_info_alloca(&info);
403 snd_pcm_info_alloca(&pcminfo);
404
405 ret = snd_card_next(&card);
406 if (ret < 0 || card < 0) {
407 AUDIO_FUNC_LOGE("No soundcards found: %{public}s.", snd_strerror(ret));
408 return;
409 }
410 while (card >= 0) {
411 (void)memset_s(deviceName, MAX_CARD_NAME_LEN, 0, MAX_CARD_NAME_LEN);
412 ret = snprintf_s(deviceName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", card);
413 if (ret < 0) {
414 AUDIO_FUNC_LOGE("snprintf_s failed");
415 return;
416 }
417
418 ret = snd_ctl_open(&handle, deviceName, 0);
419 if (ret == HDF_SUCCESS) {
420 ret = snd_ctl_card_info(handle, info);
421 if (ret == HDF_SUCCESS) {
422 cardStream.card = card;
423 cardStream.stream = stream;
424 GetDevCardsInfo(handle, info, pcminfo, cardIns, cardStream);
425 }
426 ret = snd_ctl_close(handle);
427 if (ret < 0) {
428 AUDIO_FUNC_LOGE("mixer close error: %{public}s.", snd_strerror(ret));
429 return;
430 }
431 }
432
433 ret = snd_card_next(&card);
434 if (ret < 0) {
435 AUDIO_FUNC_LOGE("snd_card_next error: %{public}s", snd_strerror(ret));
436 return;
437 }
438 }
439 }
440
GetSelCardInfo(struct AudioCardInfo * cardIns,struct AlsaDevInfo * devInsHandle)441 int32_t GetSelCardInfo(struct AudioCardInfo *cardIns, struct AlsaDevInfo *devInsHandle)
442 {
443 int32_t ret;
444
445 if (cardIns == NULL || devInsHandle == NULL) {
446 AUDIO_FUNC_LOGE("The parameter is empty.");
447 return HDF_FAILURE;
448 }
449
450 ret = snprintf_s(cardIns->devName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "plughw:%d,%d", devInsHandle->card,
451 devInsHandle->device);
452 if (ret >= 0) {
453 ret = snprintf_s(cardIns->ctrlName, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "hw:%d", devInsHandle->card);
454 if (ret >= 0) {
455 ret = snprintf_s(cardIns->alsaCardId, MAX_CARD_NAME_LEN, MAX_CARD_NAME_LEN - 1, "%s", devInsHandle->cardId);
456 if (ret >= 0) {
457 return HDF_SUCCESS;
458 }
459 }
460 }
461 AUDIO_FUNC_LOGE("snprintf_s failed");
462
463 return HDF_FAILURE;
464 }
465
MatchPimarySoundCard(struct DevProcInfo * cardInfo[],const char * adapterName)466 static struct DevProcInfo *MatchPimarySoundCard(struct DevProcInfo *cardInfo[], const char *adapterName)
467 {
468 if (cardInfo == NULL || adapterName == NULL) {
469 AUDIO_FUNC_LOGE("The parameter is empty.");
470 return NULL;
471 }
472
473 if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) != 0) {
474 AUDIO_FUNC_LOGE("The user sound card name %{public}s is incorrect!", adapterName);
475 return NULL;
476 }
477
478 for (int i = 0; i < AUDIO_MAX_CARD_NUM; i++) {
479 if (cardInfo[i] != NULL) {
480 if (strncmp(cardInfo[i]->cardName, adapterName, strlen(adapterName)) == 0) {
481 return cardInfo[i];
482 }
483 }
484 }
485 AUDIO_FUNC_LOGE("No sound card selected by the user is matched from the configuration file.");
486
487 return NULL;
488 }
489
MatchHdmiSoundCard(struct DevProcInfo * cardInfo[],const char * adapterName)490 static struct DevProcInfo *MatchHdmiSoundCard(struct DevProcInfo *cardInfo[], const char *adapterName)
491 {
492 if (cardInfo == NULL || adapterName == NULL) {
493 AUDIO_FUNC_LOGE("The parameter is empty.");
494 return NULL;
495 }
496
497 if (strncmp(adapterName, HDMI, strlen(HDMI)) != 0) {
498 AUDIO_FUNC_LOGE("The user sound card name %{public}s is incorrect!", adapterName);
499 return NULL;
500 }
501
502 for (int i = 0; i < AUDIO_MAX_CARD_NUM; i++) {
503 if (cardInfo[i] != NULL) {
504 if (strncmp(cardInfo[i]->cardName, HDMI, strlen(HDMI)) == 0) {
505 return cardInfo[i];
506 }
507 }
508 }
509 AUDIO_FUNC_LOGE("No sound card selected by the user is matched from the configuration file.");
510
511 return NULL;
512 }
513
GetPrimaryCardInfo(struct AudioCardInfo * cardIns,struct AlsaCardsList * alsaCardsList)514 static int32_t GetPrimaryCardInfo(struct AudioCardInfo *cardIns, struct AlsaCardsList *alsaCardsList)
515 {
516 int32_t i;
517 int32_t ret;
518 struct DevProcInfo *primaryInfo = NULL;
519 struct DevProcInfo **cardInfo = NULL;
520
521 if (cardIns == NULL || alsaCardsList == NULL) {
522 AUDIO_FUNC_LOGE("The parameter is empty.");
523 return HDF_FAILURE;
524 }
525
526 cardInfo = AudioGetSoundCardsInfo(SND_CARD_PRIMARY);
527 if (cardInfo == NULL) {
528 AUDIO_FUNC_LOGE("The parameter is empty.");
529 return HDF_FAILURE;
530 }
531
532 primaryInfo = MatchPimarySoundCard(cardInfo, cardIns->cardName);
533 if (primaryInfo == NULL) {
534 AUDIO_FUNC_LOGE("get cardId is null.");
535 return HDF_FAILURE;
536 }
537
538 for (i = 0; i < MAX_CARD_NUM; i++) {
539 /** Built in codec */
540 if (strcmp(primaryInfo->cid, alsaCardsList->alsaDevIns[i].cardId) == 0) {
541 ret = GetSelCardInfo(cardIns, &alsaCardsList->alsaDevIns[i]);
542 if (ret != HDF_SUCCESS) {
543 AUDIO_FUNC_LOGE("GetSelCardInfo error.");
544 }
545 return ret;
546 }
547 }
548
549 return HDF_FAILURE;
550 }
551
GetUsbCardInfo(struct AudioCardInfo * cardIns,struct AlsaCardsList * alsaCardsList)552 static int32_t GetUsbCardInfo(struct AudioCardInfo *cardIns, struct AlsaCardsList *alsaCardsList)
553 {
554 int32_t i;
555 int32_t ret;
556
557 if (cardIns == NULL || alsaCardsList == NULL) {
558 AUDIO_FUNC_LOGE("The parameter is empty.");
559 return HDF_FAILURE;
560 }
561
562 for (i = 0; i < MAX_CARD_NUM; i++) {
563 /** External codec */
564 if (strcmp(USB_AUDIO, alsaCardsList->alsaDevIns[i].pcmInfoId) == 0) {
565 ret = GetSelCardInfo(cardIns, &alsaCardsList->alsaDevIns[i]);
566 if (ret != HDF_SUCCESS) {
567 AUDIO_FUNC_LOGE("GetSelCardInfo error.");
568 }
569 return ret;
570 }
571 }
572
573 return HDF_FAILURE;
574 }
575
GetHdmiCardInfo(struct AudioCardInfo * cardIns,struct AlsaCardsList * alsaCardsList)576 static int32_t GetHdmiCardInfo(struct AudioCardInfo *cardIns, struct AlsaCardsList *alsaCardsList)
577 {
578 int32_t i;
579 int32_t ret;
580 struct DevProcInfo *hdmiInfo = NULL;
581 struct DevProcInfo **hdmiCardInfo = NULL;
582
583 if (cardIns == NULL || alsaCardsList == NULL) {
584 AUDIO_FUNC_LOGE("The parameter is empty.");
585 return HDF_FAILURE;
586 }
587
588 hdmiCardInfo = AudioGetSoundCardsInfo(SND_CARD_HDMI);
589 if (hdmiCardInfo == NULL) {
590 AUDIO_FUNC_LOGE("The parameter is empty.");
591 return HDF_FAILURE;
592 }
593
594 hdmiInfo = MatchHdmiSoundCard(hdmiCardInfo, cardIns->cardName);
595 if (hdmiInfo == NULL) {
596 AUDIO_FUNC_LOGE("get cardId is null.");
597 return HDF_FAILURE;
598 }
599 for (i = 0; i < MAX_CARD_NUM; i++) {
600 /** hdmi codec */
601 if (strcmp(hdmiInfo->cid, alsaCardsList->alsaDevIns[i].cardId) == 0) {
602 ret = GetSelCardInfo(cardIns, &alsaCardsList->alsaDevIns[i]);
603 if (ret != HDF_SUCCESS) {
604 AUDIO_FUNC_LOGE("GetSelCardInfo error.");
605 }
606 return ret;
607 }
608 }
609
610 AUDIO_FUNC_LOGE("get hdmi cardId fail.");
611 return HDF_FAILURE;
612 }
613
MatchSelAdapter(const char * adapterName,struct AudioCardInfo * cardIns)614 int32_t MatchSelAdapter(const char *adapterName, struct AudioCardInfo *cardIns)
615 {
616 if (adapterName == NULL || cardIns == NULL) {
617 AUDIO_FUNC_LOGE("The parameter is empty.");
618 return HDF_FAILURE;
619 }
620
621 if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) {
622 return GetPrimaryCardInfo(cardIns, &g_alsaCardsList);
623 } else if (strncmp(adapterName, USB, strlen(USB)) == 0) {
624 return GetUsbCardInfo(cardIns, &g_alsaCardsList);
625 } else if (strncmp(adapterName, HDMI, strlen(HDMI)) == 0) {
626 return GetHdmiCardInfo(cardIns, &g_alsaCardsList);
627 } else if (strncmp(adapterName, A2DP, strlen(A2DP)) == 0) {
628 AUDIO_FUNC_LOGE("Currently not supported A2DP, please check!");
629 return HDF_ERR_NOT_SUPPORT;
630 } else {
631 AUDIO_FUNC_LOGE("The selected sound card not find, please check!");
632 return HDF_FAILURE;
633 }
634
635 return HDF_SUCCESS;
636 }
637
AudioUsbFindElement(snd_mixer_t * mixer,snd_pcm_stream_t stream)638 static snd_mixer_elem_t *AudioUsbFindElement(snd_mixer_t *mixer, snd_pcm_stream_t stream)
639 {
640 int i;
641 int count;
642 int32_t maxLoop = MAX_ELEMENT;
643 snd_mixer_elem_t *element = NULL;
644 char *mixerCtlName = NULL;
645 char **usbCtlVol = NULL;
646 if (mixer == NULL) {
647 AUDIO_FUNC_LOGE("The parameter is NULL!");
648 return NULL;
649 }
650
651 if (stream == SND_PCM_STREAM_PLAYBACK) {
652 usbCtlVol = g_usbSimpleRenderCtlVol;
653 count = sizeof(g_usbSimpleRenderCtlVol) / sizeof(char *);
654 } else {
655 usbCtlVol = g_usbSimpleCapCtlVol;
656 count = sizeof(g_usbSimpleCapCtlVol) / sizeof(char *);
657 }
658
659 for (element = snd_mixer_first_elem(mixer); element != NULL && maxLoop >= 0;
660 element = snd_mixer_elem_next(element)) {
661 for (i = 0; i < count; i++) {
662 mixerCtlName = usbCtlVol[i];
663 /* Compare whether the element name is the option we want to set */
664 if (strcmp(mixerCtlName, snd_mixer_selem_get_name(element)) == 0) {
665 return element;
666 }
667 }
668 maxLoop--;
669 }
670 return NULL;
671 }
672
AudioFindElement(const char * mixerCtlName,snd_mixer_t * mixer)673 static snd_mixer_elem_t *AudioFindElement(const char *mixerCtlName, snd_mixer_t *mixer)
674 {
675 int32_t maxLoop = MAX_ELEMENT;
676
677 if (mixerCtlName == NULL || mixer == NULL) {
678 AUDIO_FUNC_LOGE("The parameter is NULL!");
679 return NULL;
680 }
681 snd_mixer_elem_t *element = snd_mixer_first_elem(mixer);
682 if (element == NULL) {
683 AUDIO_FUNC_LOGE("snd_mixer_first_elem failed.");
684 return NULL;
685 }
686 while (element && maxLoop >= 0) {
687 /* Compare whether the element name is the option we want to set */
688 if (strcmp(mixerCtlName, snd_mixer_selem_get_name(element)) == 0) {
689 break;
690 }
691 /* If not, keep looking for the next one */
692 element = snd_mixer_elem_next(element);
693 maxLoop--;
694 }
695
696 if (element == NULL || maxLoop < 0) {
697 AUDIO_FUNC_LOGE("snd_mixer_find_selem Err\n");
698 return NULL;
699 }
700
701 return element;
702 }
703
GetPriMixerCtlElement(struct AudioCardInfo * cardIns,snd_mixer_t * mixer,snd_pcm_stream_t stream)704 int32_t GetPriMixerCtlElement(struct AudioCardInfo *cardIns, snd_mixer_t *mixer, snd_pcm_stream_t stream)
705 {
706 int32_t i;
707 struct DevProcInfo *primaryInfo = NULL;
708 struct DevProcInfo **cardInfo = NULL;
709
710 if (cardIns == NULL || mixer == NULL) {
711 AUDIO_FUNC_LOGE("The parameter is empty.");
712 return HDF_FAILURE;
713 }
714
715 cardInfo = AudioGetSoundCardsInfo(SND_CARD_PRIMARY);
716 if (cardInfo == NULL) {
717 AUDIO_FUNC_LOGE("The parameter is empty.");
718 return HDF_FAILURE;
719 }
720
721 primaryInfo = MatchPimarySoundCard(cardInfo, cardIns->cardName);
722 if (primaryInfo == NULL) {
723 AUDIO_FUNC_LOGE("get cardId is null.");
724 return HDF_FAILURE;
725 }
726
727 if (stream == SND_PCM_STREAM_PLAYBACK) {
728 cardIns->volElemCount = primaryInfo->ctlRenderVolNameCount;
729 cardIns->volElemList =
730 (struct AlsaMixerElem *)OsalMemCalloc(cardIns->volElemCount * sizeof(struct AlsaMixerElem));
731 if (cardIns->volElemList == NULL) {
732 AUDIO_FUNC_LOGE("PLAYBACK cardIns->volElemList Out of memory!");
733 return HDF_ERR_MALLOC_FAIL;
734 }
735 for (i = 0; i < (int32_t)cardIns->volElemCount; i++) {
736 cardIns->volElemList[i].elem = AudioFindElement(primaryInfo->ctlRenderNameList[i].name, mixer);
737 }
738 } else {
739 cardIns->volElemCount = primaryInfo->ctlCaptureVolNameCount;
740 cardIns->volElemList =
741 (struct AlsaMixerElem *)OsalMemCalloc(cardIns->volElemCount * sizeof(struct AlsaMixerElem));
742 if (cardIns->volElemList == NULL) {
743 AUDIO_FUNC_LOGE("CAPTURE cardIns->volElemList Out of memory!");
744 return HDF_ERR_MALLOC_FAIL;
745 }
746 for (i = 0; i < (int32_t)cardIns->volElemCount; i++) {
747 cardIns->volElemList[i].elem = AudioFindElement(primaryInfo->ctlCaptureNameList[i].name, mixer);
748 }
749 }
750
751 return HDF_SUCCESS;
752 }
753
AudioRenderSetVolumeRange(snd_mixer_elem_t * ctlElem)754 static int32_t AudioRenderSetVolumeRange(snd_mixer_elem_t *ctlElem)
755 {
756 int32_t ret;
757 long volMin = -1;
758 long volMax = -1;
759 if (ctlElem == NULL) {
760 AUDIO_FUNC_LOGE("ctlElem is NULL.");
761 return HDF_FAILURE;
762 }
763 ret = snd_mixer_selem_has_playback_volume(ctlElem);
764 /* ret is 0 if no control is present, 1 if it's present */
765 if (ret == 0) {
766 AUDIO_FUNC_LOGE("reason: %{public}s", snd_strerror(ret));
767 return HDF_SUCCESS;
768 }
769 ret = snd_mixer_selem_get_playback_volume_range(ctlElem, &volMin, &volMax);
770 if (ret < 0) {
771 AUDIO_FUNC_LOGE("Failed to get playback volume range: %{public}s", snd_strerror(ret));
772 return HDF_FAILURE;
773 }
774
775 if (volMin == MIN_VOLUME && volMax == MAX_VOLUME) {
776 return HDF_SUCCESS;
777 } else {
778 ret = snd_mixer_selem_set_playback_volume_range(ctlElem, MIN_VOLUME, MAX_VOLUME);
779 if (ret < 0) {
780 AUDIO_FUNC_LOGE("Failed to set playback volume range: %{public}s", snd_strerror(ret));
781 return HDF_FAILURE;
782 }
783 }
784 return HDF_SUCCESS;
785 }
786
AudioCaptureSetVolumeRange(snd_mixer_elem_t * ctlElem)787 static int32_t AudioCaptureSetVolumeRange(snd_mixer_elem_t *ctlElem)
788 {
789 int32_t ret;
790 long volMin = -1;
791 long volMax = -1;
792 if (ctlElem == NULL) {
793 AUDIO_FUNC_LOGE("ctlElem is NULL.");
794 return HDF_FAILURE;
795 }
796 ret = snd_mixer_selem_has_capture_volume(ctlElem);
797 /* ret is 0 if no control is present, 1 if it's present */
798 if (ret == 0) {
799 AUDIO_FUNC_LOGE("reason: %{public}s", snd_strerror(ret));
800 return HDF_SUCCESS;
801 }
802 ret = snd_mixer_selem_get_capture_volume_range(ctlElem, &volMin, &volMax);
803 if (ret < 0) {
804 AUDIO_FUNC_LOGE("Failed to get capture volume range: %{public}s", snd_strerror(ret));
805 return HDF_FAILURE;
806 }
807
808 if (volMin != MIN_VOLUME || volMax != MAX_VOLUME) {
809 ret = snd_mixer_selem_set_capture_volume_range(ctlElem, MIN_VOLUME, MAX_VOLUME);
810 if (ret < 0) {
811 AUDIO_FUNC_LOGE("Failed to set capture volume range: %{public}s", snd_strerror(ret));
812 return HDF_FAILURE;
813 }
814 }
815
816 return HDF_SUCCESS;
817 }
818
InitMixerCtrlVolumeRange(snd_mixer_elem_t * ctlElem,snd_pcm_stream_t stream)819 static int32_t InitMixerCtrlVolumeRange(snd_mixer_elem_t *ctlElem, snd_pcm_stream_t stream)
820 {
821 if (ctlElem == NULL) {
822 AUDIO_FUNC_LOGE("ctlElem is NULL.");
823 return HDF_FAILURE;
824 }
825
826 switch (stream) {
827 case SND_PCM_STREAM_PLAYBACK:
828 return AudioRenderSetVolumeRange(ctlElem);
829 case SND_PCM_STREAM_CAPTURE:
830 return AudioCaptureSetVolumeRange(ctlElem);
831 default:
832 AUDIO_FUNC_LOGE("stream is error!");
833 break;
834 }
835
836 return HDF_FAILURE;
837 }
838
AudioSetCtrlVolumeRange(struct AudioCardInfo * cardIns,const char * adapterName,snd_pcm_stream_t stream)839 int32_t AudioSetCtrlVolumeRange(struct AudioCardInfo *cardIns, const char *adapterName, snd_pcm_stream_t stream)
840 {
841 if (cardIns == NULL || adapterName == NULL) {
842 AUDIO_FUNC_LOGE("Parameter error!");
843 return HDF_FAILURE;
844 }
845
846 if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) {
847 for (int32_t i = 0; i < (int32_t)cardIns->volElemCount; i++) {
848 if (InitMixerCtrlVolumeRange(cardIns->volElemList[i].elem, stream) != HDF_SUCCESS) {
849 AUDIO_FUNC_LOGE("set valume failed!");
850 return HDF_FAILURE;
851 }
852 }
853 return HDF_SUCCESS;
854 }
855
856 if (strncmp(adapterName, USB, strlen(USB)) == 0) {
857 return InitMixerCtrlVolumeRange(cardIns->usbCtlVolume, stream);
858 }
859
860 if (strncmp(adapterName, HDMI, strlen(HDMI)) == 0) {
861 AUDIO_FUNC_LOGW("HDMI not ctlElement.");
862 return HDF_SUCCESS;
863 }
864
865 AUDIO_FUNC_LOGE("This type of sound card: %{public}s is not supported temporarily!", adapterName);
866 return HDF_FAILURE;
867 }
868
InitMixerCtlElement(const char * adapterName,struct AudioCardInfo * cardIns,snd_mixer_t * mixer,snd_pcm_stream_t stream)869 int32_t InitMixerCtlElement(
870 const char *adapterName, struct AudioCardInfo *cardIns, snd_mixer_t *mixer, snd_pcm_stream_t stream)
871 {
872 int32_t ret;
873
874 if (adapterName == NULL || cardIns == NULL || mixer == NULL) {
875 AUDIO_FUNC_LOGE("Parameter error!");
876 return HDF_FAILURE;
877 }
878
879 if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) {
880 ret = GetPriMixerCtlElement(cardIns, mixer, stream);
881 if (ret < 0) {
882 AUDIO_FUNC_LOGE("Render GetPriMixerCtlElement failed.");
883 return HDF_FAILURE;
884 }
885 } else if (strncmp(adapterName, USB, strlen(USB)) == 0) {
886 cardIns->usbCtlVolume = AudioUsbFindElement(mixer, stream);
887 } else if (strncmp(adapterName, HDMI, strlen(HDMI)) == 0) {
888 AUDIO_FUNC_LOGI("HDMI not ctlElement.");
889 return HDF_SUCCESS;
890 } else {
891 AUDIO_FUNC_LOGE("The selected sound card not supported, please check!");
892 return HDF_FAILURE;
893 }
894
895 ret = AudioSetCtrlVolumeRange(cardIns, adapterName, stream);
896 if (ret != HDF_SUCCESS) {
897 AUDIO_FUNC_LOGI("AudioSetCtrlVolumeRange failed.");
898 return ret;
899 }
900
901 return HDF_SUCCESS;
902 }
903
AudioGetCardInstance(const char * adapterName)904 struct AudioCardInfo *AudioGetCardInstance(const char *adapterName)
905 {
906 int32_t ret;
907
908 if (adapterName == NULL) {
909 AUDIO_FUNC_LOGE("The parameter is empty.");
910 return NULL;
911 }
912
913 ret = InitCardIns();
914 if (ret != HDF_SUCCESS) {
915 AUDIO_FUNC_LOGE("Failed to initialize sound card information.");
916 return NULL;
917 }
918
919 ret = AudioAddCardIns(adapterName);
920 if (ret < 0) {
921 AUDIO_FUNC_LOGE("AudioAddCardIns failed.");
922 return NULL;
923 }
924
925 return GetCardIns(adapterName);
926 }
927
AudioGetCardInfo(struct AudioCardInfo * cardIns,const char * adapterName,snd_pcm_stream_t stream)928 int32_t AudioGetCardInfo(struct AudioCardInfo *cardIns, const char *adapterName, snd_pcm_stream_t stream)
929 {
930 if (cardIns == NULL || adapterName == NULL) {
931 AUDIO_FUNC_LOGE("The parameter is empty.");
932 return HDF_FAILURE;
933 }
934
935 /* Parse sound card from configuration file */
936 if (CardInfoParseFromConfig() != HDF_SUCCESS) {
937 AUDIO_FUNC_LOGE("parse config file failed!");
938 return HDF_FAILURE;
939 }
940 /* Read sound card list from alsa hardware */
941 (void)memset_s(&g_alsaCardsList, sizeof(struct AlsaCardsList), 0, sizeof(struct AlsaCardsList));
942 GetDeviceList(&g_alsaCardsList, stream);
943
944 if (MatchSelAdapter(adapterName, cardIns) < 0) {
945 AUDIO_FUNC_LOGE("MatchSelAdapter is error.");
946 return HDF_FAILURE;
947 }
948
949 return HDF_SUCCESS;
950 }
951
CheckParaFormat(struct AudioPcmHwParams hwParams,snd_pcm_format_t * alsaPcmFormat)952 int32_t CheckParaFormat(struct AudioPcmHwParams hwParams, snd_pcm_format_t *alsaPcmFormat)
953 {
954 if (alsaPcmFormat == NULL) {
955 AUDIO_FUNC_LOGE("paras is NULL!");
956 return HDF_FAILURE;
957 }
958 enum AudioFormat audioFormat = hwParams.format;
959 bool isBigEndian = hwParams.isBigEndian;
960
961 /** Little Endian */
962 if (!isBigEndian) {
963 switch (audioFormat) {
964 case AUDIO_FORMAT_TYPE_PCM_8_BIT:
965 *alsaPcmFormat = SND_PCM_FORMAT_S8; /** Signed 8 bit */
966 break;
967 case AUDIO_FORMAT_TYPE_PCM_16_BIT:
968 *alsaPcmFormat = SND_PCM_FORMAT_S16_LE; /** Signed 16 bit Little Endian */
969 break;
970 case AUDIO_FORMAT_TYPE_PCM_24_BIT:
971 *alsaPcmFormat = SND_PCM_FORMAT_S24_LE; /** Signed 24 bit Little Endian */
972 break;
973 case AUDIO_FORMAT_TYPE_PCM_32_BIT:
974 *alsaPcmFormat = SND_PCM_FORMAT_S32_LE; /** Signed 32 bit Little Endian */
975 break;
976 default:
977 return HDF_ERR_NOT_SUPPORT;
978 }
979 } else { /** Big Endian */
980 switch (audioFormat) {
981 case AUDIO_FORMAT_TYPE_PCM_8_BIT:
982 *alsaPcmFormat = SND_PCM_FORMAT_S8; /** Signed 8 bit */
983 break;
984 case AUDIO_FORMAT_TYPE_PCM_16_BIT:
985 *alsaPcmFormat = SND_PCM_FORMAT_S16_BE; /** Signed 16 bit Big Endian */
986 break;
987 case AUDIO_FORMAT_TYPE_PCM_24_BIT:
988 *alsaPcmFormat = SND_PCM_FORMAT_S24_BE; /** Signed 24 bit Big Endian */
989 break;
990 case AUDIO_FORMAT_TYPE_PCM_32_BIT:
991 *alsaPcmFormat = SND_PCM_FORMAT_S32_BE; /** Signed 32 bit Big Endian */
992 break;
993 default:
994 return HDF_ERR_NOT_SUPPORT;
995 }
996 }
997
998 return HDF_SUCCESS;
999 }
1000
AudioAdaptersGetConfig(const char * fpath)1001 static char *AudioAdaptersGetConfig(const char *fpath)
1002 {
1003 int32_t jsonStrSize;
1004 FILE *fp = NULL;
1005 char *pJsonStr = NULL;
1006 char pathBuf[PATH_MAX] = {0};
1007
1008 if (fpath == NULL) {
1009 AUDIO_FUNC_LOGE("Parameter is null!!!");
1010 return NULL;
1011 }
1012 if (realpath(fpath, pathBuf) == NULL) {
1013 AUDIO_FUNC_LOGE("File path invalid!");
1014 return NULL;
1015 }
1016
1017 fp = fopen(pathBuf, "r");
1018 if (fp == NULL) {
1019 AUDIO_FUNC_LOGE("Can not open config file [ %{public}s ].", fpath);
1020 return NULL;
1021 }
1022 if (fseek(fp, 0, SEEK_END) != 0) {
1023 AUDIO_FUNC_LOGE("fseek configuration file error!");
1024 (void)fclose(fp);
1025 return NULL;
1026 }
1027 jsonStrSize = ftell(fp);
1028 if (jsonStrSize <= 0) {
1029 AUDIO_FUNC_LOGE("The configuration file size <= 0!");
1030 (void)fclose(fp);
1031 return NULL;
1032 }
1033 rewind(fp);
1034 if (jsonStrSize > ALSA_CONFIG_FILE_MAX) {
1035 AUDIO_FUNC_LOGE("The configuration file is too large to load!");
1036 (void)fclose(fp);
1037 return NULL;
1038 }
1039 pJsonStr = (char *)OsalMemCalloc((uint32_t)jsonStrSize + 1);
1040 if (pJsonStr == NULL) {
1041 AUDIO_FUNC_LOGE("OsalMemCalloc pJsonStr failed!");
1042 (void)fclose(fp);
1043 return NULL;
1044 }
1045 if (fread(pJsonStr, jsonStrSize, 1, fp) != 1) {
1046 AUDIO_FUNC_LOGE("Read to config file failed!!!");
1047 (void)fclose(fp);
1048 AudioMemFree((void **)&pJsonStr);
1049 return NULL;
1050 }
1051 (void)fclose(fp);
1052
1053 return pJsonStr;
1054 }
1055
AudioCardGetConfig(const char * fpath)1056 static cJSON *AudioCardGetConfig(const char *fpath)
1057 {
1058 char *pJsonStr = NULL;
1059 cJSON *cJsonObj = NULL;
1060
1061 if (fpath == NULL) {
1062 AUDIO_FUNC_LOGE("Parameter error!");
1063 return NULL;
1064 }
1065
1066 pJsonStr = AudioAdaptersGetConfig(fpath);
1067 if (pJsonStr == NULL) {
1068 AUDIO_FUNC_LOGE("AudioAdaptersGetConfig failed!");
1069 return NULL;
1070 }
1071
1072 cJsonObj = cJSON_Parse(pJsonStr);
1073 if (cJsonObj == NULL) {
1074 AUDIO_FUNC_LOGE("AudioAdaptersGetConfig failed!");
1075 AudioMemFree((void **)&pJsonStr);
1076 return NULL;
1077 }
1078 AudioMemFree((void **)&pJsonStr);
1079
1080 return cJsonObj;
1081 }
1082
AudioAdapterCheckName(const char * name)1083 static int32_t AudioAdapterCheckName(const char *name)
1084 {
1085 uint32_t len;
1086 const char *strName = name;
1087
1088 if (strName == NULL) {
1089 AUDIO_FUNC_LOGE("Invalid parameter!");
1090 return HDF_FAILURE;
1091 }
1092
1093 len = strlen(strName);
1094 if (len == 0 || len >= CARD_ID_LEN_MAX) {
1095 AUDIO_FUNC_LOGW("name len is zero or too long!, len = %{public}d", len);
1096 return HDF_FAILURE;
1097 }
1098
1099 if (!isalpha(*strName++)) { // Names must begin with a letter
1100 AUDIO_FUNC_LOGE("The name of the illegal!");
1101 return HDF_FAILURE;
1102 }
1103
1104 while (*strName != '\0') {
1105 if (*strName == '_' || *strName == '-') {
1106 strName++;
1107 continue;
1108 }
1109
1110 if (!isalnum(*strName++)) {
1111 AUDIO_FUNC_LOGE("The name of the illegal!");
1112 return HDF_FAILURE;
1113 }
1114 }
1115
1116 return HDF_SUCCESS;
1117 }
1118
AudioAdapterNameToType(const char * name)1119 static enum SndCardType AudioAdapterNameToType(const char *name)
1120 {
1121 enum SndCardType cardType = SND_CARD_UNKNOWN;
1122
1123 if (name == NULL) {
1124 AUDIO_FUNC_LOGE("Invalid parameter!");
1125 return SND_CARD_UNKNOWN;
1126 }
1127
1128 if (strcmp(name, "primary") == 0) {
1129 cardType = SND_CARD_PRIMARY;
1130 } else if (strcmp(name, "hdmi") == 0) {
1131 cardType = SND_CARD_HDMI;
1132 } else if (strcmp(name, "usb") == 0) {
1133 cardType = SND_CARD_USB;
1134 } else if (strcmp(name, "bt") == 0) {
1135 cardType = SND_CARD_BT;
1136 }
1137
1138 return cardType;
1139 }
1140
AudioGetVolumeJsonObj(cJSON * object,cJSON ** volumeJsonObj,const char * ctlName)1141 static int32_t AudioGetVolumeJsonObj(cJSON *object, cJSON **volumeJsonObj, const char *ctlName)
1142 {
1143 if (object == NULL || volumeJsonObj == NULL || ctlName == NULL) {
1144 AUDIO_FUNC_LOGE("Parameters is NULL!");
1145 return HDF_FAILURE;
1146 }
1147
1148 cJSON *ctlObjList = cJSON_GetObjectItem(object, ctlName);
1149 if (ctlObjList == NULL) {
1150 AUDIO_FUNC_LOGE("secondItem[%{public}s] Get Object Fail!", ctlName);
1151 return HDF_FAILURE;
1152 }
1153 *volumeJsonObj = ctlObjList;
1154 return HDF_SUCCESS;
1155 }
1156
AudioGetRenderVolumeInstance(struct DevProcInfo * adapter,cJSON * ctlVolumeList)1157 static int32_t AudioGetRenderVolumeInstance(struct DevProcInfo *adapter, cJSON *ctlVolumeList)
1158 {
1159 int32_t ret;
1160 cJSON *listSub = NULL;
1161 char *ctlName = NULL;
1162 cJSON *nodeCtlName = NULL;
1163
1164 if (adapter == NULL || ctlVolumeList == NULL) {
1165 AUDIO_FUNC_LOGE("Parameter is null");
1166 return HDF_FAILURE;
1167 }
1168
1169 int32_t arraySize = cJSON_GetArraySize(ctlVolumeList);
1170 if (arraySize < 0 || arraySize > MIXER_CTL_MAX_NUM) {
1171 AUDIO_FUNC_LOGE("Maximum support: %{public}d, but actually is %{public}d.", MIXER_CTL_MAX_NUM, arraySize);
1172 return HDF_FAILURE;
1173 }
1174
1175 adapter->ctlRenderVolNameCount = arraySize;
1176 adapter->ctlRenderNameList =
1177 (struct MixerCtlVolumeName *)OsalMemCalloc(arraySize * sizeof(struct MixerCtlVolumeName));
1178 if (adapter->ctlRenderNameList == NULL) {
1179 AUDIO_FUNC_LOGE("Out of memory!");
1180 return HDF_ERR_MALLOC_FAIL;
1181 }
1182
1183 for (int32_t index = 0; index < arraySize; index++) {
1184 listSub = cJSON_GetArrayItem(ctlVolumeList, index);
1185 if (listSub == NULL) {
1186 AUDIO_FUNC_LOGE("cJSON_GetArrayItem failed, listSub is NULL!");
1187 AudioMemFree((void **)&adapter->ctlRenderNameList);
1188 return HDF_FAILURE;
1189 }
1190 if ((nodeCtlName = cJSON_GetObjectItem(listSub, "name")) == NULL) {
1191 AudioMemFree((void **)&adapter->ctlRenderNameList);
1192 AUDIO_FUNC_LOGE("cJSON_GetObjectItem Failed!");
1193 return HDF_FAILURE;
1194 }
1195 ctlName = nodeCtlName->valuestring;
1196 ret = strncpy_s(adapter->ctlRenderNameList[index].name, ALSA_CTL_NAME_LEN - 1, ctlName, strlen(ctlName));
1197 if (ret != 0) {
1198 AUDIO_FUNC_LOGE("strncpy_s failed!");
1199 AudioMemFree((void **)&adapter->ctlRenderNameList);
1200 return HDF_FAILURE;
1201 }
1202 }
1203
1204 return HDF_SUCCESS;
1205 }
1206
AudioGetCaptureVolumeInstance(struct DevProcInfo * adapter,cJSON * ctlCaptureVolList)1207 static int32_t AudioGetCaptureVolumeInstance(struct DevProcInfo *adapter, cJSON *ctlCaptureVolList)
1208 {
1209 int32_t ret;
1210 cJSON *listSub = NULL;
1211 char *ctlName = NULL;
1212 cJSON *nodeCtlName = NULL;
1213
1214 if (adapter == NULL || ctlCaptureVolList == NULL) {
1215 AUDIO_FUNC_LOGE("Parameter is null");
1216 return HDF_FAILURE;
1217 }
1218 int32_t arraySize = cJSON_GetArraySize(ctlCaptureVolList);
1219 if (arraySize < 0 || arraySize > MIXER_CTL_MAX_NUM) {
1220 AUDIO_FUNC_LOGE("Maximum support: %{public}d, but actually is %{public}d.", MIXER_CTL_MAX_NUM, arraySize);
1221 return HDF_FAILURE;
1222 }
1223 adapter->ctlCaptureVolNameCount = arraySize;
1224 adapter->ctlCaptureNameList =
1225 (struct MixerCtlVolumeName *)OsalMemCalloc(arraySize * sizeof(struct MixerCtlVolumeName));
1226 if (adapter->ctlCaptureNameList == NULL) {
1227 AUDIO_FUNC_LOGE("Out of memory!");
1228 return HDF_ERR_MALLOC_FAIL;
1229 }
1230 for (int32_t index = 0; index < arraySize; index++) {
1231 listSub = cJSON_GetArrayItem(ctlCaptureVolList, index);
1232 if (listSub == NULL) {
1233 AUDIO_FUNC_LOGE("cJSON_GetArrayItem failed, listSub is NULL!");
1234 AudioMemFree((void **)&adapter->ctlCaptureNameList);
1235 return HDF_FAILURE;
1236 }
1237 if ((nodeCtlName = cJSON_GetObjectItem(listSub, "name")) == NULL) {
1238 AudioMemFree((void **)&adapter->ctlCaptureNameList);
1239 AUDIO_FUNC_LOGE("cJSON_GetObjectItem Failed!");
1240 return HDF_FAILURE;
1241 }
1242 ctlName = nodeCtlName->valuestring;
1243 ret = strncpy_s(adapter->ctlCaptureNameList[index].name, ALSA_CTL_NAME_LEN - 1, ctlName, strlen(ctlName));
1244 if (ret != 0) {
1245 AUDIO_FUNC_LOGE("strncpy_s failed!");
1246 AudioMemFree((void **)&adapter->ctlCaptureNameList);
1247 return HDF_FAILURE;
1248 }
1249 }
1250 return HDF_SUCCESS;
1251 }
1252
AudioGetVolumeControls(cJSON * object,struct DevProcInfo * adapter)1253 static int32_t AudioGetVolumeControls(cJSON *object, struct DevProcInfo *adapter)
1254 {
1255 int32_t ret;
1256 cJSON *ctlVolumeObj = NULL;
1257 cJSON *ctlRenderVolumeList = NULL;
1258 cJSON *ctlCaptureVolumeList = NULL;
1259
1260 if (object == NULL || adapter == NULL) {
1261 AUDIO_FUNC_LOGE("Parameter is null");
1262 return HDF_FAILURE;
1263 }
1264 ctlVolumeObj = cJSON_GetObjectItem(object, MIXER_CTL_VOLUME);
1265 if (ctlVolumeObj == NULL) {
1266 AUDIO_FUNC_LOGE("cJSON_GetObjectItem failed!");
1267 return HDF_FAILURE;
1268 }
1269 ret = AudioGetVolumeJsonObj(ctlVolumeObj, &ctlRenderVolumeList, PLAYBACK);
1270 if (ret != HDF_SUCCESS) {
1271 AUDIO_FUNC_LOGE("AudioGetVolumeJsonObj failed.");
1272 return ret;
1273 }
1274
1275 ret = AudioGetVolumeJsonObj(ctlVolumeObj, &ctlCaptureVolumeList, CAPTURE);
1276 if (ret != HDF_SUCCESS) {
1277 AUDIO_FUNC_LOGE("AudioGetVolumeJsonObj failed.");
1278 return ret;
1279 }
1280
1281 ret = AudioGetRenderVolumeInstance(adapter, ctlRenderVolumeList);
1282 if (ret != HDF_SUCCESS) {
1283 AUDIO_FUNC_LOGE("AudioGetVolumeInstance failed.");
1284 return ret;
1285 }
1286 ret = AudioGetCaptureVolumeInstance(adapter, ctlCaptureVolumeList);
1287 if (ret != HDF_SUCCESS) {
1288 AUDIO_FUNC_LOGE("AudioGetVolumeInstance failed.");
1289 return ret;
1290 }
1291 return HDF_SUCCESS;
1292 }
1293
AudioAdapterInfoSet(cJSON * adapterObj,struct DevProcInfo * cardDev,enum SndCardType cardType)1294 static int32_t AudioAdapterInfoSet(cJSON *adapterObj, struct DevProcInfo *cardDev, enum SndCardType cardType)
1295 {
1296 int32_t ret;
1297 struct DevProcInfo *adapter = NULL;
1298
1299 if (cardDev == NULL || adapterObj == NULL) {
1300 AUDIO_FUNC_LOGE("Invalid parameter!");
1301 return HDF_FAILURE;
1302 }
1303
1304 adapter = (struct DevProcInfo *)OsalMemCalloc(sizeof(struct DevProcInfo));
1305 if (adapter == NULL) {
1306 AUDIO_FUNC_LOGE("calloc cardDev failed!");
1307 return HDF_FAILURE;
1308 }
1309
1310 ret = memcpy_s(adapter->cardName, CARD_ID_LEN_MAX - 1, cardDev->cardName, CARD_ID_LEN_MAX - 1);
1311 if (ret != EOK) {
1312 AUDIO_FUNC_LOGE("memcpy_s adapter card name fail!");
1313 AudioMemFree((void **)&adapter);
1314 return HDF_FAILURE;
1315 }
1316 ret = memcpy_s(adapter->cid, CARD_ID_LEN_MAX - 1, cardDev->cid, CARD_ID_LEN_MAX - 1);
1317 if (ret != EOK) {
1318 AUDIO_FUNC_LOGE("memcpy_s adapter card id fail!");
1319 AudioMemFree((void **)&adapter);
1320 return HDF_FAILURE;
1321 }
1322 ret = memcpy_s(adapter->did, CARD_ID_LEN_MAX - 1, cardDev->did, CARD_ID_LEN_MAX - 1);
1323 if (ret != EOK) {
1324 AUDIO_FUNC_LOGE("memcpy_s adapter dai id fail!");
1325 /* Only log is printed and cannot be returned */
1326 }
1327
1328 if (strncmp(cardDev->cardName, PRIMARY, strlen(PRIMARY)) == 0) {
1329 ret = AudioGetVolumeControls(adapterObj, adapter);
1330 if (ret < 0) {
1331 AUDIO_FUNC_LOGE("AudioGetVolumeControls failed!");
1332 return HDF_FAILURE;
1333 }
1334 }
1335
1336 for (int cardNum = 0; cardNum < AUDIO_MAX_CARD_NUM; cardNum++) {
1337 if (g_sndCardList[cardType][cardNum] == NULL) {
1338 g_sndCardList[cardType][cardNum] = adapter;
1339 break;
1340 }
1341
1342 if (cardNum == AUDIO_MAX_CARD_NUM - 1) {
1343 AUDIO_FUNC_LOGE("The maximum limit for a single type of sound card is %{public}d.", AUDIO_MAX_CARD_NUM);
1344 AudioMemFree((void **)&adapter);
1345 return HDF_FAILURE;
1346 }
1347 }
1348
1349 return HDF_SUCCESS;
1350 }
1351
AudioGetItemString(cJSON * adapter,char * name)1352 static cJSON *AudioGetItemString(cJSON *adapter, char *name)
1353 {
1354 int32_t ret;
1355 cJSON *item = NULL;
1356
1357 if (adapter == NULL || name == NULL) {
1358 AUDIO_FUNC_LOGE("Invalid parameter!");
1359 return NULL;
1360 }
1361
1362 item = cJSON_GetObjectItem(adapter, name);
1363 if (item == NULL) {
1364 AUDIO_FUNC_LOGE("item is null!");
1365 return NULL;
1366 }
1367 if (item->valuestring == NULL) {
1368 AUDIO_FUNC_LOGE("item valuestring is null!");
1369 return NULL;
1370 }
1371
1372 ret = AudioAdapterCheckName(item->valuestring);
1373 if (ret < 0) {
1374 if (strncmp(name, "daiId", sizeof("daiId")) != 0) {
1375 AUDIO_FUNC_LOGE("The %{public}s name incorrect!", name);
1376 }
1377 return NULL;
1378 }
1379
1380 return item;
1381 }
1382
AudioGetAllItem(cJSON * adapter,struct DevProcInfo * cardDev)1383 static int32_t AudioGetAllItem(cJSON *adapter, struct DevProcInfo *cardDev)
1384 {
1385 int32_t ret;
1386 cJSON *adapterName = NULL;
1387 cJSON *cid = NULL;
1388 cJSON *did = NULL;
1389
1390 if (adapter == NULL || cardDev == NULL) {
1391 AUDIO_FUNC_LOGE("Invalid parameter!");
1392 return HDF_FAILURE;
1393 }
1394
1395 adapterName = AudioGetItemString(adapter, "name");
1396 if (adapterName == NULL) {
1397 AUDIO_FUNC_LOGE("Get adapterName failed!");
1398 return HDF_FAILURE;
1399 }
1400 ret = memcpy_s(cardDev->cardName, CARD_ID_LEN_MAX - 1, adapterName->valuestring, CARD_ID_LEN_MAX - 1);
1401 if (ret != EOK) {
1402 AUDIO_FUNC_LOGE("memcpy_s adapter card name fail!");
1403 return HDF_FAILURE;
1404 }
1405
1406 cid = AudioGetItemString(adapter, "cardId");
1407 if (cid == NULL) {
1408 AUDIO_FUNC_LOGE("Get cid failed!");
1409 return HDF_FAILURE;
1410 }
1411 ret = memcpy_s(cardDev->cid, CARD_ID_LEN_MAX - 1, cid->valuestring, CARD_ID_LEN_MAX - 1);
1412 if (ret != EOK) {
1413 AUDIO_FUNC_LOGE("memcpy_s adapter card id fail!");
1414 return HDF_FAILURE;
1415 }
1416
1417 did = AudioGetItemString(adapter, "daiId");
1418 if (did == NULL) { // Not all sound cards have dai id.
1419 return HDF_SUCCESS;
1420 }
1421 ret = memcpy_s(cardDev->did, CARD_ID_LEN_MAX - 1, did->valuestring, CARD_ID_LEN_MAX - 1);
1422 if (ret != EOK) {
1423 AUDIO_FUNC_LOGE("memcpy_s adapter card id fail!");
1424 /* Only log is printed and cannot be returned */
1425 }
1426
1427 return HDF_SUCCESS;
1428 }
1429
AudioParseAdapter(cJSON * adapterObj)1430 static int32_t AudioParseAdapter(cJSON *adapterObj)
1431 {
1432 int ret;
1433 struct DevProcInfo cardDev;
1434 enum SndCardType cardType = SND_CARD_UNKNOWN;
1435
1436 if (adapterObj == NULL) {
1437 AUDIO_FUNC_LOGE("Parameter error!\n");
1438 return HDF_FAILURE;
1439 }
1440
1441 (void)memset_s(&cardDev, sizeof(struct DevProcInfo), 0, sizeof(struct DevProcInfo));
1442 ret = AudioGetAllItem(adapterObj, &cardDev);
1443 if (ret < 0) {
1444 AUDIO_FUNC_LOGE("AudioGetAllItem failed!\n");
1445 return ret;
1446 }
1447 cardType = AudioAdapterNameToType(cardDev.cardName);
1448 switch (cardType) {
1449 case SND_CARD_PRIMARY:
1450 case SND_CARD_HDMI:
1451 case SND_CARD_USB:
1452 case SND_CARD_BT:
1453 ret = AudioAdapterInfoSet(adapterObj, &cardDev, cardType);
1454 if (ret < 0) {
1455 AUDIO_FUNC_LOGE("AudioAdapterInfoSet failed!\n");
1456 return ret;
1457 }
1458 break;
1459 default:
1460 AUDIO_FUNC_LOGE("Sound card unknown!\n");
1461 return HDF_FAILURE;
1462 }
1463
1464 return HDF_SUCCESS;
1465 }
1466
AudioAdaptersSetAdapterVar(cJSON * cJsonObj)1467 static int32_t AudioAdaptersSetAdapterVar(cJSON *cJsonObj)
1468 {
1469 int32_t ret;
1470 cJSON *adapterObj = NULL;
1471
1472 if (cJsonObj == NULL) {
1473 AUDIO_FUNC_LOGE("Parameter error!");
1474 return HDF_FAILURE;
1475 }
1476
1477 int32_t adaptersArraySize = cJSON_GetArraySize(cJsonObj);
1478 if (adaptersArraySize <= 0) {
1479 AUDIO_FUNC_LOGE("Failed to get JSON array size!");
1480 return HDF_FAILURE;
1481 }
1482 if (adaptersArraySize > MAX_CARD_NUM) {
1483 AUDIO_FUNC_LOGE("Read adapters number is %{public}d!", adaptersArraySize);
1484 AUDIO_FUNC_LOGE("The number of sound cards exceeds the upper limit %{public}d.", MAX_CARD_NUM);
1485 return HDF_FAILURE;
1486 }
1487 g_sndCardsNum = adaptersArraySize;
1488 for (int32_t i = 0; i < adaptersArraySize; i++) {
1489 adapterObj = cJSON_GetArrayItem(cJsonObj, i);
1490 if (adapterObj != NULL) {
1491 ret = AudioParseAdapter(adapterObj);
1492 if (ret < 0) {
1493 AUDIO_FUNC_LOGE("AudioParseAdapter (%{public}d) error!", i);
1494 return HDF_FAILURE;
1495 }
1496 adapterObj = NULL;
1497 }
1498 }
1499
1500 return HDF_SUCCESS;
1501 }
1502
CardInfoParseFromConfig(void)1503 int32_t CardInfoParseFromConfig(void)
1504 {
1505 int32_t ret;
1506 cJSON *cJsonObj = NULL;
1507 cJSON *adaptersObj = NULL;
1508
1509 if (g_parseFlag) {
1510 return HDF_SUCCESS;
1511 }
1512
1513 cJsonObj = AudioCardGetConfig(ALSA_CARD_CONFIG_FILE);
1514 if (cJsonObj == NULL) {
1515 AUDIO_FUNC_LOGE("AudioCardGetConfig failed!\n");
1516 return HDF_FAILURE;
1517 }
1518
1519 adaptersObj = cJSON_GetObjectItem(cJsonObj, "adapters");
1520 if (adaptersObj == NULL) {
1521 AUDIO_FUNC_LOGE("cJSON_GetObjectItem adapters failed!\n");
1522 cJSON_Delete(cJsonObj);
1523 return HDF_FAILURE;
1524 }
1525
1526 ret = AudioAdaptersSetAdapterVar(adaptersObj);
1527 if (ret < 0) {
1528 AUDIO_FUNC_LOGE("AudioAdaptersSetAdapterVar is failed!\n");
1529 cJSON_Delete(cJsonObj);
1530 return HDF_FAILURE;
1531 }
1532 cJSON_Delete(cJsonObj);
1533 g_parseFlag = true;
1534
1535 return HDF_SUCCESS;
1536 }
1537
AudioBindService(const char * name)1538 struct DevHandle *AudioBindService(const char *name)
1539 {
1540 (void)name;
1541 struct DevHandle *handle = (struct DevHandle *)OsalMemCalloc(sizeof(struct DevHandle));
1542 if (handle == NULL) {
1543 AUDIO_FUNC_LOGE("OsalMemCalloc handle failed!!!");
1544 return NULL;
1545 }
1546
1547 static struct HdfIoService hdfIoService;
1548 handle->object = &hdfIoService;
1549 return handle;
1550 }
1551
AudioCloseService(const struct DevHandle * handle)1552 void AudioCloseService(const struct DevHandle *handle)
1553 {
1554 if (handle != NULL) {
1555 if (handle->object == NULL) {
1556 AUDIO_FUNC_LOGE("handle or handle->object is NULL");
1557 }
1558 AudioMemFree((void **)&handle);
1559 }
1560 }
1561
AudioPortNameFree(struct AudioPort * dataBlock,uint32_t portsLen)1562 static void AudioPortNameFree(struct AudioPort *dataBlock, uint32_t portsLen)
1563 {
1564 if (dataBlock == NULL) {
1565 return;
1566 }
1567
1568 for (uint32_t i = 0; i < portsLen; i++) {
1569 OsalMemFree((void *)dataBlock[i].portName);
1570 dataBlock[i].portName = NULL;
1571 }
1572 OsalMemFree(dataBlock);
1573 }
1574
AudioFreeDesc(struct AudioAdapterDescriptor ** descList,uint32_t sndCardNum)1575 static void AudioFreeDesc(struct AudioAdapterDescriptor **descList, uint32_t sndCardNum)
1576 {
1577 if (descList == NULL || *descList == NULL) {
1578 AUDIO_FUNC_LOGE("AudioFreeDesc failed!");
1579 return;
1580 }
1581
1582 for (uint32_t index = 0; index < sndCardNum; index++) {
1583 if ((*descList)[index].adapterName != NULL) {
1584 AudioMemFree((void **)&((*descList)[index].adapterName));
1585 (*descList)[index].adapterName = NULL;
1586 }
1587 #ifndef AUDIO_HDI_SERVICE_MODE
1588 AudioPortNameFree((*descList)[index].ports, (*descList)[index].portNum);
1589 #else
1590 AudioPortNameFree((*descList)[index].ports, (*descList)[index].portsLen);
1591 #endif
1592 }
1593
1594 AudioMemFree((void **)descList);
1595 }
1596
AudioMatchCardName(char * cardName,int32_t cardType,int32_t cardNum)1597 static char *AudioMatchCardName(char *cardName, int32_t cardType, int32_t cardNum)
1598 {
1599 if (strcmp(cardName, PRIMARY) == 0) {
1600 g_sndCardList[cardType][cardNum]->cardName[0] = 0;
1601 return strdup("primary");
1602 } else if (strcmp(cardName, HDMI) == 0) {
1603 g_sndCardList[cardType][cardNum]->cardName[0] = 0;
1604 return strdup("hdmi");
1605 } else {
1606 AUDIO_FUNC_LOGI("audio card fail to identify");
1607 }
1608 return NULL;
1609 }
1610
AudioCardNameTransform(void)1611 static char *AudioCardNameTransform(void)
1612 {
1613 for (int32_t i = 0; i < SND_CARD_MAX; i++) {
1614 for (int32_t j = 0; j < AUDIO_MAX_CARD_NUM; j++) {
1615 if (g_sndCardList[i][j] != NULL && strlen(g_sndCardList[i][j]->cardName) != 0) {
1616 return AudioMatchCardName(g_sndCardList[i][j]->cardName, i, j);
1617 }
1618 }
1619 }
1620 return NULL;
1621 }
1622
InitAudioPortOut(struct AudioPort * audioPort)1623 static void InitAudioPortOut(struct AudioPort *audioPort)
1624 {
1625 audioPort->dir = PORT_OUT;
1626 audioPort->portId = 0;
1627 audioPort->portName = strdup("AOP");
1628 }
1629
InitAudioPortIn(struct AudioPort * audioPort)1630 static void InitAudioPortIn(struct AudioPort *audioPort)
1631 {
1632 audioPort->dir = PORT_IN;
1633 audioPort->portId = 0;
1634 audioPort->portName = strdup("AIP");
1635 }
1636
InitAudioPortOutAndIn(struct AudioPort * audioPort)1637 static void InitAudioPortOutAndIn(struct AudioPort *audioPort)
1638 {
1639 audioPort->dir = PORT_OUT_IN;
1640 audioPort->portId = 0;
1641 audioPort->portName = strdup("AIOP");
1642 }
1643
InitAudioPortsForUser(struct AudioAdapterDescriptor * desc)1644 static int32_t InitAudioPortsForUser(struct AudioAdapterDescriptor *desc)
1645 {
1646 if (desc == NULL || desc->adapterName == NULL || desc->ports == NULL) {
1647 AUDIO_FUNC_LOGE("Paras is null!");
1648 return HDF_ERR_INVALID_PARAM;
1649 }
1650
1651 if (strcmp(desc->adapterName, PRIMARY) == 0) {
1652 InitAudioPortOut(&desc->ports[0]);
1653 InitAudioPortIn(&desc->ports[SUPPORT_CAPTURE_OR_RENDER]);
1654 InitAudioPortOutAndIn(&desc->ports[SUPPORT_CAPTURE_AND_RENDER]);
1655 } else if (strcmp(desc->adapterName, HDMI) == 0) {
1656 InitAudioPortOut(&desc->ports[0]);
1657 } else if (strcmp(desc->adapterName, USB) == 0) {
1658 InitAudioPortOut(&desc->ports[0]);
1659 InitAudioPortIn(&desc->ports[SUPPORT_CAPTURE_OR_RENDER]);
1660 } else {
1661 AUDIO_FUNC_LOGE("Unknown sound card type does not support this sound card temporarily!");
1662 return HDF_FAILURE;
1663 }
1664 return HDF_SUCCESS;
1665 }
1666
AudioReadCardPortToDesc(struct AudioAdapterDescriptor * desc)1667 static int32_t AudioReadCardPortToDesc(struct AudioAdapterDescriptor *desc)
1668 {
1669 uint8_t portNum;
1670
1671 if (desc == NULL || desc->adapterName == NULL) {
1672 AUDIO_FUNC_LOGE("descs or desc->adapterName is NULL!");
1673 return HDF_ERR_INVALID_PARAM;
1674 }
1675
1676 if (strcmp(desc->adapterName, PRIMARY) == 0) {
1677 portNum = PORT_OUT_IN; /* support (capture, render, capture & render) */
1678 } else if (strcmp(desc->adapterName, HDMI) == 0) {
1679 portNum = PORT_OUT; /* support render */
1680 } else if (strcmp(desc->adapterName, USB) == 0) {
1681 portNum = PORT_IN; /* support (capture, render) */
1682 } else {
1683 AUDIO_FUNC_LOGE("Unknown sound card type does not support this sound card temporarily!");
1684 return HDF_FAILURE;
1685 }
1686
1687 #ifndef AUDIO_HDI_SERVICE_MODE
1688 desc->portNum = portNum;
1689 #else
1690 desc->portsLen = portNum;
1691 #endif
1692
1693 desc->ports = (struct AudioPort *)OsalMemCalloc(sizeof(struct AudioPort) * portNum);
1694 if (desc->ports == NULL) {
1695 AUDIO_FUNC_LOGE("OsalMemCalloc failed!");
1696 return HDF_FAILURE;
1697 }
1698 if (InitAudioPortsForUser(desc) < 0) {
1699 AUDIO_FUNC_LOGE("InitAudioPortsForUser failed!");
1700 AudioMemFree((void **)&desc->ports);
1701 return HDF_FAILURE;
1702 }
1703 return HDF_SUCCESS;
1704 }
1705
AudioReadCardInfoToDesc(struct AudioAdapterDescriptor ** descs,uint8_t cardNum,bool usbAudioState)1706 static int32_t AudioReadCardInfoToDesc(struct AudioAdapterDescriptor **descs, uint8_t cardNum, bool usbAudioState)
1707 {
1708 int32_t index = 0;
1709 int32_t cardNumTemp = 0;
1710 if (descs == NULL || cardNum == 0) {
1711 AUDIO_FUNC_LOGE("Parameter error.");
1712 return HDF_FAILURE;
1713 }
1714 cardNumTemp = cardNum;
1715 if (*descs == NULL) {
1716 AUDIO_FUNC_LOGW("*descs is null, need memcalloc.");
1717 *descs = (struct AudioAdapterDescriptor *)OsalMemCalloc(sizeof(struct AudioAdapterDescriptor) * cardNum);
1718 if (*descs == NULL) {
1719 AUDIO_FUNC_LOGE("OsalMemCalloc descs is NULL");
1720 return HDF_FAILURE;
1721 }
1722 }
1723 if (usbAudioState) {
1724 (*descs)[cardNum - 1].adapterName = strdup(USB);
1725 cardNumTemp = cardNum - 1;
1726 }
1727
1728 for (index = 0; index < cardNumTemp; index++) {
1729 (*descs)[index].adapterName = AudioCardNameTransform();
1730 if ((*descs)[index].adapterName == NULL) {
1731 AUDIO_FUNC_LOGE("(*descs)[index].adapterName is NULL!");
1732 AudioFreeDesc(descs, cardNum);
1733 return HDF_FAILURE;
1734 }
1735 }
1736
1737 for (index = 0; index < cardNum; index++) {
1738 if (AudioReadCardPortToDesc(&(*descs)[index]) != HDF_SUCCESS) {
1739 AUDIO_FUNC_LOGE("read port failed!");
1740 AudioFreeDesc(descs, cardNum);
1741 return HDF_FAILURE;
1742 }
1743 }
1744
1745 return HDF_SUCCESS;
1746 }
1747
CheckUsbAudioIsInserted(struct AlsaCardsList * cardList)1748 static bool CheckUsbAudioIsInserted(struct AlsaCardsList *cardList)
1749 {
1750 if (cardList == NULL) {
1751 AUDIO_FUNC_LOGE("The parameter is empty.");
1752 return false;
1753 }
1754
1755 for (int32_t i = 0; i < MAX_CARD_NUM; i++) {
1756 /** External codec */
1757 if (strcmp(USB_AUDIO, cardList->alsaDevIns[i].pcmInfoId) == 0) {
1758 return true;
1759 }
1760 }
1761
1762 return false;
1763 }
1764
AudioGetAllCardInfo(struct AudioAdapterDescriptor ** descs,int32_t * sndCardNum)1765 int32_t AudioGetAllCardInfo(struct AudioAdapterDescriptor **descs, int32_t *sndCardNum)
1766 {
1767 if (descs == NULL || sndCardNum == NULL) {
1768 AUDIO_FUNC_LOGE("descs or sndCardNum is NULL!");
1769 return HDF_ERR_INVALID_PARAM;
1770 }
1771 AUDIO_FUNC_LOGI("enter!");
1772 /* Parse sound card from configuration file */
1773 int32_t ret = CardInfoParseFromConfig();
1774 if (ret != HDF_SUCCESS) {
1775 AUDIO_FUNC_LOGE("parse config file failed! ret = %{public}d", ret);
1776 return HDF_FAILURE;
1777 }
1778
1779 /* Read sound card list from alsa hardware */
1780 (void)memset_s(&g_alsaCardsList, sizeof(struct AlsaCardsList), 0, sizeof(struct AlsaCardsList));
1781 GetDeviceList(&g_alsaCardsList, SND_PCM_STREAM_PLAYBACK);
1782
1783 /* Check whether there is a USB sound card through pcmInfoId ("USB Audio") */
1784 bool usbAduioFlag = CheckUsbAudioIsInserted(&g_alsaCardsList);
1785 if (usbAduioFlag) {
1786 g_sndCardsNum += 1;
1787 }
1788 *sndCardNum = g_sndCardsNum;
1789
1790 /* Reconstruct sound card information to user */
1791 if (AudioReadCardInfoToDesc(descs, g_sndCardsNum, usbAduioFlag) != HDF_SUCCESS) {
1792 AUDIO_FUNC_LOGE("AudioReadCardInfoToDesc failed!");
1793 *sndCardNum = 0;
1794 CardInfoRelease();
1795 return HDF_FAILURE;
1796 }
1797 CardInfoRelease();
1798 return HDF_SUCCESS;
1799 }
1800