• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021 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 "audio_adapter_info_common.h"
17 #include <ctype.h>
18 #include <limits.h>
19 #include "audio_hal_log.h"
20 #include "cJSON.h"
21 
22 #define HDF_LOG_TAG hal_audio_adapter_info_common
23 
24 #define AUDIO_ADAPTER_CONFIG    HDF_CONFIG_DIR"/adapter_config.json"
25 #define ADAPTER_NAME_LEN        32
26 #define PORT_NAME_LEN           ADAPTER_NAME_LEN
27 #define SUPPORT_PORT_NUM_MAX    3
28 #define SUPPORT_PORT_ID_MAX     18
29 #define CONFIG_FILE_SIZE_MAX    (SUPPORT_ADAPTER_NUM_MAX * 1024)  // 8KB
30 #define CONFIG_CHANNEL_COUNT    2 // two channels
31 #define TIME_BASE_YEAR_1900     1900
32 #define DECIMAL_SYSTEM          10
33 #define MAX_ADDR_RECORD_NUM (SUPPORT_ADAPTER_NUM_MAX*3)
34 
35 int32_t g_adapterNum = 0;
36 struct AudioAdapterDescriptor *g_audioAdapterOut = NULL;
37 struct AudioAdapterDescriptor *g_audioAdapterDescs = NULL;
38 static const char *g_adaptersName[SUPPORT_ADAPTER_NUM_MAX] = {NULL};
39 static const char *g_portsName[SUPPORT_ADAPTER_NUM_MAX][SUPPORT_PORT_NUM_MAX] = {{NULL}};
40 
41 
42 struct AudioAddrDB g_localAudioAddrList[MAX_ADDR_RECORD_NUM];
43 bool g_fuzzCheckFlag = true;
44 
AudioSetFuzzCheckFlag(bool check)45 void AudioSetFuzzCheckFlag(bool check)
46 {
47     g_fuzzCheckFlag = check;
48     return;
49 }
50 
AudioAdapterAddrMgrInit()51 void AudioAdapterAddrMgrInit()
52 {
53     (void)memset_s(&g_localAudioAddrList, sizeof(g_localAudioAddrList), 0, sizeof(g_localAudioAddrList));
54     for (int index = 0; index < MAX_ADDR_RECORD_NUM; index++) {
55         g_localAudioAddrList[index].addrType = AUDIO_INVALID_ADDR;
56     }
57     return;
58 }
59 
AudioAddAdapterAddrToList(AudioHandle adapter,const struct AudioAdapterDescriptor * desc)60 int32_t AudioAddAdapterAddrToList(AudioHandle adapter, const struct AudioAdapterDescriptor *desc)
61 {
62     int pos = MAX_ADDR_RECORD_NUM;
63     if (adapter == NULL || desc == NULL || desc->adapterName == NULL) {
64         return AUDIO_HAL_ERR_INVALID_OBJECT;
65     }
66     for (int index = 0; index < MAX_ADDR_RECORD_NUM; index++) {
67         if (g_localAudioAddrList[index].adapterName) {
68             if (!strcmp(g_localAudioAddrList[index].adapterName, desc->adapterName)) {
69                 LOG_FUN_ERR("The adapter has been loaded. Please reselect the adapter!");
70                 return AUDIO_HAL_ERR_NOTREADY;
71             } else {
72                 continue;
73             }
74         } else {
75             if (pos == MAX_ADDR_RECORD_NUM && (g_localAudioAddrList[index].addrType == AUDIO_INVALID_ADDR)) {
76                 pos = index;
77             }
78         }
79     }
80     if (pos < MAX_ADDR_RECORD_NUM) {
81         g_localAudioAddrList[pos].adapterName = desc->adapterName;
82         g_localAudioAddrList[pos].addrValue = adapter;
83         g_localAudioAddrList[pos].addrType = AUDIO_ADAPTER_ADDR;
84         return AUDIO_HAL_SUCCESS;
85     }
86     return AUDIO_HAL_ERR_INVALID_PARAM;
87 }
88 
AudioCheckAdapterAddr(AudioHandle adapter)89 int32_t AudioCheckAdapterAddr(AudioHandle adapter)
90 {
91     if (g_fuzzCheckFlag == false) {
92         return AUDIO_HAL_SUCCESS;
93     }
94     if (adapter != NULL) {
95         for (int index = 0; index < MAX_ADDR_RECORD_NUM; index++) {
96             if (g_localAudioAddrList[index].addrValue == adapter &&
97                 g_localAudioAddrList[index].addrType == AUDIO_ADAPTER_ADDR) {
98                 return AUDIO_HAL_SUCCESS;
99             }
100         }
101         return AUDIO_HAL_ERR_INVALID_OBJECT;
102     }
103     return AUDIO_HAL_ERR_INVALID_PARAM;
104 }
105 
AudioDelAdapterAddrFromList(AudioHandle adapter)106 int32_t AudioDelAdapterAddrFromList(AudioHandle adapter)
107 {
108     if (adapter != NULL) {
109         for (int index = 0; index < MAX_ADDR_RECORD_NUM; index++) {
110             if (g_localAudioAddrList[index].addrValue == adapter &&
111                 g_localAudioAddrList[index].addrType == AUDIO_ADAPTER_ADDR) {
112                 g_localAudioAddrList[index].addrValue = NULL;
113                 g_localAudioAddrList[index].adapterName = NULL;
114                 g_localAudioAddrList[index].addrType = AUDIO_INVALID_ADDR;
115                 return AUDIO_HAL_SUCCESS;
116             }
117         }
118         return AUDIO_HAL_ERR_INVALID_OBJECT;
119     }
120     return AUDIO_HAL_ERR_INVALID_PARAM;
121 }
122 
AudioAddRenderAddrToList(AudioHandle render)123 int32_t AudioAddRenderAddrToList(AudioHandle render)
124 {
125     if (render != NULL) {
126         for (int index = 0; index < MAX_ADDR_RECORD_NUM; index++) {
127             if (g_localAudioAddrList[index].addrValue == NULL) {
128                 g_localAudioAddrList[index].addrValue = render;
129                 g_localAudioAddrList[index].addrType = AUDIO_RENDER_ADDR;
130                 return AUDIO_HAL_SUCCESS;
131             }
132         }
133         return AUDIO_HAL_ERR_INVALID_OBJECT;
134     }
135     return AUDIO_HAL_ERR_INVALID_PARAM;
136 }
137 
AudioCheckRenderAddr(AudioHandle render)138 int32_t AudioCheckRenderAddr(AudioHandle render)
139 {
140     if (g_fuzzCheckFlag == false) {
141         return AUDIO_HAL_SUCCESS;
142     }
143     if (render != NULL) {
144         for (int index = 0; index < MAX_ADDR_RECORD_NUM; index++) {
145             if (g_localAudioAddrList[index].addrValue == render &&
146                 g_localAudioAddrList[index].addrType == AUDIO_RENDER_ADDR) {
147                 return AUDIO_HAL_SUCCESS;
148             }
149         }
150         return AUDIO_HAL_ERR_INVALID_OBJECT;
151     }
152     return AUDIO_HAL_ERR_INVALID_PARAM;
153 }
154 
AudioDelRenderAddrFromList(AudioHandle render)155 int32_t AudioDelRenderAddrFromList(AudioHandle render)
156 {
157     if (render != NULL) {
158         for (int index = 0; index < MAX_ADDR_RECORD_NUM; index++) {
159             if (g_localAudioAddrList[index].addrValue == render &&
160                 g_localAudioAddrList[index].addrType == AUDIO_RENDER_ADDR) {
161                 g_localAudioAddrList[index].addrValue = NULL;
162                 g_localAudioAddrList[index].addrType = AUDIO_INVALID_ADDR;
163                 return AUDIO_HAL_SUCCESS;
164             }
165         }
166         return AUDIO_HAL_ERR_INVALID_OBJECT;
167     }
168     return AUDIO_HAL_ERR_INVALID_PARAM;
169 }
170 
AudioAddCaptureAddrToList(AudioHandle capture)171 int32_t AudioAddCaptureAddrToList(AudioHandle capture)
172 {
173     if (capture != NULL) {
174         for (int index = 0; index < MAX_ADDR_RECORD_NUM; index++) {
175             if (g_localAudioAddrList[index].addrValue == NULL) {
176                 g_localAudioAddrList[index].addrValue = capture;
177                 g_localAudioAddrList[index].addrType = AUDIO_CAPTURE_ADDR;
178                 return AUDIO_HAL_SUCCESS;
179             }
180         }
181     }
182     return AUDIO_HAL_ERR_INVALID_OBJECT;
183 }
184 
AudioCheckCaptureAddr(AudioHandle capture)185 int32_t AudioCheckCaptureAddr(AudioHandle capture)
186 {
187     if (g_fuzzCheckFlag == false) {
188         return AUDIO_HAL_SUCCESS;
189     }
190     if (capture != NULL) {
191         for (int index = 0; index < MAX_ADDR_RECORD_NUM; index++) {
192             if (g_localAudioAddrList[index].addrValue == capture &&
193                 g_localAudioAddrList[index].addrType == AUDIO_CAPTURE_ADDR) {
194                 return AUDIO_HAL_SUCCESS;
195             }
196         }
197         return AUDIO_HAL_ERR_INVALID_OBJECT;
198     }
199     return AUDIO_HAL_ERR_INVALID_PARAM;
200 }
201 
202 
AudioDelCaptureAddrFromList(AudioHandle capture)203 int32_t AudioDelCaptureAddrFromList(AudioHandle capture)
204 {
205     if (capture != NULL) {
206         for (int index = 0; index < MAX_ADDR_RECORD_NUM; index++) {
207             if (g_localAudioAddrList[index].addrValue == capture &&
208                 g_localAudioAddrList[index].addrType == AUDIO_CAPTURE_ADDR) {
209                 g_localAudioAddrList[index].addrValue = NULL;
210                 g_localAudioAddrList[index].addrType = AUDIO_INVALID_ADDR;
211                 return AUDIO_HAL_SUCCESS;
212             }
213         }
214         return AUDIO_HAL_ERR_INVALID_OBJECT;
215     }
216     return AUDIO_HAL_ERR_INVALID_PARAM;
217 }
218 
ClearAdaptersAllName(void)219 static void ClearAdaptersAllName(void)
220 {
221     int i, j;
222 
223     for (i = 0; i < SUPPORT_ADAPTER_NUM_MAX; i++) {
224         g_adaptersName[i] = NULL;
225         for (j = 0; j < SUPPORT_PORT_NUM_MAX; j++) {
226             g_portsName[i][j] = NULL;
227         }
228     }
229 }
230 
AudioAdapterGetConfigOut(void)231 struct AudioAdapterDescriptor *AudioAdapterGetConfigOut(void)
232 {
233     return g_audioAdapterOut;
234 }
235 
AudioAdapterGetConfigDescs(void)236 struct AudioAdapterDescriptor *AudioAdapterGetConfigDescs(void)
237 {
238     return g_audioAdapterDescs;
239 }
240 
AudioAdapterGetAdapterNum(void)241 int32_t AudioAdapterGetAdapterNum(void)
242 {
243     return g_adapterNum;
244 }
245 
AudioAdapterCheckPortFlow(const char * name)246 static int32_t AudioAdapterCheckPortFlow(const char *name)
247 {
248     uint32_t len;
249 
250     if (name == NULL) {
251         LOG_FUN_ERR("Invalid parameter!\n");
252 
253         return HDF_ERR_INVALID_PARAM;
254     }
255 
256     len = strlen(name);
257     if (len == 0) {
258         LOG_FUN_ERR("port name is null!\n");
259 
260         return HDF_FAILURE;
261     } else if (len >= PORT_NAME_LEN) {
262         LOG_FUN_ERR("port name is too long!\n");
263 
264         return HDF_FAILURE;
265     } else {
266         /* Nothing to do */
267     }
268 
269     if (strcmp(name, "AIP") && strcmp(name, "AOP") && strcmp(name, "AIOP")) {
270         LOG_FUN_ERR("Incorrect port name: [ %s ]!\n", name);
271 
272         return HDF_FAILURE;
273     }
274 
275     return HDF_SUCCESS;
276 }
277 
AudioAdapterCheckName(const char * name)278 static int32_t AudioAdapterCheckName(const char *name)
279 {
280     uint32_t len;
281 
282     if (name == NULL) {
283         LOG_FUN_ERR("Invalid parameter!\n");
284 
285         return HDF_ERR_INVALID_PARAM;
286     }
287 
288     len = strlen(name);
289     if (len == 0) {
290         LOG_FUN_ERR("adapter name is null!\n");
291 
292         return HDF_FAILURE;
293     } else if (len >= ADAPTER_NAME_LEN) {
294         LOG_FUN_ERR("adapter name is too long!\n");
295 
296         return HDF_FAILURE;
297     } else {
298         /* Nothing to do */
299     }
300 
301     if (!isalpha(*name++)) { // Names must begin with a letter
302         LOG_FUN_ERR("The adapter name of the illegal!\n");
303 
304         return HDF_FAILURE;
305     }
306 
307     while (*name != '\0') {
308         if (*name == '_') {
309             name++;
310             continue;
311         }
312 
313         if (!isalnum(*name++)) {
314             LOG_FUN_ERR("The adapter name of the illegal!\n");
315 
316             return HDF_FAILURE;
317         }
318     }
319 
320     return HDF_SUCCESS;
321 }
322 
AudioAdapterExist(const char * adapterName)323 int32_t AudioAdapterExist(const char *adapterName)
324 {
325     if (adapterName == NULL) {
326         LOG_FUN_ERR("Invalid parameter!\n");
327 
328         return HDF_ERR_INVALID_PARAM;
329     }
330     if (g_audioAdapterDescs == NULL || g_adapterNum <= 0 || g_adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
331         LOG_FUN_ERR("no adapter info");
332 
333         return HDF_FAILURE;
334     }
335     for (int i = 0; i < g_adapterNum; i++) {
336         if (strcmp(adapterName, g_audioAdapterDescs[i].adapterName) == 0) {
337             return HDF_SUCCESS;
338         }
339     }
340 
341     return HDF_FAILURE;
342 }
343 
AudioAdapterPortSync(struct AudioPort * outPorts,const struct AudioPort * desPorts,uint32_t portNum)344 static int32_t AudioAdapterPortSync(struct AudioPort *outPorts,
345     const struct AudioPort *desPorts, uint32_t portNum)
346 {
347     uint32_t index;
348     int32_t ret;
349 
350     if (outPorts == NULL || desPorts == NULL ||
351         portNum == 0 || portNum > SUPPORT_PORT_NUM_MAX) {
352         LOG_FUN_ERR("Invalid parameter!\n");
353 
354         return HDF_ERR_INVALID_PARAM;
355     }
356 
357     for (index = 0; index < portNum; index++) {
358         if (outPorts[index].portName && desPorts[index].portName) {
359             ret = memcpy_s((void *)outPorts[index].portName, PORT_NAME_LEN,
360                 desPorts[index].portName, strlen(desPorts[index].portName));
361             if (ret != EOK) {
362                 LOG_FUN_ERR("memcpy_s port name fail!\n");
363 
364                 return HDF_FAILURE;
365             }
366             outPorts[index].dir = desPorts[index].dir;
367             outPorts[index].portId = desPorts[index].portId;
368         }
369     }
370 
371     return HDF_SUCCESS;
372 }
373 
AudioAdaptersSync(void)374 static int32_t AudioAdaptersSync(void)
375 {
376     int32_t i, ret;
377 
378     if (g_audioAdapterDescs == NULL || g_audioAdapterOut == NULL ||
379         g_adapterNum <= 0 || g_adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
380         return HDF_FAILURE;
381     }
382 
383     for (i = 0; i < g_adapterNum; i++) {
384         if (g_audioAdapterDescs[i].adapterName &&
385             g_audioAdapterOut[i].adapterName) {
386             ret = memcpy_s((void *)g_audioAdapterOut[i].adapterName, ADAPTER_NAME_LEN,
387                 g_audioAdapterDescs[i].adapterName,
388                 strlen(g_audioAdapterDescs[i].adapterName));
389             if (ret != EOK) {
390                 LOG_FUN_ERR("memcpy_s adapter name fail!\n");
391 
392                 return HDF_FAILURE;
393             }
394 
395             g_audioAdapterOut[i].portNum = g_audioAdapterDescs[i].portNum;
396             ret = AudioAdapterPortSync(g_audioAdapterOut[i].ports,
397                 g_audioAdapterDescs[i].ports, g_audioAdapterOut[i].portNum);
398             if (ret != HDF_SUCCESS) {
399                 LOG_FUN_ERR("port sync fail!\n");
400 
401                 return HDF_FAILURE;
402             }
403         }
404     }
405 
406     return HDF_SUCCESS;
407 }
408 
AudioAdapterJudegReleaseDescs(const struct AudioAdapterDescriptor * desc)409 static void AudioAdapterJudegReleaseDescs(const struct AudioAdapterDescriptor *desc)
410 {
411     uint32_t portIdx;
412 
413     if (desc == NULL) {
414         return;
415     }
416 
417     if (desc->adapterName != NULL) {
418         AudioMemFree((void **)&desc->adapterName);
419     }
420 
421     if (desc->ports != NULL) {
422         portIdx = 0;
423         if (desc->portNum <= 0 || desc->portNum > SUPPORT_PORT_NUM_MAX) {
424             LOG_FUN_ERR("desc->portNum error!\n");
425             AudioMemFree((void **)&desc->ports);
426 
427             return;
428         }
429 
430         while (portIdx < desc->portNum) {
431             if (desc->ports[portIdx].portName != NULL) {
432                 AudioMemFree((void **)&desc->ports[portIdx].portName);
433             }
434             portIdx++;
435         }
436         AudioMemFree((void **)&desc->ports);
437     }
438 }
439 
AudioAdapterReleaseDescs(const struct AudioAdapterDescriptor * descs,int32_t adapterNum)440 static void AudioAdapterReleaseDescs(const struct AudioAdapterDescriptor *descs, int32_t adapterNum)
441 {
442     int32_t adapterIdx = 0;
443 
444     if (descs == NULL || adapterNum <= 0 || adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
445         return;
446     }
447 
448     if (adapterNum > g_adapterNum) {
449         adapterNum = g_adapterNum;
450     }
451 
452     while (adapterIdx < adapterNum) {
453         AudioAdapterJudegReleaseDescs(&descs[adapterIdx]);
454         adapterIdx++;
455     }
456 
457     AudioMemFree((void **)&descs);
458 }
459 
AudioAdapterGetDir(const char * dir)460 static int32_t AudioAdapterGetDir(const char *dir)
461 {
462     if (dir == NULL) {
463         return HDF_FAILURE;
464     }
465     if (strcmp(dir, "PORT_OUT") == 0) {
466         return PORT_OUT;
467     } else if (strcmp(dir, "PORT_IN") == 0) {
468         return PORT_IN;
469     } else if (strcmp(dir, "PORT_OUT_IN") == 0) {
470         return PORT_OUT_IN;
471     } else {
472         return HDF_FAILURE;
473     }
474 }
475 
AudioAdaptersGetArraySize(const cJSON * cJsonObj,int * size)476 static int32_t AudioAdaptersGetArraySize(const cJSON *cJsonObj, int *size)
477 {
478     int adapterArraySize;
479 
480     if (cJsonObj == NULL || size == NULL) {
481         LOG_FUN_ERR("Invalid parameter!\n");
482 
483         return HDF_ERR_INVALID_PARAM;
484     }
485 
486     /* Follow the new adapterNum by the number of actual parses */
487     adapterArraySize = cJSON_GetArraySize(cJsonObj);
488     if (adapterArraySize <= 0) {
489         LOG_FUN_ERR("Failed to get JSON array size!\n");
490 
491         return HDF_FAILURE;
492     }
493     *size = adapterArraySize;
494 
495     return HDF_SUCCESS;
496 }
497 
AudioAdapterParsePort(struct AudioPort * info,const cJSON * port)498 static int32_t AudioAdapterParsePort(struct AudioPort *info, const cJSON *port)
499 {
500     int32_t ret;
501     uint32_t tmpId;
502     cJSON *portDir = NULL;
503     cJSON *portID = NULL;
504     cJSON *portName = NULL;
505 
506     if (info == NULL || port == NULL) {
507         LOG_FUN_ERR("Invalid parameter!\n");
508 
509         return HDF_ERR_INVALID_PARAM;
510     }
511 
512     portDir = cJSON_GetObjectItem(port, "dir");
513     if (portDir == NULL || portDir->valuestring == NULL) {
514         return HDF_FAILURE;
515     }
516     ret = AudioAdapterGetDir(portDir->valuestring);
517     if (ret == HDF_FAILURE) {
518         LOG_FUN_ERR("port dir error!\n");
519 
520         return ret;
521     }
522     info->dir = ret;
523 
524     portID = cJSON_GetObjectItem(port, "id");
525     if (portID == NULL) {
526         return HDF_FAILURE;
527     }
528     tmpId = portID->valueint;
529     if (tmpId < 0 || tmpId > SUPPORT_PORT_ID_MAX) {
530         LOG_FUN_ERR("portID error!\n");
531 
532         return HDF_FAILURE;
533     }
534     info->portId = (uint32_t)tmpId;
535 
536     portName = cJSON_GetObjectItem(port, "name");
537     if (portName == NULL || portName->valuestring == NULL) {
538         return HDF_FAILURE;
539     }
540     ret = AudioAdapterCheckPortFlow(portName->valuestring);
541     if (ret != HDF_SUCCESS) {
542         LOG_FUN_ERR("Port name error!\n");
543 
544         return ret;
545     }
546     info->portName = (char *)calloc(1, PORT_NAME_LEN);
547     if (info->portName == NULL) {
548         LOG_FUN_ERR("Out of memory\n");
549 
550         return HDF_ERR_MALLOC_FAIL;
551     }
552     ret = memcpy_s((void *)info->portName, PORT_NAME_LEN,
553         portName->valuestring, strlen(portName->valuestring));
554     if (ret != EOK) {
555         LOG_FUN_ERR("memcpy_s port name fail");
556 
557         return HDF_FAILURE;
558     }
559 
560     return HDF_SUCCESS;
561 }
562 
AudioAdapterParsePorts(struct AudioAdapterDescriptor * desc,const cJSON * adapter)563 static int32_t AudioAdapterParsePorts(struct AudioAdapterDescriptor *desc, const cJSON *adapter)
564 {
565     uint32_t i;
566     int32_t ret, tmpNum;
567     cJSON *adapterPort = NULL;
568     int32_t realSize = 0;
569     if (desc == NULL || adapter == NULL) {
570         LOG_FUN_ERR("Invalid parameter!\n");
571 
572         return HDF_ERR_INVALID_PARAM;
573     }
574     cJSON *adapterPortNum = cJSON_GetObjectItem(adapter, "portnum");
575     if (adapterPortNum == NULL) {
576         return HDF_FAILURE;
577     }
578     tmpNum = cJSON_GetNumberValue(adapterPortNum);
579     if (tmpNum <= 0 || tmpNum > SUPPORT_PORT_NUM_MAX) {
580         LOG_FUN_ERR("portnum error!\n");
581 
582         return HDF_FAILURE;
583     }
584     desc->portNum = (uint32_t)tmpNum;
585 
586     cJSON *adapterPorts = cJSON_GetObjectItem(adapter, "port");
587     if (adapterPorts == NULL) {
588         return HDF_FAILURE;
589     }
590     ret = AudioAdaptersGetArraySize(adapterPorts, &realSize);
591     if (ret != HDF_SUCCESS || realSize != desc->portNum) {
592         LOG_FUN_ERR("realSize = %d, portNum = %d.\n", realSize, desc->portNum);
593         LOG_FUN_ERR("The defined portnum does not match the actual portnum!\n");
594 
595         return HDF_FAILURE;
596     }
597 
598     desc->ports = (struct AudioPort *)calloc(1, desc->portNum * sizeof(struct AudioPort));
599     if (desc->ports == NULL) {
600         LOG_FUN_ERR("Out of memory!\n");
601 
602         return HDF_ERR_MALLOC_FAIL;
603     }
604     for (i = 0; i < desc->portNum; i++) {
605         adapterPort = cJSON_GetArrayItem(adapterPorts, i);
606         if (adapterPort != NULL) {
607             ret = AudioAdapterParsePort(&desc->ports[i], adapterPort);
608             if (ret != HDF_SUCCESS) {
609                 return ret;
610             }
611         }
612     }
613     return HDF_SUCCESS;
614 }
615 
AudioAdapterParseAdapter(struct AudioAdapterDescriptor * desc,const cJSON * adapter)616 static int32_t AudioAdapterParseAdapter(struct AudioAdapterDescriptor *desc,
617                                         const cJSON *adapter)
618 {
619     int32_t ret;
620 
621     if (desc == NULL || adapter == NULL) {
622         LOG_FUN_ERR("Invalid parameter!\n");
623 
624         return HDF_ERR_INVALID_PARAM;
625     }
626 
627     cJSON *adapterName = cJSON_GetObjectItem(adapter, "name");
628     if (adapterName == NULL || adapterName->valuestring == NULL) {
629         return HDF_FAILURE;
630     }
631     ret = AudioAdapterCheckName(adapterName->valuestring);
632     if (ret != HDF_SUCCESS) {
633         LOG_FUN_ERR("The Adapter name is incorrect!\n");
634 
635         return ret;
636     }
637 
638     desc->adapterName = (char *)calloc(1, ADAPTER_NAME_LEN);
639     if (desc->adapterName == NULL) {
640         LOG_FUN_ERR("Out of memory!\n");
641 
642         return HDF_ERR_MALLOC_FAIL;
643     }
644     ret = memcpy_s((void *)desc->adapterName, ADAPTER_NAME_LEN,
645         adapterName->valuestring, strlen(adapterName->valuestring));
646     if (ret != EOK) {
647         LOG_FUN_ERR("memcpy_s adapter name fail!\n");
648 
649         return HDF_FAILURE;
650     }
651 
652     ret = AudioAdapterParsePorts(desc, adapter);
653     if (ret != HDF_SUCCESS) {
654         return ret;
655     }
656 
657     return HDF_SUCCESS;
658 }
659 
AudioAdaptersGetConfig(const char * fpath)660 static char *AudioAdaptersGetConfig(const char *fpath)
661 {
662     char *pJsonStr = NULL;
663 
664     if (fpath == NULL) {
665         /* The file path is bad or unreadable */
666         return NULL;
667     }
668     char pathBuf[PATH_MAX] = {'\0'};
669     if (realpath(fpath, pathBuf) == NULL) {
670         return NULL;
671     }
672     FILE *fp = fopen(pathBuf, "r");
673     if (fp == NULL) {
674         LOG_FUN_ERR("Can not open config file [ %s ].\n", fpath);
675         return NULL;
676     }
677     fseek(fp, 0, SEEK_END);
678     int32_t jsonStrSize = ftell(fp);
679     if (jsonStrSize <= 0) {
680         fclose(fp);
681         return NULL;
682     }
683     rewind(fp);
684     if (jsonStrSize > CONFIG_FILE_SIZE_MAX) {
685         LOG_FUN_ERR("The configuration file is too large to load!\n");
686         fclose(fp);
687         return NULL;
688     }
689     pJsonStr = (char *)calloc(1, (uint32_t)jsonStrSize + 1);
690     if (pJsonStr == NULL) {
691         fclose(fp);
692         return NULL;
693     }
694     if (fread(pJsonStr, jsonStrSize, 1, fp) != 1) {
695         LOG_FUN_ERR("read to file fail!");
696         fclose(fp);
697         AudioMemFree((void **)&pJsonStr);
698         return NULL;
699     }
700     fclose(fp);
701     return pJsonStr;
702 }
703 
AudioAdaptersGetConfigToJsonObj(const char * fpath)704 cJSON *AudioAdaptersGetConfigToJsonObj(const char *fpath)
705 {
706     char *pJsonStr = AudioAdaptersGetConfig(fpath);
707     if (pJsonStr == NULL) {
708         return NULL;
709     }
710     cJSON *cJsonObj = cJSON_Parse(pJsonStr);
711     if (cJsonObj == NULL) {
712         AudioMemFree((void **)&pJsonStr);
713         return NULL;
714     }
715     AudioMemFree((void **)&pJsonStr);
716     cJSON *adapterNum = cJSON_GetObjectItem(cJsonObj, "adapterNum");
717     if (adapterNum == NULL) {
718         cJSON_Delete(cJsonObj);
719         return NULL;
720     }
721     g_adapterNum = adapterNum->valueint;
722     if (g_adapterNum <= 0 || g_adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
723         LOG_FUN_ERR("Adapter number error!\n");
724         cJSON_Delete(cJsonObj);
725         return NULL;
726     }
727     return cJsonObj;
728 }
729 
AudioAdaptersSetAdapter(struct AudioAdapterDescriptor ** descs,int32_t adapterNum,const cJSON * adaptersObj)730 static int32_t AudioAdaptersSetAdapter(struct AudioAdapterDescriptor **descs,
731     int32_t adapterNum, const cJSON *adaptersObj)
732 {
733     int32_t i, ret;
734     cJSON *adapterObj = NULL;
735 
736     if (descs == NULL || adaptersObj == NULL ||
737         adapterNum <= 0 || adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
738         LOG_FUN_ERR("Invalid parameter!\n");
739 
740         return HDF_ERR_INVALID_PARAM;
741     }
742     if (*descs != NULL) {
743         /* Existing content is no longer assigned twice */
744         return HDF_SUCCESS;
745     }
746 
747     *descs = (struct AudioAdapterDescriptor *)calloc(1,
748         adapterNum * sizeof(struct AudioAdapterDescriptor));
749     if (*descs == NULL) {
750         LOG_FUN_ERR("calloc g_audioAdapterDescs failed");
751 
752         return HDF_ERR_MALLOC_FAIL;
753     }
754 
755     for (i = 0; i < adapterNum; i++) {
756         adapterObj = cJSON_GetArrayItem(adaptersObj, i);
757         if (adapterObj != NULL) {
758             ret = AudioAdapterParseAdapter(&(*descs)[i], adapterObj);
759             if (ret != HDF_SUCCESS) {
760                 AudioAdapterReleaseDescs(*descs, adapterNum);
761                 *descs = NULL;
762 
763                 return HDF_FAILURE;
764             }
765         }
766     }
767 
768     return HDF_SUCCESS;
769 }
770 
AudioAdaptersNamesRepair(void)771 static void AudioAdaptersNamesRepair(void)
772 {
773     int i, realNum;
774 
775     if (g_audioAdapterOut == NULL ||
776         g_audioAdapterDescs == NULL || g_adapterNum <= 0) {
777         return;
778     }
779 
780     realNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX;
781     for (i = 0; i < realNum; i++) {
782         if (g_adaptersName[i] == NULL) {
783             return;
784         }
785 
786         if (strcmp(g_audioAdapterOut[i].adapterName, g_audioAdapterDescs[i].adapterName)) {
787             /* Retrieve the location of the port name */
788             g_audioAdapterOut[i].adapterName = g_adaptersName[i];
789         }
790     }
791 }
792 
AudioPortsNamesRepair(void)793 static void AudioPortsNamesRepair(void)
794 {
795     int i, j, adapterNum, portNum;
796 
797     if (g_audioAdapterOut == NULL ||
798         g_audioAdapterDescs == NULL || g_adapterNum <= 0) {
799         return;
800     }
801 
802     adapterNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX;
803     for (i = 0; i < adapterNum; i++) {
804         portNum = (g_audioAdapterOut[i].portNum < SUPPORT_PORT_NUM_MAX) ?
805             g_audioAdapterOut[i].portNum : SUPPORT_PORT_NUM_MAX;
806         for (j = 0; j < portNum; j++) {
807             if (g_portsName[i][j] == NULL) {
808                 return;
809             }
810             if (strcmp(g_audioAdapterOut[i].ports[j].portName, g_audioAdapterDescs[i].ports[j].portName)) {
811                 /* Retrieve the location of the sound card name */
812                 g_audioAdapterOut[i].ports[j].portName = g_portsName[i][j];
813             }
814         }
815     }
816 }
817 
AudioAdaptersNamesRecord(void)818 static void AudioAdaptersNamesRecord(void)
819 {
820     int i, currentNum;
821 
822     if (g_audioAdapterOut == NULL ||
823         g_audioAdapterDescs == NULL || g_adapterNum <= 0) {
824         return;
825     }
826 
827     currentNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX;
828     for (i = 0; i < currentNum; i++) {
829         /* Record the location of the sound card name */
830         g_adaptersName[i] = g_audioAdapterOut[i].adapterName;
831     }
832 }
833 
AudioPortsNamesRecord(void)834 static void AudioPortsNamesRecord(void)
835 {
836     int i, j, adapterCurNum, portCurNum;
837 
838     if (g_audioAdapterOut == NULL || g_audioAdapterDescs == NULL || g_adapterNum <= 0) {
839         return;
840     }
841 
842     adapterCurNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX;
843     for (i = 0; i < adapterCurNum; i++) {
844         portCurNum = (g_audioAdapterOut[i].portNum < SUPPORT_PORT_NUM_MAX) ?
845             g_audioAdapterOut[i].portNum : SUPPORT_PORT_NUM_MAX;
846         for (j = 0; j < portCurNum; j++) {
847             /* Record the location of the port name */
848             g_portsName[i][j] = g_audioAdapterOut[i].ports[j].portName;
849         }
850     }
851 }
852 
AudioAdaptersForUser(struct AudioAdapterDescriptor ** descs,int * size)853 int32_t AudioAdaptersForUser(struct AudioAdapterDescriptor **descs, int *size)
854 {
855     int32_t realSize;
856 
857     if (descs == NULL || size == NULL) {
858         return HDF_ERR_INVALID_PARAM;
859     }
860     if (g_audioAdapterDescs != NULL && g_audioAdapterOut != NULL &&
861         g_adapterNum > 0 && g_adapterNum <= SUPPORT_ADAPTER_NUM_MAX) {
862         AudioAdaptersNamesRepair();
863         AudioPortsNamesRepair();
864         /* Existing content is no longer assigned twice */
865         *descs = g_audioAdapterOut;
866         *size = g_adapterNum;
867 
868         return HDF_SUCCESS;
869     }
870     cJSON *cJsonObj = AudioAdaptersGetConfigToJsonObj(AUDIO_ADAPTER_CONFIG);
871     if (cJsonObj == NULL) {
872         return HDF_FAILURE;
873     }
874     cJSON *adaptersObj = cJSON_GetObjectItem(cJsonObj, "adapters");
875     if (adaptersObj == NULL) {
876         cJSON_Delete(cJsonObj);
877 
878         return HDF_FAILURE;
879     }
880     if (AudioAdaptersGetArraySize(adaptersObj, &realSize) != HDF_SUCCESS || realSize != g_adapterNum) {
881         LOG_FUN_ERR("realSize = %d, adaptersNum = %d.\n", realSize, g_adapterNum);
882         LOG_FUN_ERR("The defined adaptersnum does not match the actual adapters!\n");
883         g_adapterNum = 0;
884         cJSON_Delete(cJsonObj);
885 
886         return HDF_FAILURE;
887     }
888     if (AudioAdaptersSetAdapter(&g_audioAdapterDescs, g_adapterNum, adaptersObj) != HDF_SUCCESS) {
889         g_adapterNum = 0;
890         cJSON_Delete(cJsonObj);
891 
892         return HDF_FAILURE;
893     }
894     if (AudioAdaptersSetAdapter(&g_audioAdapterOut, g_adapterNum, adaptersObj) != HDF_SUCCESS) {
895         /* g_audioAdapterOut failure also releases g_audioAdapterDescs */
896         AudioAdapterReleaseDescs(g_audioAdapterDescs, g_adapterNum);
897         ClearAdaptersAllName();
898         g_audioAdapterDescs = NULL;
899         g_adapterNum = 0;
900         cJSON_Delete(cJsonObj);
901 
902         return HDF_FAILURE;
903     }
904     AudioAdaptersNamesRecord();
905     AudioPortsNamesRecord();
906     *descs = g_audioAdapterOut;
907     *size = g_adapterNum;
908     cJSON_Delete(cJsonObj);
909 
910     return HDF_SUCCESS;
911 }
912 
913 static enum AudioFormat g_formatIdZero = AUDIO_FORMAT_PCM_16_BIT;
HdmiPortInit(struct AudioPort portIndex,struct AudioPortCapability * capabilityIndex)914 int32_t HdmiPortInit(struct AudioPort portIndex, struct AudioPortCapability *capabilityIndex)
915 {
916     if (capabilityIndex == NULL) {
917         LOG_FUN_ERR("capabilityIndex Is NULL");
918         return HDF_FAILURE;
919     }
920     capabilityIndex->hardwareMode = true;
921     capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO;
922     capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT;
923     capabilityIndex->deviceType = portIndex.dir;
924     capabilityIndex->deviceId = PIN_OUT_SPEAKER;
925     capabilityIndex->formatNum = 1;
926     capabilityIndex->formats = &g_formatIdZero;
927     capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000 | AUDIO_SAMPLE_RATE_MASK_24000;
928     capabilityIndex->subPortsNum = 1;
929     capabilityIndex->subPorts = (struct AudioSubPortCapability *)calloc(capabilityIndex->subPortsNum,
930         sizeof(struct AudioSubPortCapability));
931     if (capabilityIndex->subPorts == NULL) {
932         LOG_FUN_ERR("The pointer is null!");
933         return HDF_FAILURE;
934     }
935     capabilityIndex->subPorts->portId = portIndex.portId;
936     capabilityIndex->subPorts->desc = portIndex.portName;
937     capabilityIndex->subPorts->mask = PORT_PASSTHROUGH_LPCM;
938     return HDF_SUCCESS;
939 }
940 
FormatToBits(enum AudioFormat format,uint32_t * formatBits)941 int32_t FormatToBits(enum AudioFormat format, uint32_t *formatBits)
942 {
943     if (formatBits == NULL) {
944         return HDF_FAILURE;
945     }
946     switch (format) {
947         case AUDIO_FORMAT_PCM_32_BIT:
948             *formatBits = BIT_NUM_32;
949             return HDF_SUCCESS;
950         case AUDIO_FORMAT_PCM_24_BIT:
951             *formatBits = BIT_NUM_24;
952             return HDF_SUCCESS;
953         case AUDIO_FORMAT_PCM_16_BIT:
954             *formatBits = BIT_NUM_16;
955             return HDF_SUCCESS;
956         case AUDIO_FORMAT_PCM_8_BIT:
957             *formatBits = BIT_NUM_8;
958             return HDF_SUCCESS;
959         default:
960             return HDF_ERR_NOT_SUPPORT;
961     }
962 }
963 
BitsToFormat(enum AudioFormat * format,long formatBits)964 int32_t BitsToFormat(enum AudioFormat *format, long formatBits)
965 {
966     if (format == NULL) {
967         return HDF_FAILURE;
968     }
969     switch (formatBits) {
970         case BIT_NUM_32:
971             *format = AUDIO_FORMAT_PCM_32_BIT;
972             return HDF_SUCCESS;
973         case BIT_NUM_24:
974             *format = AUDIO_FORMAT_PCM_24_BIT;
975             return HDF_SUCCESS;
976         case BIT_NUM_16:
977             *format = AUDIO_FORMAT_PCM_16_BIT;
978             return HDF_SUCCESS;
979         case BIT_NUM_8:
980             *format = AUDIO_FORMAT_PCM_8_BIT;
981             return HDF_SUCCESS;
982         default:
983             return HDF_ERR_NOT_SUPPORT;
984     }
985 }
986 
CheckAttrRoute(long param)987 int32_t CheckAttrRoute(long param)
988 {
989     if (param < DEEP_BUFF || param > LOW_LATRNCY) {
990         return HDF_FAILURE;
991     }
992     return HDF_SUCCESS;
993 }
994 
CheckAttrChannel(unsigned long param)995 int32_t CheckAttrChannel(unsigned long param)
996 {
997     if (param != 1 && param != 2) { // channel 1 and 2
998         return HDF_FAILURE;
999     }
1000     return HDF_SUCCESS;
1001 }
1002 
TransferRoute(const char * value,int32_t * route)1003 int32_t TransferRoute(const char *value, int32_t *route)
1004 {
1005     if (value == NULL || route == NULL) {
1006         return HDF_FAILURE;
1007     }
1008     char *endptr = NULL;
1009     errno = 0;
1010     long tempRoute = strtol(value, &endptr, DECIMAL_SYSTEM);
1011     if ((errno == ERANGE && (tempRoute == LONG_MAX || tempRoute == LONG_MIN)) || (errno != 0 && tempRoute == 0)) {
1012         return HDF_FAILURE;
1013     }
1014     int32_t ret = CheckAttrRoute(tempRoute);
1015     if (ret == 0) {
1016         *route = tempRoute;
1017     }
1018     return ret;
1019 }
1020 
TransferFormat(const char * value,int32_t * format)1021 int32_t TransferFormat(const char *value, int32_t *format)
1022 {
1023     if (value == NULL || format == NULL) {
1024         return HDF_FAILURE;
1025     }
1026     char *endptr = NULL;
1027     errno = 0;
1028     long tempFormat = strtol(value, &endptr, DECIMAL_SYSTEM);
1029     if ((errno == ERANGE && (tempFormat == LONG_MAX || tempFormat == LONG_MIN)) || (errno != 0 && tempFormat == 0)) {
1030         return HDF_FAILURE;
1031     }
1032     enum AudioFormat audioFormat;
1033     int32_t ret = BitsToFormat(&audioFormat, tempFormat);
1034     if (ret == HDF_SUCCESS) {
1035         ret = CheckAttrFormat(audioFormat);
1036         if (ret == 0) {
1037             *format = audioFormat;
1038         }
1039     }
1040     return ret;
1041 }
1042 
TransferChannels(const char * value,uint32_t * channels)1043 int32_t TransferChannels(const char *value, uint32_t *channels)
1044 {
1045     if (value == NULL || channels == NULL) {
1046         return HDF_FAILURE;
1047     }
1048     char *endptr = NULL;
1049     errno = 0;
1050     unsigned long tempChannels = strtoul(value, &endptr, DECIMAL_SYSTEM);
1051     if ((errno == ERANGE && (tempChannels == ULONG_MAX)) || (errno != 0 && tempChannels == 0)) {
1052         return HDF_FAILURE;
1053     }
1054     int32_t ret = CheckAttrChannel(tempChannels);
1055     if (ret == 0) {
1056         *channels = tempChannels;
1057     }
1058     return ret;
1059 }
1060 
TransferFrames(const char * value,uint64_t * frames)1061 int32_t TransferFrames(const char *value, uint64_t *frames)
1062 {
1063     if (value == NULL || frames == NULL) {
1064         return HDF_FAILURE;
1065     }
1066     char *endptr = NULL;
1067     errno = 0;
1068     uint64_t tempFrames = strtoull(value, &endptr, 10);
1069     if ((errno == ERANGE && (tempFrames == ULLONG_MAX)) || (errno != 0 && tempFrames == 0)) {
1070         return HDF_FAILURE;
1071     } else {
1072         *frames = tempFrames;
1073         return HDF_SUCCESS;
1074     }
1075 }
1076 
TransferSampleRate(const char * value,uint32_t * sampleRate)1077 int32_t TransferSampleRate(const char *value, uint32_t *sampleRate)
1078 {
1079     if (value == NULL || sampleRate == NULL) {
1080         return HDF_FAILURE;
1081     }
1082     char *endptr = NULL;
1083     errno = 0;
1084     unsigned long tempSampleRate = strtoul(value, &endptr, DECIMAL_SYSTEM);
1085     if ((errno == ERANGE && (tempSampleRate == ULONG_MAX)) || (errno != 0 && tempSampleRate == 0)) {
1086         return HDF_FAILURE;
1087     }
1088     int32_t ret = CheckAttrSamplingRate(tempSampleRate);
1089     if (ret == 0) {
1090         *sampleRate = tempSampleRate;
1091     }
1092     return ret;
1093 }
1094 
KeyValueListToMap(const char * keyValueList,struct ParamValMap mParamValMap[],int32_t * count)1095 int32_t KeyValueListToMap(const char *keyValueList, struct ParamValMap mParamValMap[], int32_t *count)
1096 {
1097     if (keyValueList == NULL || mParamValMap == NULL || count == NULL) {
1098         return HDF_FAILURE;
1099     }
1100     int i = 0;
1101     char *mParaMap[MAP_MAX];
1102     char buffer[KEY_VALUE_LIST_LEN] = {0};
1103     int32_t ret = sprintf_s(buffer, KEY_VALUE_LIST_LEN - 1, "%s", keyValueList);
1104     if (ret < 0) {
1105         LOG_FUN_ERR("sprintf_s failed!");
1106         return HDF_FAILURE;
1107     }
1108     char *tempBuf = buffer;
1109     char *outPtr = NULL;
1110     char *inPtr = NULL;
1111     while (i < MAP_MAX && ((mParaMap[i] = strtok_r(tempBuf, ";", &outPtr)) != NULL)) {
1112         tempBuf = mParaMap[i];
1113         if ((mParaMap[i] = strtok_r(tempBuf, "=", &inPtr)) != NULL) {
1114             ret = strncpy_s(mParamValMap[i].key, EXTPARAM_LEN - 1, mParaMap[i], strlen(mParaMap[i]) + 1);
1115             if (ret != 0) {
1116                 return HDF_FAILURE;
1117             }
1118             tempBuf = NULL;
1119         }
1120         if ((mParaMap[i] = strtok_r(tempBuf, "=", &inPtr)) != NULL) {
1121             ret = strncpy_s(mParamValMap[i].value, EXTPARAM_LEN - 1, mParaMap[i], strlen(mParaMap[i]) + 1);
1122             if (ret != 0) {
1123                 return HDF_FAILURE;
1124             }
1125             tempBuf = NULL;
1126         } else {
1127             LOG_FUN_ERR("Has no value!");
1128             return HDF_FAILURE;
1129         }
1130         tempBuf = NULL;
1131         i++;
1132     }
1133     *count = i;
1134     return HDF_SUCCESS;
1135 }
1136 
AddElementToList(char * keyValueList,int32_t listLenth,const char * key,void * value)1137 int32_t AddElementToList(char *keyValueList, int32_t listLenth, const char *key, void *value)
1138 {
1139     if (keyValueList == NULL || key == NULL || value == NULL) {
1140         return HDF_FAILURE;
1141     }
1142     int32_t ret = HDF_FAILURE;
1143     char strValue[MAP_MAX] = { 0 };
1144     if (strcmp(key, AUDIO_ATTR_PARAM_ROUTE) == 0) {
1145         ret = sprintf_s(strValue, sizeof(strValue), "%s=%d;", key, *((int32_t *)value));
1146     } else if (strcmp(key, AUDIO_ATTR_PARAM_FORMAT) == 0) {
1147         uint32_t formatBits = 0;
1148         ret = FormatToBits((enum AudioFormat)(*((int32_t *)value)), &formatBits);
1149         if (ret == 0) {
1150             ret = sprintf_s(strValue, sizeof(strValue), "%s=%u;", key, formatBits);
1151         }
1152     } else if (strcmp(key, AUDIO_ATTR_PARAM_CHANNELS) == 0) {
1153         ret = sprintf_s(strValue, sizeof(strValue), "%s=%u;", key, *((uint32_t *)value));
1154     } else if (strcmp(key, AUDIO_ATTR_PARAM_FRAME_COUNT) == 0) {
1155         ret = sprintf_s(strValue, sizeof(strValue), "%s=%llu;", key, *((uint64_t *)value));
1156     } else if (strcmp(key, AUDIO_ATTR_PARAM_SAMPLING_RATE) == 0) {
1157         ret = sprintf_s(strValue, sizeof(strValue), "%s=%u", key, *((uint32_t *)value));
1158     } else {
1159         LOG_FUN_ERR("NO this key correspond value!");
1160         return HDF_FAILURE;
1161     }
1162     if (ret < 0) {
1163         LOG_FUN_ERR("sprintf_s failed!");
1164         return HDF_FAILURE;
1165     }
1166     ret = strncat_s(keyValueList, listLenth, strValue, strlen(strValue));
1167     if (ret != EOK) {
1168         LOG_FUN_ERR("strcat_s failed!");
1169         return HDF_FAILURE;
1170     }
1171     return HDF_SUCCESS;
1172 }
1173 
SetExtParam(const char * key,const char * value,struct ExtraParams * mExtraParams)1174 int32_t SetExtParam(const char *key, const char *value, struct ExtraParams *mExtraParams)
1175 {
1176     if (key == NULL || value == NULL || mExtraParams == NULL) {
1177         return HDF_FAILURE;
1178     }
1179     int ret = HDF_FAILURE;
1180     if (strcmp(key, AUDIO_ATTR_PARAM_ROUTE) == 0) {
1181         int32_t route;
1182         ret = TransferRoute(value, &route);
1183         if (ret < 0) {
1184             return HDF_FAILURE;
1185         }
1186         mExtraParams->route = route;
1187     } else if (strcmp(key, AUDIO_ATTR_PARAM_FORMAT) == 0) {
1188         int32_t format;
1189         ret = TransferFormat(value, &format);
1190         if (ret < 0) {
1191             return HDF_FAILURE;
1192         }
1193         mExtraParams->format = format;
1194     } else if (strcmp(key, AUDIO_ATTR_PARAM_CHANNELS) == 0) {
1195         uint32_t channels;
1196         ret = TransferChannels(value, &channels);
1197         if (ret < 0) {
1198             return HDF_FAILURE;
1199         }
1200         mExtraParams->channels = channels;
1201     } else if (strcmp(key, AUDIO_ATTR_PARAM_FRAME_COUNT) == 0) {
1202         uint64_t frames;
1203         ret = TransferFrames(value, &frames);
1204         if (ret < 0) {
1205             return HDF_FAILURE;
1206         }
1207         mExtraParams->frames = frames;
1208         mExtraParams->flag = true;
1209     } else if (strcmp(key, AUDIO_ATTR_PARAM_SAMPLING_RATE) == 0) {
1210         uint32_t sampleRate = 0;
1211         ret = TransferSampleRate(value, &sampleRate);
1212         if (ret < 0) {
1213             return HDF_FAILURE;
1214         }
1215         mExtraParams->sampleRate = sampleRate;
1216     } else {
1217         LOG_FUN_ERR("NO this key correspond value or value is invalid!");
1218         return HDF_FAILURE;
1219     }
1220     return ret;
1221 }
1222 
GetErrorReason(int reason,char * reasonDesc)1223 int32_t GetErrorReason(int reason, char *reasonDesc)
1224 {
1225     int32_t ret;
1226     if (reasonDesc == NULL) {
1227         return HDF_FAILURE;
1228     }
1229     switch (reason) {
1230         case HDF_FAILURE:
1231             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("NOT SUPPORT") + 1, "%s", "NOT SUPPORT");
1232             break;
1233         case HDF_ERR_NOT_SUPPORT:
1234             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("BUFFER FULL") + 1, "%s", "BUFFER FULL");
1235             break;
1236         default:
1237             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("UNKNOW") + 1, "%s", "UNKNOW");
1238             break;
1239     }
1240     if (ret < 0) {
1241         LOG_FUN_ERR("sprintf_s failed!");
1242         return HDF_FAILURE;
1243     }
1244     return HDF_SUCCESS;
1245 }
GetCurrentTime(char * currentTime)1246 int32_t GetCurrentTime(char *currentTime)
1247 {
1248     if (currentTime == NULL) {
1249         return HDF_FAILURE;
1250     }
1251     // Get the current time
1252     char *week[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
1253     time_t timeSec;
1254     time(&timeSec);
1255     struct tm *specificTime = localtime(&timeSec);
1256     if (specificTime == NULL) {
1257         LOG_FUN_ERR("localtime failed!");
1258         return HDF_FAILURE;
1259     }
1260     int32_t ret = sprintf_s(currentTime, ERROR_REASON_DESC_LEN - 1, "%d/%d/%d %s %d:%d:%d",
1261         (TIME_BASE_YEAR_1900 + specificTime->tm_year), (1 + specificTime->tm_mon), specificTime->tm_mday,
1262         week[specificTime->tm_wday], specificTime->tm_hour, specificTime->tm_min, specificTime->tm_sec);
1263     if (ret < 0) {
1264         LOG_FUN_ERR("sprintf_s failed!");
1265         return HDF_FAILURE;
1266     }
1267 
1268     return HDF_SUCCESS;
1269 }
1270 
AudioSetExtraParams(const char * keyValueList,int32_t * count,struct ExtraParams * mExtraParams,int32_t * sumOk)1271 int32_t AudioSetExtraParams(const char *keyValueList, int32_t *count,
1272     struct ExtraParams *mExtraParams, int32_t *sumOk)
1273 {
1274     if (keyValueList == NULL || count == NULL || mExtraParams == NULL || sumOk == NULL) {
1275         return AUDIO_HAL_ERR_INTERNAL;
1276     }
1277     struct ParamValMap mParamValMap[MAP_MAX];
1278     int32_t ret = KeyValueListToMap(keyValueList, mParamValMap, count);
1279     if (ret < 0) {
1280         LOG_FUN_ERR("Convert to map FAIL!");
1281         return AUDIO_HAL_ERR_INTERNAL;
1282     }
1283     int index = 0;
1284     mExtraParams->route = -1;
1285     mExtraParams->format = -1;
1286     mExtraParams->channels = 0;
1287     mExtraParams->frames = 0;
1288     mExtraParams->sampleRate = 0;
1289     mExtraParams->flag = false;
1290     while (index < *count) {
1291         ret = SetExtParam(mParamValMap[index].key, mParamValMap[index].value, mExtraParams);
1292         if (ret < 0) {
1293             return AUDIO_HAL_ERR_INTERNAL;
1294         } else {
1295             (*sumOk)++;
1296         }
1297         index++;
1298     }
1299     return AUDIO_HAL_SUCCESS;
1300 }
1301 
1302