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 <cctype>
17 #include <climits>
18 #include <hdf_log.h>
19 #include "audio_internal.h"
20 #include "cJSON.h"
21 #include "audio_adapter_info_common.h"
22 
23 #ifdef LOG_DOMAIN
24 #undef LOG_DOMAIN
25 #endif
26 #define LOG_DOMAIN 0xD000105
27 
28 namespace OHOS::HDI::Audio_Bluetooth {
29 constexpr const char *AUDIO_ADAPTER_CONFIG = "/vendor/etc/hdfconfig/a2dp_adapter_config.json";
30 constexpr int ADAPTER_NAME_LEN = 32;
31 #define PORT_NAME_LEN           ADAPTER_NAME_LEN
32 constexpr int SUPPORT_ADAPTER_NUM_MAX = 8;
33 constexpr int SUPPORT_PORT_NUM_MAX = 3;
34 constexpr int SUPPORT_PORT_ID_MAX = 18;
35 constexpr int CONFIG_FILE_SIZE_MAX = (SUPPORT_ADAPTER_NUM_MAX * 1024);  // 8KB
36 constexpr int CONFIG_CHANNEL_COUNT = 2; // two channels
37 constexpr int DECIMAL_SYSTEM = 10;
38 
39 int32_t g_adapterNum = 0;
40 struct AudioAdapterDescriptor *g_audioAdapterOut = NULL;
41 struct AudioAdapterDescriptor *g_audioAdapterDescs = NULL;
42 static const char *g_adaptersName[SUPPORT_ADAPTER_NUM_MAX] = {NULL};
43 static const char *g_portsName[SUPPORT_ADAPTER_NUM_MAX][SUPPORT_PORT_NUM_MAX] = {{NULL}};
44 
ClearAdaptersAllName(void)45 static void ClearAdaptersAllName(void)
46 {
47     int i, j;
48 
49     for (i = 0; i < SUPPORT_ADAPTER_NUM_MAX; i++) {
50         g_adaptersName[i] = NULL;
51         for (j = 0; j < SUPPORT_PORT_NUM_MAX; j++) {
52             g_portsName[i][j] = NULL;
53         }
54     }
55 }
56 
AudioAdapterGetConfigOut(void)57 struct AudioAdapterDescriptor *AudioAdapterGetConfigOut(void)
58 {
59     return g_audioAdapterOut;
60 }
61 
AudioAdapterGetConfigDescs(void)62 struct AudioAdapterDescriptor *AudioAdapterGetConfigDescs(void)
63 {
64     return g_audioAdapterDescs;
65 }
66 
AudioAdapterGetAdapterNum(void)67 int32_t AudioAdapterGetAdapterNum(void)
68 {
69     return g_adapterNum;
70 }
71 
AudioAdapterCheckPortFlow(const char * name)72 static int32_t AudioAdapterCheckPortFlow(const char *name)
73 {
74     uint32_t len;
75 
76     if (name == NULL) {
77         HDF_LOGE("Invalid parameter!\n");
78 
79         return HDF_ERR_INVALID_PARAM;
80     }
81 
82     len = strlen(name);
83     if (len == 0) {
84         HDF_LOGE("port name is null!\n");
85 
86         return HDF_FAILURE;
87     } else if (len >= PORT_NAME_LEN) {
88         HDF_LOGE("port name is too long!\n");
89 
90         return HDF_FAILURE;
91     } else {
92         /* Nothing to do */
93     }
94 
95     if (strcmp(name, "AIP") && strcmp(name, "AOP") && strcmp(name, "AIOP")) {
96         HDF_LOGE("Incorrect port name: [ %s ]!\n", name);
97 
98         return HDF_FAILURE;
99     }
100 
101     return HDF_SUCCESS;
102 }
103 
AudioAdapterCheckName(const char * name)104 static int32_t AudioAdapterCheckName(const char *name)
105 {
106     uint32_t len;
107 
108     if (name == NULL) {
109         HDF_LOGE("Invalid parameter!\n");
110 
111         return HDF_ERR_INVALID_PARAM;
112     }
113 
114     len = strlen(name);
115     if (len == 0) {
116         HDF_LOGE("adapter name is null!\n");
117 
118         return HDF_FAILURE;
119     } else if (len >= ADAPTER_NAME_LEN) {
120         HDF_LOGE("adapter name is too long!\n");
121 
122         return HDF_FAILURE;
123     } else {
124         /* Nothing to do */
125     }
126 
127     if (!isalpha(*name++)) { // Names must begin with a letter
128         HDF_LOGE("The adapter name of the illegal!\n");
129 
130         return HDF_FAILURE;
131     }
132 
133     while (*name != '\0') {
134         if (*name == '_') {
135             name++;
136             continue;
137         }
138 
139         if (!isalnum(*name++)) {
140             HDF_LOGE("The adapter name of the illegal!\n");
141 
142             return HDF_FAILURE;
143         }
144     }
145 
146     return HDF_SUCCESS;
147 }
148 
AudioAdapterExist(const char * adapterName)149 int32_t AudioAdapterExist(const char *adapterName)
150 {
151     if (adapterName == NULL) {
152         HDF_LOGE("Invalid parameter!\n");
153 
154         return HDF_ERR_INVALID_PARAM;
155     }
156     if (g_audioAdapterDescs == NULL || g_adapterNum <= 0 || g_adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
157         HDF_LOGE("no adapter info");
158 
159         return HDF_FAILURE;
160     }
161     for (int i = 0; i < g_adapterNum; i++) {
162         if (strcmp(adapterName, g_audioAdapterDescs[i].adapterName) == 0) {
163             return HDF_SUCCESS;
164         }
165     }
166 
167     return HDF_FAILURE;
168 }
169 
AudioAdapterJudegReleaseDescs(const struct AudioAdapterDescriptor * desc)170 static void AudioAdapterJudegReleaseDescs(const struct AudioAdapterDescriptor *desc)
171 {
172     uint32_t portIdx;
173 
174     if (desc == NULL) {
175         return;
176     }
177 
178     if (desc->adapterName != NULL) {
179         AudioMemFree(reinterpret_cast<void **>(const_cast<char **>(&desc->adapterName)));
180     }
181 
182     if (desc->ports != NULL) {
183         portIdx = 0;
184         if (desc->portNum <= 0 || desc->portNum > SUPPORT_PORT_NUM_MAX) {
185             HDF_LOGE("desc->portNum error!\n");
186             AudioMemFree(reinterpret_cast<void **>(const_cast<AudioPort **>(&desc->ports)));
187 
188             return;
189         }
190 
191         while (portIdx < desc->portNum) {
192             if (desc->ports[portIdx].portName != NULL) {
193                 AudioMemFree((void **)&desc->ports[portIdx].portName);
194             }
195             portIdx++;
196         }
197         AudioMemFree(reinterpret_cast<void **>(const_cast<AudioPort **>(&desc->ports)));
198     }
199 }
200 
AudioAdapterReleaseDescs(const struct AudioAdapterDescriptor * descs,int32_t adapterNum)201 static void AudioAdapterReleaseDescs(const struct AudioAdapterDescriptor *descs, int32_t adapterNum)
202 {
203     int32_t adapterIdx = 0;
204 
205     if (descs == NULL || adapterNum <= 0 || adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
206         return;
207     }
208 
209     if (adapterNum > g_adapterNum) {
210         adapterNum = g_adapterNum;
211     }
212 
213     while (adapterIdx < adapterNum) {
214         AudioAdapterJudegReleaseDescs(&descs[adapterIdx]);
215         adapterIdx++;
216     }
217 
218     AudioMemFree(reinterpret_cast<void **>(const_cast<AudioAdapterDescriptor **>(&descs)));
219 }
220 
AudioAdapterGetDir(const char * dir)221 static int32_t AudioAdapterGetDir(const char *dir)
222 {
223     if (dir == NULL) {
224         return HDF_FAILURE;
225     }
226     if (strcmp(dir, "PORT_OUT") == 0) {
227         return PORT_OUT;
228     } else if (strcmp(dir, "PORT_IN") == 0) {
229         return PORT_IN;
230     } else if (strcmp(dir, "PORT_OUT_IN") == 0) {
231         return PORT_OUT_IN;
232     } else {
233         return HDF_FAILURE;
234     }
235 }
236 
AudioAdaptersGetArraySize(const cJSON * cJsonObj,int * size)237 static int32_t AudioAdaptersGetArraySize(const cJSON *cJsonObj, int *size)
238 {
239     int adapterArraySize;
240 
241     if (cJsonObj == NULL || size == NULL) {
242         HDF_LOGE("Invalid parameter!\n");
243 
244         return HDF_ERR_INVALID_PARAM;
245     }
246 
247     /* Follow the new adapterNum by the number of actual parses */
248     adapterArraySize = cJSON_GetArraySize(cJsonObj);
249     if (adapterArraySize <= 0) {
250         HDF_LOGE("Failed to get JSON array size!\n");
251 
252         return HDF_FAILURE;
253     }
254     *size = adapterArraySize;
255 
256     return HDF_SUCCESS;
257 }
258 
AudioAdapterParsePort(struct AudioPort * info,const cJSON * port)259 static int32_t AudioAdapterParsePort(struct AudioPort *info, const cJSON *port)
260 {
261     int32_t ret;
262     uint32_t tmpId;
263     cJSON *portDir = NULL;
264     cJSON *portID = NULL;
265     cJSON *portName = NULL;
266 
267     if (info == NULL || port == NULL) {
268         HDF_LOGE("Invalid parameter!\n");
269 
270         return HDF_ERR_INVALID_PARAM;
271     }
272 
273     portDir = cJSON_GetObjectItem(port, "dir");
274     if (portDir == NULL || portDir->valuestring == NULL) {
275         return HDF_FAILURE;
276     }
277     ret = AudioAdapterGetDir(portDir->valuestring);
278     if (ret == HDF_FAILURE) {
279         HDF_LOGE("port dir error!\n");
280 
281         return ret;
282     }
283     info->dir = (AudioPortDirection)ret;
284 
285     portID = cJSON_GetObjectItem(port, "id");
286     if (portID == NULL) {
287         return HDF_FAILURE;
288     }
289     tmpId = portID->valueint;
290     if (tmpId < 0 || tmpId > SUPPORT_PORT_ID_MAX) {
291         HDF_LOGE("portID error!\n");
292 
293         return HDF_FAILURE;
294     }
295     info->portId = (uint32_t)tmpId;
296 
297     portName = cJSON_GetObjectItem(port, "name");
298     if (portName == NULL || portName->valuestring == NULL) {
299         return HDF_FAILURE;
300     }
301     ret = AudioAdapterCheckPortFlow(portName->valuestring);
302     if (ret != HDF_SUCCESS) {
303         HDF_LOGE("Port name error!\n");
304 
305         return ret;
306     }
307     info->portName = static_cast<char *>(calloc(1, PORT_NAME_LEN));
308     if (info->portName == NULL) {
309         HDF_LOGE("Out of memory\n");
310 
311         return HDF_ERR_MALLOC_FAIL;
312     }
313     ret = memcpy_s(static_cast<void *>(const_cast<char *>(info->portName)), PORT_NAME_LEN,
314         portName->valuestring, strlen(portName->valuestring));
315     if (ret != EOK) {
316         HDF_LOGE("memcpy_s port name fail");
317 
318         return HDF_FAILURE;
319     }
320 
321     return HDF_SUCCESS;
322 }
323 
AudioAdapterParsePorts(struct AudioAdapterDescriptor * desc,const cJSON * adapter)324 static int32_t AudioAdapterParsePorts(struct AudioAdapterDescriptor *desc, const cJSON *adapter)
325 {
326     uint32_t i;
327     int32_t ret, tmpNum;
328     cJSON *adapterPort = NULL;
329     int32_t realSize = 0;
330     if (desc == NULL || adapter == NULL) {
331         HDF_LOGE("Invalid parameter!\n");
332 
333         return HDF_ERR_INVALID_PARAM;
334     }
335     cJSON *adapterPortNum = cJSON_GetObjectItem(adapter, "portnum");
336     if (adapterPortNum == NULL) {
337         return HDF_FAILURE;
338     }
339     tmpNum = cJSON_GetNumberValue(adapterPortNum);
340     if (tmpNum <= 0 || tmpNum > SUPPORT_PORT_NUM_MAX) {
341         HDF_LOGE("portnum error!\n");
342 
343         return HDF_FAILURE;
344     }
345     desc->portNum = (uint32_t)tmpNum;
346 
347     cJSON *adapterPorts = cJSON_GetObjectItem(adapter, "port");
348     if (adapterPorts == NULL) {
349         return HDF_FAILURE;
350     }
351     ret = AudioAdaptersGetArraySize(adapterPorts, &realSize);
352     if (ret != HDF_SUCCESS || realSize != (int)(desc->portNum)) {
353         HDF_LOGE("realSize = %d, portNum = %d.\n", realSize, desc->portNum);
354         HDF_LOGE("The defined portnum does not match the actual portnum!\n");
355 
356         return HDF_FAILURE;
357     }
358 
359     desc->ports = reinterpret_cast<struct AudioPort *>(calloc(1, desc->portNum * sizeof(struct AudioPort)));
360     if (desc->ports == NULL) {
361         HDF_LOGE("Out of memory!\n");
362 
363         return HDF_ERR_MALLOC_FAIL;
364     }
365     for (i = 0; i < desc->portNum; i++) {
366         adapterPort = cJSON_GetArrayItem(adapterPorts, i);
367         if (adapterPort) {
368             ret = AudioAdapterParsePort(&desc->ports[i], adapterPort);
369             if (ret != HDF_SUCCESS) {
370                 return ret;
371             }
372         }
373     }
374     return HDF_SUCCESS;
375 }
376 
AudioAdapterParseAdapter(struct AudioAdapterDescriptor * desc,const cJSON * adapter)377 static int32_t AudioAdapterParseAdapter(struct AudioAdapterDescriptor *desc,
378                                         const cJSON *adapter)
379 {
380     int32_t ret;
381 
382     if (desc == NULL || adapter == NULL) {
383         HDF_LOGE("Invalid parameter!\n");
384 
385         return HDF_ERR_INVALID_PARAM;
386     }
387 
388     cJSON *adapterName = cJSON_GetObjectItem(adapter, "name");
389     if (adapterName == NULL || adapterName->valuestring == NULL) {
390         return HDF_FAILURE;
391     }
392     ret = AudioAdapterCheckName(adapterName->valuestring);
393     if (ret != HDF_SUCCESS) {
394         HDF_LOGE("The Adapter name is incorrect!\n");
395 
396         return ret;
397     }
398 
399     desc->adapterName = static_cast<char *>(calloc(1, ADAPTER_NAME_LEN));
400     if (desc->adapterName == NULL) {
401         HDF_LOGE("Out of memory!\n");
402 
403         return HDF_ERR_MALLOC_FAIL;
404     }
405     ret = memcpy_s(static_cast<void *>(const_cast<char *>(desc->adapterName)), ADAPTER_NAME_LEN,
406         adapterName->valuestring, strlen(adapterName->valuestring));
407     if (ret != EOK) {
408         HDF_LOGE("memcpy_s adapter name fail!\n");
409 
410         return HDF_FAILURE;
411     }
412 
413     ret = AudioAdapterParsePorts(desc, adapter);
414     if (ret != HDF_SUCCESS) {
415         return ret;
416     }
417 
418     return HDF_SUCCESS;
419 }
420 
AudioAdaptersGetConfig(const char * fpath)421 static char *AudioAdaptersGetConfig(const char *fpath)
422 {
423     char *pJsonStr = NULL;
424 
425     if (fpath == NULL) {
426         /* The file path is bad or unreadable */
427         return NULL;
428     }
429     if (access(fpath, F_OK | R_OK)) {
430         return NULL;
431     }
432     FILE *fp = fopen(fpath, "r");
433     if (fp == NULL) {
434         HDF_LOGE("Can not open config file [ %s ].\n", fpath);
435         return NULL;
436     }
437     if (fseek(fp, 0, SEEK_END) != 0) {
438         fclose(fp);
439         return NULL;
440     }
441     int32_t jsonStrSize = ftell(fp);
442     if (jsonStrSize <= 0) {
443         fclose(fp);
444         return NULL;
445     }
446     rewind(fp);
447     if (jsonStrSize > CONFIG_FILE_SIZE_MAX) {
448         HDF_LOGE("The configuration file is too large to load!\n");
449         fclose(fp);
450         return NULL;
451     }
452     pJsonStr = static_cast<char *>(calloc(1, (uint32_t)jsonStrSize));
453     if (pJsonStr == NULL) {
454         fclose(fp);
455         return NULL;
456     }
457     if (fread(pJsonStr, jsonStrSize, 1, fp) != 1) {
458         HDF_LOGE("read to file fail!");
459         fclose(fp);
460         AudioMemFree(reinterpret_cast<void **>(&pJsonStr));
461         return NULL;
462     }
463     if (fclose(fp) != 0) {
464         HDF_LOGE("close fp fail!");
465     }
466     return pJsonStr;
467 }
468 
AudioAdaptersGetConfigToJsonObj(const char * fpath)469 cJSON *AudioAdaptersGetConfigToJsonObj(const char *fpath)
470 {
471     char *pJsonStr = AudioAdaptersGetConfig(fpath);
472     if (pJsonStr == NULL) {
473         return NULL;
474     }
475     cJSON *cJsonObj = cJSON_Parse(pJsonStr);
476     if (cJsonObj == NULL) {
477         AudioMemFree(reinterpret_cast<void **>(&pJsonStr));
478         return NULL;
479     }
480     AudioMemFree(reinterpret_cast<void **>(&pJsonStr));
481     cJSON *adapterNum = cJSON_GetObjectItem(cJsonObj, "adapterNum");
482     if (adapterNum == NULL) {
483         cJSON_Delete(cJsonObj);
484         return NULL;
485     }
486     g_adapterNum = adapterNum->valueint;
487     if (g_adapterNum <= 0 || g_adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
488         HDF_LOGE("Adapter number error!\n");
489         cJSON_Delete(cJsonObj);
490         return NULL;
491     }
492     return cJsonObj;
493 }
494 
AudioAdaptersSetAdapter(struct AudioAdapterDescriptor ** descs,int32_t adapterNum,const cJSON * adaptersObj)495 static int32_t AudioAdaptersSetAdapter(struct AudioAdapterDescriptor **descs,
496     int32_t adapterNum, const cJSON *adaptersObj)
497 {
498     int32_t i, ret;
499     cJSON *adapterObj = NULL;
500 
501     if (descs == NULL || adaptersObj == NULL ||
502         adapterNum <= 0 || adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
503         HDF_LOGE("Invalid parameter!\n");
504 
505         return HDF_ERR_INVALID_PARAM;
506     }
507     if (*descs != NULL) {
508         /* Existing content is no longer assigned twice */
509         return HDF_SUCCESS;
510     }
511 
512     *descs = reinterpret_cast<struct AudioAdapterDescriptor *>(calloc(1,
513         adapterNum * sizeof(struct AudioAdapterDescriptor)));
514     if (*descs == NULL) {
515         HDF_LOGE("calloc g_audioAdapterDescs failed");
516 
517         return HDF_ERR_MALLOC_FAIL;
518     }
519 
520     for (i = 0; i < adapterNum; i++) {
521         adapterObj = cJSON_GetArrayItem(adaptersObj, i);
522         if (adapterObj) {
523             ret = AudioAdapterParseAdapter(&(*descs)[i], adapterObj);
524             if (ret != HDF_SUCCESS) {
525                 AudioAdapterReleaseDescs(*descs, adapterNum);
526                 *descs = NULL;
527 
528                 return HDF_FAILURE;
529             }
530         }
531     }
532 
533     return HDF_SUCCESS;
534 }
535 
AudioAdaptersNamesRepair(void)536 static void AudioAdaptersNamesRepair(void)
537 {
538     int i, realNum;
539 
540     if (g_audioAdapterOut == NULL ||
541         g_audioAdapterDescs == NULL || g_adapterNum <= 0) {
542         return;
543     }
544 
545     realNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX;
546     for (i = 0; i < realNum; i++) {
547         if (g_adaptersName[i] == NULL) {
548             return;
549         }
550 
551         if (strcmp(g_audioAdapterOut[i].adapterName, g_audioAdapterDescs[i].adapterName)) {
552             /* Retrieve the location of the port name */
553             g_audioAdapterOut[i].adapterName = g_adaptersName[i];
554         }
555     }
556 }
557 
AudioPortsNamesRepair(void)558 static void AudioPortsNamesRepair(void)
559 {
560     int i, j, adapterNum, portNum;
561 
562     if (g_audioAdapterOut == NULL ||
563         g_audioAdapterDescs == NULL || g_adapterNum <= 0) {
564         return;
565     }
566 
567     adapterNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX;
568     for (i = 0; i < adapterNum; i++) {
569         portNum = (g_audioAdapterOut[i].portNum < SUPPORT_PORT_NUM_MAX) ?
570             g_audioAdapterOut[i].portNum : SUPPORT_PORT_NUM_MAX;
571         for (j = 0; j < portNum; j++) {
572             if (g_portsName[i][j] == NULL) {
573                 return;
574             }
575             if (strcmp(g_audioAdapterOut[i].ports[j].portName, g_audioAdapterDescs[i].ports[j].portName)) {
576                 /* Retrieve the location of the sound card name */
577                 g_audioAdapterOut[i].ports[j].portName = g_portsName[i][j];
578             }
579         }
580     }
581 }
582 
AudioAdaptersNamesRecord(void)583 static void AudioAdaptersNamesRecord(void)
584 {
585     int i, currentNum;
586 
587     if (g_audioAdapterOut == NULL ||
588         g_audioAdapterDescs == NULL || g_adapterNum <= 0) {
589         return;
590     }
591 
592     currentNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX;
593     for (i = 0; i < currentNum; i++) {
594         /* Record the location of the sound card name */
595         g_adaptersName[i] = g_audioAdapterOut[i].adapterName;
596     }
597 }
598 
AudioPortsNamesRecord(void)599 static void AudioPortsNamesRecord(void)
600 {
601     int i, j, adapterCurNum, portCurNum;
602 
603     if (g_audioAdapterOut == NULL || g_audioAdapterDescs == NULL || g_adapterNum <= 0) {
604         return;
605     }
606 
607     adapterCurNum = (g_adapterNum < SUPPORT_ADAPTER_NUM_MAX) ? g_adapterNum : SUPPORT_ADAPTER_NUM_MAX;
608     for (i = 0; i < adapterCurNum; i++) {
609         portCurNum = (g_audioAdapterOut[i].portNum < SUPPORT_PORT_NUM_MAX) ?
610             g_audioAdapterOut[i].portNum : SUPPORT_PORT_NUM_MAX;
611         for (j = 0; j < portCurNum; j++) {
612             /* Record the location of the port name */
613             g_portsName[i][j] = g_audioAdapterOut[i].ports[j].portName;
614         }
615     }
616 }
617 
AudioAdaptersForUser(struct AudioAdapterDescriptor ** descs,int * size)618 int32_t AudioAdaptersForUser(struct AudioAdapterDescriptor **descs, int *size)
619 {
620     int32_t realSize = -1;
621 
622     if (descs == NULL || size == NULL) {
623         return HDF_ERR_INVALID_PARAM;
624     }
625     if (g_audioAdapterDescs != NULL && g_audioAdapterOut != NULL &&
626         g_adapterNum > 0 && g_adapterNum <= SUPPORT_ADAPTER_NUM_MAX) {
627         AudioAdaptersNamesRepair();
628         AudioPortsNamesRepair();
629         /* Existing content is no longer assigned twice */
630         *descs = g_audioAdapterOut;
631         *size = g_adapterNum;
632 
633         return HDF_SUCCESS;
634     }
635     cJSON *cJsonObj = AudioAdaptersGetConfigToJsonObj(AUDIO_ADAPTER_CONFIG);
636     if (cJsonObj == NULL) {
637         return HDF_FAILURE;
638     }
639     cJSON *adaptersObj = cJSON_GetObjectItem(cJsonObj, "adapters");
640     if (adaptersObj == NULL) {
641         cJSON_Delete(cJsonObj);
642 
643         return HDF_FAILURE;
644     }
645     if (AudioAdaptersGetArraySize(adaptersObj, &realSize) != HDF_SUCCESS || realSize != g_adapterNum) {
646         HDF_LOGE("realSize = %d, adaptersNum = %d.\n", realSize, g_adapterNum);
647         HDF_LOGE("The defined adaptersnum does not match the actual adapters!\n");
648         g_adapterNum = 0;
649         cJSON_Delete(cJsonObj);
650 
651         return HDF_FAILURE;
652     }
653     if (AudioAdaptersSetAdapter(&g_audioAdapterDescs, g_adapterNum, adaptersObj) != HDF_SUCCESS) {
654         g_adapterNum = 0;
655         cJSON_Delete(cJsonObj);
656 
657         return HDF_FAILURE;
658     }
659     if (AudioAdaptersSetAdapter(&g_audioAdapterOut, g_adapterNum, adaptersObj) != HDF_SUCCESS) {
660         /* g_audioAdapterOut failure also releases g_audioAdapterDescs */
661         AudioAdapterReleaseDescs(g_audioAdapterDescs, g_adapterNum);
662         ClearAdaptersAllName();
663         g_audioAdapterDescs = NULL;
664         g_adapterNum = 0;
665         cJSON_Delete(cJsonObj);
666 
667         return HDF_FAILURE;
668     }
669     AudioAdaptersNamesRecord();
670     AudioPortsNamesRecord();
671     *descs = g_audioAdapterOut;
672     *size = g_adapterNum;
673     cJSON_Delete(cJsonObj);
674 
675     return HDF_SUCCESS;
676 }
677 
678 static AudioFormat g_formatIdZero = AUDIO_FORMAT_TYPE_PCM_16_BIT;
HdmiPortInit(struct AudioPort portIndex,struct AudioPortCapability * capabilityIndex)679 int32_t HdmiPortInit(struct AudioPort portIndex, struct AudioPortCapability *capabilityIndex)
680 {
681     if (capabilityIndex == NULL) {
682         HDF_LOGE("capabilityIndex Is NULL");
683         return HDF_FAILURE;
684     }
685     capabilityIndex->hardwareMode = true;
686     capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO;
687     capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT;
688     capabilityIndex->deviceType = portIndex.dir;
689     capabilityIndex->deviceId = PIN_OUT_SPEAKER;
690     capabilityIndex->formatNum = 1;
691     capabilityIndex->formats = &g_formatIdZero;
692     capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000 | AUDIO_SAMPLE_RATE_MASK_24000;
693     capabilityIndex->subPortsNum = 1;
694     capabilityIndex->subPorts = reinterpret_cast<struct AudioSubPortCapability *>(calloc(capabilityIndex->subPortsNum,
695         sizeof(struct AudioSubPortCapability)));
696     if (capabilityIndex->subPorts == NULL) {
697         HDF_LOGE("The pointer is null!");
698         return HDF_FAILURE;
699     }
700     capabilityIndex->subPorts->portId = portIndex.portId;
701     capabilityIndex->subPorts->desc = portIndex.portName;
702     capabilityIndex->subPorts->mask = PORT_PASSTHROUGH_LPCM;
703     return HDF_SUCCESS;
704 }
705 
FormatToBits(AudioFormat format,uint32_t * formatBits)706 int32_t FormatToBits(AudioFormat format, uint32_t *formatBits)
707 {
708     if (formatBits == NULL) {
709         return HDF_FAILURE;
710     }
711     switch (format) {
712         case AUDIO_FORMAT_TYPE_PCM_32_BIT:
713             *formatBits = BIT_NUM_32;
714             return HDF_SUCCESS;
715         case AUDIO_FORMAT_TYPE_PCM_24_BIT:
716             *formatBits = BIT_NUM_24;
717             return HDF_SUCCESS;
718         case AUDIO_FORMAT_TYPE_PCM_16_BIT:
719             *formatBits = BIT_NUM_16;
720             return HDF_SUCCESS;
721         case AUDIO_FORMAT_TYPE_PCM_8_BIT:
722             *formatBits = BIT_NUM_8;
723             return HDF_SUCCESS;
724         default:
725             return HDF_ERR_NOT_SUPPORT;
726     }
727 }
728 
BitsToFormat(AudioFormat * format,long formatBits)729 int32_t BitsToFormat(AudioFormat *format, long formatBits)
730 {
731     if (format == NULL) {
732         return HDF_FAILURE;
733     }
734     switch (formatBits) {
735         case BIT_NUM_32:
736             *format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
737             return HDF_SUCCESS;
738         case BIT_NUM_24:
739             *format = AUDIO_FORMAT_TYPE_PCM_24_BIT;
740             return HDF_SUCCESS;
741         case BIT_NUM_16:
742             *format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
743             return HDF_SUCCESS;
744         case BIT_NUM_8:
745             *format = AUDIO_FORMAT_TYPE_PCM_8_BIT;
746             return HDF_SUCCESS;
747         default:
748             return HDF_ERR_NOT_SUPPORT;
749     }
750 }
751 
CheckAttrRoute(long param)752 int32_t CheckAttrRoute(long param)
753 {
754     if (param < DEEP_BUFF || param > LOW_LATRNCY) {
755         return HDF_FAILURE;
756     }
757     return HDF_SUCCESS;
758 }
759 
CheckAttrChannel(unsigned long param)760 int32_t CheckAttrChannel(unsigned long param)
761 {
762     if (param != 1 && param != 2) { // channel 1 and 2
763         return HDF_FAILURE;
764     }
765     return HDF_SUCCESS;
766 }
767 
TransferRoute(const char * value,int32_t * route)768 int32_t TransferRoute(const char *value, int32_t *route)
769 {
770     if (value == NULL || route == NULL) {
771         return HDF_FAILURE;
772     }
773     char *endptr = NULL;
774     errno = 0;
775     long tempRoute = strtol(value, &endptr, DECIMAL_SYSTEM);
776     if ((errno == ERANGE && (tempRoute == LONG_MAX || tempRoute == LONG_MIN)) || (errno != 0 && tempRoute == 0)) {
777         return HDF_FAILURE;
778     }
779     int32_t ret = CheckAttrRoute(tempRoute);
780     if (ret == 0) {
781         *route = tempRoute;
782     }
783     return ret;
784 }
785 
TransferFormat(const char * value,int32_t * format)786 int32_t TransferFormat(const char *value, int32_t *format)
787 {
788     if (value == NULL || format == NULL) {
789         return HDF_FAILURE;
790     }
791     char *endptr = NULL;
792     errno = 0;
793     long tempFormat = strtol(value, &endptr, DECIMAL_SYSTEM);
794     if ((errno == ERANGE && (tempFormat == LONG_MAX || tempFormat == LONG_MIN)) || (errno != 0 && tempFormat == 0)) {
795         return HDF_FAILURE;
796     }
797     AudioFormat audioFormat;
798     int32_t ret = BitsToFormat(&audioFormat, tempFormat);
799     if (ret == HDF_SUCCESS) {
800         ret = CheckAttrFormat(audioFormat);
801         if (ret == 0) {
802             *format = audioFormat;
803         }
804     }
805     return ret;
806 }
807 
TransferChannels(const char * value,uint32_t * channels)808 int32_t TransferChannels(const char *value, uint32_t *channels)
809 {
810     if (value == NULL || channels == NULL) {
811         return HDF_FAILURE;
812     }
813     char *endptr = NULL;
814     errno = 0;
815     unsigned long tempChannels = strtoul(value, &endptr, DECIMAL_SYSTEM);
816     if ((errno == ERANGE && (tempChannels == ULONG_MAX)) || (errno != 0 && tempChannels == 0)) {
817         return HDF_FAILURE;
818     }
819     int32_t ret = CheckAttrChannel(tempChannels);
820     if (ret == 0) {
821         *channels = tempChannels;
822     }
823     return ret;
824 }
825 
TransferFrames(const char * value,uint64_t * frames)826 int32_t TransferFrames(const char *value, uint64_t *frames)
827 {
828     if (value == NULL || frames == NULL) {
829         return HDF_FAILURE;
830     }
831     char *endptr = NULL;
832     errno = 0;
833     uint64_t tempFrames = strtoull(value, &endptr, 10);
834     if ((errno == ERANGE && (tempFrames == ULLONG_MAX)) || (errno != 0 && tempFrames == 0)) {
835         return HDF_FAILURE;
836     } else {
837         *frames = tempFrames;
838         return HDF_SUCCESS;
839     }
840 }
841 
TransferSampleRate(const char * value,uint32_t * sampleRate)842 int32_t TransferSampleRate(const char *value, uint32_t *sampleRate)
843 {
844     if (value == NULL || sampleRate == NULL) {
845         return HDF_FAILURE;
846     }
847     char *endptr = NULL;
848     errno = 0;
849     unsigned long tempSampleRate = strtoul(value, &endptr, DECIMAL_SYSTEM);
850     if ((errno == ERANGE && (tempSampleRate == ULONG_MAX)) || (errno != 0 && tempSampleRate == 0)) {
851         return HDF_FAILURE;
852     }
853     int32_t ret = CheckAttrSamplingRate(tempSampleRate);
854     if (ret == 0) {
855         *sampleRate = tempSampleRate;
856     }
857     return ret;
858 }
859 
860 #ifdef A2DP_HDI_SERVICE
TransferA2dpSuspended(const char * value,uint32_t * result)861 int32_t TransferA2dpSuspended(const char *value, uint32_t *result)
862 {
863     if (value == NULL || result == NULL) {
864         return HDF_FAILURE;
865     }
866     char *endptr = NULL;
867     errno = 0;
868     unsigned long toSuspend = strtoul(value, &endptr, DECIMAL_SYSTEM);
869     if (errno == ERANGE) {
870         return HDF_FAILURE;
871     }
872     if (toSuspend != 0 && toSuspend != 1) {
873         HDF_LOGE("TransferA2dpSuspended, wrong value");
874         return HDF_FAILURE;
875     }
876     *result = toSuspend;
877     return HDF_SUCCESS;
878 }
879 #endif
880 
KeyValueListToMap(const char * keyValueList,struct ParamValMap mParamValMap[],int32_t * count)881 int32_t KeyValueListToMap(const char *keyValueList, struct ParamValMap mParamValMap[], int32_t *count)
882 {
883     if (keyValueList == NULL || mParamValMap == NULL || count == NULL) {
884         return HDF_FAILURE;
885     }
886     int i = 0;
887     char *mParaMap[MAP_MAX];
888     char buffer[ERROR_REASON_DESC_LEN] = {0};
889     errno_t ret = strcpy_s(buffer, ERROR_REASON_DESC_LEN, keyValueList);
890     if (ret != EOK) {
891         HDF_LOGE("strcpy_s failed!");
892         return HDF_FAILURE;
893     }
894     char *tempBuf = buffer;
895     char *outPtr = NULL;
896     char *inPtr = NULL;
897     while (i < MAP_MAX && ((mParaMap[i] = strtok_r(tempBuf, ";", &outPtr)) != NULL)) {
898         tempBuf = mParaMap[i];
899         if ((mParaMap[i] = strtok_r(tempBuf, "=", &inPtr)) != NULL) {
900             ret = strncpy_s(mParamValMap[i].key, EXTPARAM_LEN - 1, mParaMap[i], strlen(mParaMap[i]) + 1);
901             if (ret != 0) {
902                 return HDF_FAILURE;
903             }
904             tempBuf = NULL;
905         }
906         if ((mParaMap[i] = strtok_r(tempBuf, "=", &inPtr)) != NULL) {
907             ret = strncpy_s(mParamValMap[i].value, EXTPARAM_LEN - 1, mParaMap[i], strlen(mParaMap[i]) + 1);
908             if (ret != 0) {
909                 return HDF_FAILURE;
910             }
911             tempBuf = NULL;
912         }
913         tempBuf = NULL;
914         i++;
915     }
916     *count = i;
917     return HDF_SUCCESS;
918 }
919 
AddElementToList(char * keyValueList,int32_t listLenth,const char * key,void * value)920 int32_t AddElementToList(char *keyValueList, int32_t listLenth, const char *key, void *value)
921 {
922     if (keyValueList == NULL || key == NULL || value == NULL) {
923         return HDF_FAILURE;
924     }
925     int32_t ret = HDF_FAILURE;
926     char strValue[MAP_MAX] = { 0 };
927     if (strcmp(key, AUDIO_ATTR_PARAM_ROUTE) == 0) {
928         ret = sprintf_s(strValue, sizeof(strValue), "%s=%d;", key, *(reinterpret_cast<int32_t *>(value)));
929     } else if (strcmp(key, AUDIO_ATTR_PARAM_FORMAT) == 0) {
930         uint32_t formatBits = 0;
931         ret = FormatToBits((AudioFormat)(*(reinterpret_cast<int32_t *>(value))), &formatBits);
932         if (ret == 0) {
933             ret = sprintf_s(strValue, sizeof(strValue), "%s=%u;", key, formatBits);
934         }
935     } else if (strcmp(key, AUDIO_ATTR_PARAM_CHANNELS) == 0) {
936         ret = sprintf_s(strValue, sizeof(strValue), "%s=%u;", key, *(reinterpret_cast<uint32_t *>(value)));
937     } else if (strcmp(key, AUDIO_ATTR_PARAM_FRAME_COUNT) == 0) {
938         ret = sprintf_s(strValue, sizeof(strValue), "%s=%llu;", key, *(reinterpret_cast<uint64_t *>(value)));
939     } else if (strcmp(key, AUDIO_ATTR_PARAM_SAMPLING_RATE) == 0) {
940         ret = sprintf_s(strValue, sizeof(strValue), "%s=%u", key, *(reinterpret_cast<uint32_t *>(value)));
941     } else {
942         HDF_LOGE("NO this key correspond value!");
943         return HDF_FAILURE;
944     }
945     if (ret < 0) {
946         HDF_LOGE("sprintf_s failed!");
947         return HDF_FAILURE;
948     }
949     ret = strncat_s(keyValueList, listLenth, strValue, strlen(strValue));
950     if (ret < 0) {
951         HDF_LOGE("strcat_s failed!");
952         return HDF_FAILURE;
953     }
954     return HDF_SUCCESS;
955 }
956 
SetExtParam(const char * key,const char * value,struct ExtraParams * mExtraParams)957 int32_t SetExtParam(const char *key, const char *value, struct ExtraParams *mExtraParams)
958 {
959     if (key == NULL || value == NULL || mExtraParams == NULL) {
960         return HDF_FAILURE;
961     }
962     HDF_LOGI("SetExtParam, key is:%{public}s", key);
963     int ret = HDF_FAILURE;
964 #ifdef A2DP_HDI_SERVICE
965     if (strcmp(key, A2DP_SUSPEND) == 0) {
966         uint32_t result = 0;
967         ret = TransferA2dpSuspended(value, &result);
968         if (ret < 0) {
969             return HDF_FAILURE;
970         }
971         mExtraParams->audioStreamCtl = result;
972     }
973 #endif
974     if (strcmp(key, AUDIO_ATTR_PARAM_ROUTE) == 0) {
975         int32_t route = 0;
976         ret = TransferRoute(value, &route);
977         if (ret < 0) {
978             return HDF_FAILURE;
979         }
980         mExtraParams->route = route;
981     } else if (strcmp(key, AUDIO_ATTR_PARAM_FORMAT) == 0) {
982         int32_t format = 0;
983         ret = TransferFormat(value, &format);
984         if (ret < 0) {
985             return HDF_FAILURE;
986         }
987         mExtraParams->format = format;
988     } else if (strcmp(key, AUDIO_ATTR_PARAM_CHANNELS) == 0) {
989         uint32_t channels = 0;
990         ret = TransferChannels(value, &channels);
991         if (ret < 0) {
992             return HDF_FAILURE;
993         }
994         mExtraParams->channels = channels;
995     } else if (strcmp(key, AUDIO_ATTR_PARAM_FRAME_COUNT) == 0) {
996         uint64_t frames = 0;
997         ret = TransferFrames(value, &frames);
998         if (ret < 0) {
999             return HDF_FAILURE;
1000         }
1001         mExtraParams->frames = frames;
1002         mExtraParams->flag = true;
1003     } else if (strcmp(key, AUDIO_ATTR_PARAM_SAMPLING_RATE) == 0) {
1004         uint32_t sampleRate = 0;
1005         ret = TransferSampleRate(value, &sampleRate);
1006         if (ret < 0) {
1007             return HDF_FAILURE;
1008         }
1009         mExtraParams->sampleRate = sampleRate;
1010     } else {
1011         HDF_LOGE("NO this key correspond value or value is invalid!");
1012         return HDF_FAILURE;
1013     }
1014     return ret;
1015 }
1016 
GetErrorReason(int reason,char * reasonDesc)1017 int32_t GetErrorReason(int reason, char *reasonDesc)
1018 {
1019     int32_t ret;
1020     if (reasonDesc == NULL) {
1021         return HDF_FAILURE;
1022     }
1023     switch (reason) {
1024         case HDF_FAILURE:
1025             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("NOT SUPPORT") + 1, "%s", "NOT SUPPORT");
1026             break;
1027         case HDF_ERR_NOT_SUPPORT:
1028             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("BUFFER FULL") + 1, "%s", "BUFFER FULL");
1029             break;
1030         default:
1031             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("UNKNOW") + 1, "%s", "UNKNOW");
1032             break;
1033     }
1034     if (ret < 0) {
1035         HDF_LOGE("sprintf_s failed!");
1036         return HDF_FAILURE;
1037     }
1038     return HDF_SUCCESS;
1039 }
1040 
AudioSetExtraParams(const char * keyValueList,int32_t * count,struct ExtraParams * mExtraParams,int32_t * sumOk)1041 int32_t AudioSetExtraParams(const char *keyValueList, int32_t *count,
1042     struct ExtraParams *mExtraParams, int32_t *sumOk)
1043 {
1044     if (keyValueList == NULL || count == NULL || mExtraParams == NULL || sumOk == NULL) {
1045         return AUDIO_HAL_ERR_INTERNAL;
1046     }
1047     struct ParamValMap mParamValMap[MAP_MAX];
1048     int32_t ret = KeyValueListToMap(keyValueList, mParamValMap, count);
1049     if (ret < 0) {
1050         HDF_LOGE("Convert to map FAIL!");
1051         return AUDIO_HAL_ERR_INTERNAL;
1052     }
1053     int index = 0;
1054     mExtraParams->route = -1;
1055     mExtraParams->format = -1;
1056     mExtraParams->channels = 0;
1057     mExtraParams->frames = 0;
1058     mExtraParams->sampleRate = 0;
1059     mExtraParams->flag = false;
1060     while (index < *count) {
1061         ret = SetExtParam(mParamValMap[index].key, mParamValMap[index].value, mExtraParams);
1062         if (ret < 0) {
1063             return AUDIO_HAL_ERR_INTERNAL;
1064         } else {
1065             (*sumOk)++;
1066         }
1067         index++;
1068     }
1069     return AUDIO_HAL_SUCCESS;
1070 }
1071 }
1072