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_uhdf_log.h"
20 #include "osal_mem.h"
21 
22 #define HDF_LOG_TAG HDF_AUDIO_HAL_IMPL
23 
24 #define ADAPTER_NAME_LEN        32
25 #define PORT_NAME_LEN           ADAPTER_NAME_LEN
26 #define SUPPORT_PORT_NUM_MAX    10
27 #define SUPPORT_PORT_ID_MAX     41
28 #define CONFIG_FILE_SIZE_MAX    (SUPPORT_ADAPTER_NUM_MAX * 1024 * 2)  // 16KB
29 #define CONFIG_CHANNEL_COUNT    2 // two channels
30 #define TIME_BASE_YEAR_1900     1900
31 #define DECIMAL_SYSTEM          10
32 #define MAX_ADDR_RECORD_NUM     (SUPPORT_ADAPTER_NUM_MAX * 3)
33 
34 int32_t g_adapterNum = 0;
35 struct AudioAdapterDescriptor *g_audioAdapterDescs = NULL;
36 
AudioAdapterGetConfigDescs(void)37 struct AudioAdapterDescriptor *AudioAdapterGetConfigDescs(void)
38 {
39     return g_audioAdapterDescs;
40 }
41 
AudioAdapterGetAdapterNum(void)42 int32_t AudioAdapterGetAdapterNum(void)
43 {
44     return g_adapterNum;
45 }
46 
AudioAdapterExist(const char * adapterName)47 int32_t AudioAdapterExist(const char *adapterName)
48 {
49     if (adapterName == NULL) {
50         AUDIO_FUNC_LOGE("Invalid parameter!\n");
51 
52         return HDF_ERR_INVALID_PARAM;
53     }
54     if (g_audioAdapterDescs == NULL || g_adapterNum <= 0 || g_adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
55         AUDIO_FUNC_LOGE("no adapter info");
56 
57         return HDF_FAILURE;
58     }
59     for (int i = 0; i < g_adapterNum; i++) {
60         if (strcmp(adapterName, g_audioAdapterDescs[i].adapterName) == 0) {
61             return HDF_SUCCESS;
62         }
63     }
64     AUDIO_FUNC_LOGE("adapterName=%{public}s does not exist!", adapterName);
65     return HDF_FAILURE;
66 }
67 
AudioAdapterJudegReleaseDescs(const struct AudioAdapterDescriptor * desc)68 static void AudioAdapterJudegReleaseDescs(const struct AudioAdapterDescriptor *desc)
69 {
70     uint32_t portIdx;
71 
72     if (desc == NULL) {
73         AUDIO_FUNC_LOGE("param desc is null!");
74         return;
75     }
76 
77     if (desc->adapterName != NULL) {
78         AudioMemFree((void **)&desc->adapterName);
79     }
80 
81     if (desc->ports != NULL) {
82         portIdx = 0;
83         if (desc->portNum <= 0 || desc->portNum > SUPPORT_PORT_NUM_MAX) {
84             AUDIO_FUNC_LOGE("desc->portNum error!\n");
85             AudioMemFree((void **)&desc->ports);
86 
87             return;
88         }
89 
90         while (portIdx < desc->portNum) {
91             if (desc->ports[portIdx].portName != NULL) {
92                 AudioMemFree((void **)&desc->ports[portIdx].portName);
93             }
94             portIdx++;
95         }
96         AudioMemFree((void **)&desc->ports);
97     }
98 }
99 
AudioAdapterReleaseDescs(const struct AudioAdapterDescriptor * descs,int32_t adapterNum)100 void AudioAdapterReleaseDescs(const struct AudioAdapterDescriptor *descs, int32_t adapterNum)
101 {
102     int32_t adapterIdx = 0;
103 
104     if (descs == NULL || adapterNum <= 0 || adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
105         AUDIO_FUNC_LOGE("descs is null or adapterNum is invalid!");
106         return;
107     }
108 
109     if (adapterNum > g_adapterNum) {
110         adapterNum = g_adapterNum;
111     }
112 
113     while (adapterIdx < adapterNum) {
114         AudioAdapterJudegReleaseDescs(&descs[adapterIdx]);
115         adapterIdx++;
116     }
117 
118     AudioMemFree((void **)&descs);
119 }
120 
MatchAdapterType(const char * adapterName,uint32_t portId)121 enum AudioAdapterType MatchAdapterType(const char *adapterName, uint32_t portId)
122 {
123     if (adapterName == NULL) {
124         AUDIO_FUNC_LOGE("Invalid parameter!\n");
125         return AUDIO_ADAPTER_MAX;
126     }
127 
128     if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) {
129         if (portId >= AUDIO_PRIMARY_ID_MIN && portId <= AUDIO_PRIMARY_ID_MAX) {
130             return AUDIO_ADAPTER_PRIMARY;
131         }
132         return AUDIO_ADAPTER_PRIMARY_EXT;
133     } else if (strcmp(adapterName, HDMI) == 0) {
134         return AUDIO_ADAPTER_HDMI;
135     } else if (strcmp(adapterName, USB) == 0) {
136         return AUDIO_ADAPTER_USB;
137     } else if (strcmp(adapterName, A2DP) == 0) {
138         return AUDIO_ADAPTER_A2DP;
139     } else {
140         return AUDIO_ADAPTER_MAX;
141     }
142 }
143 
AudioAdapterCheckPortId(const char * adapterName,uint32_t portId)144 int32_t AudioAdapterCheckPortId(const char *adapterName, uint32_t portId)
145 {
146     if (adapterName == NULL) {
147         AUDIO_FUNC_LOGE("Invalid parameter!\n");
148         return HDF_ERR_INVALID_PARAM;
149     }
150 
151     enum AudioAdapterType adapterType = MatchAdapterType(adapterName, portId);
152     switch (adapterType) {
153         case AUDIO_ADAPTER_PRIMARY:
154             if (portId < AUDIO_PRIMARY_ID_MIN || portId > AUDIO_PRIMARY_ID_MAX) {
155                 AUDIO_FUNC_LOGE("portId is invalid!");
156                 return HDF_FAILURE;
157             }
158             break;
159         case AUDIO_ADAPTER_PRIMARY_EXT:
160             if (portId < AUDIO_PRIMARY_EXT_ID_MIN || portId > AUDIO_PRIMARY_EXT_ID_MAX) {
161                 AUDIO_FUNC_LOGE("portId is invalid!");
162                 return HDF_FAILURE;
163             }
164             break;
165         case AUDIO_ADAPTER_HDMI:
166             if (portId < AUDIO_HDMI_ID_MIN || portId > AUDIO_HDMI_ID_MAX) {
167                 AUDIO_FUNC_LOGE("portId is invalid!");
168                 return HDF_FAILURE;
169             }
170             break;
171         case AUDIO_ADAPTER_USB:
172             if (portId < AUDIO_USB_ID_MIN || portId > AUDIO_USB_ID_MAX) {
173                 AUDIO_FUNC_LOGE("portId is invalid!");
174                 return HDF_FAILURE;
175             }
176             break;
177         case AUDIO_ADAPTER_A2DP:
178             if (portId < AUDIO_A2DP_ID_MIN || portId > AUDIO_A2DP_ID_MAX) {
179                 AUDIO_FUNC_LOGE("portId is invalid!");
180                 return HDF_FAILURE;
181             }
182             break;
183         default:
184             AUDIO_FUNC_LOGE("An unsupported adapter type.");
185             return HDF_ERR_NOT_SUPPORT;
186     }
187 
188     return HDF_SUCCESS;
189 }
190 
ReleaseAudioManagerObjectComm(const struct AudioManager * object)191 bool ReleaseAudioManagerObjectComm(const struct AudioManager *object)
192 {
193     if (object == NULL) {
194         AUDIO_FUNC_LOGE("param object is null!");
195         return false;
196     }
197 
198     AudioAdapterReleaseDescs(g_audioAdapterDescs, g_adapterNum);
199     g_audioAdapterDescs = NULL;
200     g_adapterNum = 0;
201 
202     return true;
203 }
204 
205 static enum AudioFormat g_formatIdZero = AUDIO_FORMAT_TYPE_PCM_16_BIT;
InitPortForCapabilitySub(struct AudioPort portIndex,struct AudioPortCapability * capabilityIndex)206 int32_t InitPortForCapabilitySub(struct AudioPort portIndex, struct AudioPortCapability *capabilityIndex)
207 {
208     if (capabilityIndex == NULL) {
209         AUDIO_FUNC_LOGE("capabilityIndex Is NULL");
210         return HDF_FAILURE;
211     }
212     if (portIndex.portId == 0 || (portIndex.portId > 1 && portIndex.portId <= AUDIO_PRIMARY_ID_MAX)) {
213         capabilityIndex->deviceId = PIN_OUT_SPEAKER;
214         capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000;
215     } else if (portIndex.portId == 1 ||
216         (portIndex.portId >= AUDIO_USB_ID_MIN && portIndex.portId <= AUDIO_USB_ID_MAX)) {
217         capabilityIndex->deviceId = PIN_OUT_HEADSET;
218         capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000 | AUDIO_SAMPLE_RATE_MASK_8000;
219     } else if (portIndex.portId >= AUDIO_PRIMARY_EXT_ID_MIN && portIndex.portId <= AUDIO_PRIMARY_EXT_ID_MAX) {
220         capabilityIndex->deviceId = PIN_OUT_SPEAKER;
221     } else if (portIndex.portId >= AUDIO_HDMI_ID_MIN && portIndex.portId <= AUDIO_HDMI_ID_MAX) {
222         capabilityIndex->deviceId = PIN_OUT_HDMI;
223         capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000 | AUDIO_SAMPLE_RATE_MASK_24000;
224     } else {
225         AUDIO_FUNC_LOGE("The port ID not support!");
226         return HDF_ERR_NOT_SUPPORT;
227     }
228     capabilityIndex->hardwareMode = true;
229     capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO;
230     capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT;
231     capabilityIndex->deviceType = portIndex.dir;
232     capabilityIndex->formatNum = 1;
233     capabilityIndex->formats = &g_formatIdZero;
234     capabilityIndex->subPortsNum = 1;
235     capabilityIndex->subPorts = (struct AudioSubPortCapability *)OsalMemCalloc(
236         capabilityIndex->subPortsNum * sizeof(struct AudioSubPortCapability));
237     if (capabilityIndex->subPorts == NULL) {
238         AUDIO_FUNC_LOGE("The pointer is null!");
239         return HDF_FAILURE;
240     }
241     capabilityIndex->subPorts->portId = portIndex.portId;
242     capabilityIndex->subPorts->desc = portIndex.portName;
243     capabilityIndex->subPorts->mask = PORT_PASSTHROUGH_LPCM;
244     return HDF_SUCCESS;
245 }
246 
FormatToBits(enum AudioFormat format,uint32_t * formatBits)247 int32_t FormatToBits(enum AudioFormat format, uint32_t *formatBits)
248 {
249     if (formatBits == NULL) {
250         AUDIO_FUNC_LOGE("param formatBits is null!");
251         return HDF_FAILURE;
252     }
253     switch (format) {
254         case AUDIO_FORMAT_TYPE_PCM_32_BIT:
255             *formatBits = BIT_NUM_32;
256             return HDF_SUCCESS;
257         case AUDIO_FORMAT_TYPE_PCM_24_BIT:
258             *formatBits = BIT_NUM_24;
259             return HDF_SUCCESS;
260         case AUDIO_FORMAT_TYPE_PCM_16_BIT:
261             *formatBits = BIT_NUM_16;
262             return HDF_SUCCESS;
263         case AUDIO_FORMAT_TYPE_PCM_8_BIT:
264             *formatBits = BIT_NUM_8;
265             return HDF_SUCCESS;
266         default:
267             return HDF_ERR_NOT_SUPPORT;
268     }
269 }
270 
BitsToFormat(enum AudioFormat * format,int32_t formatBits)271 int32_t BitsToFormat(enum AudioFormat *format, int32_t formatBits)
272 {
273     if (format == NULL) {
274         AUDIO_FUNC_LOGE("param format is null!");
275         return HDF_FAILURE;
276     }
277     switch (formatBits) {
278         case BIT_NUM_32:
279             *format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
280             return HDF_SUCCESS;
281         case BIT_NUM_24:
282             *format = AUDIO_FORMAT_TYPE_PCM_24_BIT;
283             return HDF_SUCCESS;
284         case BIT_NUM_16:
285             *format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
286             return HDF_SUCCESS;
287         case BIT_NUM_8:
288             *format = AUDIO_FORMAT_TYPE_PCM_8_BIT;
289             return HDF_SUCCESS;
290         default:
291             return HDF_ERR_NOT_SUPPORT;
292     }
293 }
294 
CheckAttrRoute(int32_t param)295 int32_t CheckAttrRoute(int32_t param)
296 {
297     if (param < DEEP_BUFF || param > LOW_LATRNCY) {
298         AUDIO_FUNC_LOGE("param is invalid!");
299         return HDF_FAILURE;
300     }
301     return HDF_SUCCESS;
302 }
303 
CheckAttrChannel(uint32_t param)304 int32_t CheckAttrChannel(uint32_t param)
305 {
306     if (param != 1 && param != 2) { // channel 1 and 2
307         AUDIO_FUNC_LOGE("param is invalid!");
308         return HDF_FAILURE;
309     }
310     return HDF_SUCCESS;
311 }
312 
TransferRoute(const char * value,int32_t * route)313 int32_t TransferRoute(const char *value, int32_t *route)
314 {
315     if (value == NULL || route == NULL) {
316         AUDIO_FUNC_LOGE("param value or route is null!");
317         return HDF_FAILURE;
318     }
319     char *endptr = NULL;
320     errno = 0;
321     int64_t tempRoute = strtol(value, &endptr, DECIMAL_SYSTEM);
322     if ((errno == ERANGE && (tempRoute == LONG_MAX || tempRoute == LONG_MIN)) || (errno != 0 && tempRoute == 0)) {
323         AUDIO_FUNC_LOGE("TransferRoute failed!");
324         return HDF_FAILURE;
325     }
326     int32_t ret = CheckAttrRoute(tempRoute);
327     if (ret == 0) {
328         *route = tempRoute;
329     }
330     return ret;
331 }
332 
TransferFormat(const char * value,int32_t * format)333 int32_t TransferFormat(const char *value, int32_t *format)
334 {
335     if (value == NULL || format == NULL) {
336         AUDIO_FUNC_LOGE("param value or format is null!");
337         return HDF_FAILURE;
338     }
339     char *endptr = NULL;
340     errno = 0;
341     int64_t tempFormat = strtol(value, &endptr, DECIMAL_SYSTEM);
342     if ((errno == ERANGE && (tempFormat == LONG_MAX || tempFormat == LONG_MIN)) || (errno != 0 && tempFormat == 0)) {
343         return HDF_FAILURE;
344     }
345     enum AudioFormat audioFormat;
346     int32_t ret = BitsToFormat(&audioFormat, tempFormat);
347     if (ret == HDF_SUCCESS) {
348         ret = CheckAttrFormat(audioFormat);
349         if (ret == 0) {
350             *format = audioFormat;
351         }
352     }
353     return ret;
354 }
355 
TransferChannels(const char * value,uint32_t * channels)356 int32_t TransferChannels(const char *value, uint32_t *channels)
357 {
358     if (value == NULL || channels == NULL) {
359         AUDIO_FUNC_LOGE("param value or channels is null!");
360         return HDF_FAILURE;
361     }
362     char *endptr = NULL;
363     errno = 0;
364     uint64_t tempChannels = strtoul(value, &endptr, DECIMAL_SYSTEM);
365     if ((errno == ERANGE && (tempChannels == ULONG_MAX)) || (errno != 0 && tempChannels == 0)) {
366         AUDIO_FUNC_LOGE("strtoul failed!");
367         return HDF_FAILURE;
368     }
369     int32_t ret = CheckAttrChannel(tempChannels);
370     if (ret == 0) {
371         *channels = tempChannels;
372     }
373     return ret;
374 }
375 
TransferFrames(const char * value,uint64_t * frames)376 int32_t TransferFrames(const char *value, uint64_t *frames)
377 {
378     if (value == NULL || frames == NULL) {
379         AUDIO_FUNC_LOGE("param value or frames is null!");
380         return HDF_FAILURE;
381     }
382     char *endptr = NULL;
383     errno = 0;
384     uint64_t tempFrames = strtoull(value, &endptr, 10);
385     if ((errno == ERANGE && (tempFrames == ULLONG_MAX)) || (errno != 0 && tempFrames == 0)) {
386         AUDIO_FUNC_LOGE("strtoull is failed!");
387         return HDF_FAILURE;
388     } else {
389         *frames = tempFrames;
390         return HDF_SUCCESS;
391     }
392 }
393 
TransferSampleRate(const char * value,uint32_t * sampleRate)394 int32_t TransferSampleRate(const char *value, uint32_t *sampleRate)
395 {
396     if (value == NULL || sampleRate == NULL) {
397         AUDIO_FUNC_LOGE("param value or sampleRate is null!");
398         return HDF_FAILURE;
399     }
400     char *endptr = NULL;
401     errno = 0;
402     uint64_t tempSampleRate = strtoul(value, &endptr, DECIMAL_SYSTEM);
403     if ((errno == ERANGE && (tempSampleRate == ULONG_MAX)) || (errno != 0 && tempSampleRate == 0)) {
404         AUDIO_FUNC_LOGE("strtoul is failed!");
405         return HDF_FAILURE;
406     }
407     int32_t ret = CheckAttrSamplingRate(tempSampleRate);
408     if (ret == 0) {
409         *sampleRate = tempSampleRate;
410     }
411     return ret;
412 }
413 
KeyValueListToMap(const char * keyValueList,struct ParamValMap mParamValMap[],int32_t * count)414 int32_t KeyValueListToMap(const char *keyValueList, struct ParamValMap mParamValMap[], int32_t *count)
415 {
416     if (keyValueList == NULL || mParamValMap == NULL || count == NULL) {
417         AUDIO_FUNC_LOGE("param keyValueList or mParamValMap or count is null!");
418         return HDF_FAILURE;
419     }
420     int i = 0;
421     char *mParaMap[MAP_MAX];
422     char buffer[KEY_VALUE_LIST_LEN] = {0};
423     int32_t ret = sprintf_s(buffer, KEY_VALUE_LIST_LEN - 1, "%s", keyValueList);
424     if (ret < 0) {
425         AUDIO_FUNC_LOGE("sprintf_s failed!");
426         return HDF_FAILURE;
427     }
428     char *tempBuf = buffer;
429     char *outPtr = NULL;
430     char *inPtr = NULL;
431     while (i < MAP_MAX) {
432         if ((mParaMap[i] = strtok_r(tempBuf, ";", &outPtr)) == NULL) {
433             break;
434         }
435         tempBuf = mParaMap[i];
436         if ((mParaMap[i] = strtok_r(tempBuf, "=", &inPtr)) != NULL) {
437             ret = strncpy_s(mParamValMap[i].key, EXTPARAM_LEN - 1, mParaMap[i], strlen(mParaMap[i]) + 1);
438             if (ret != 0) {
439                 return HDF_FAILURE;
440             }
441             tempBuf = NULL;
442         }
443         if ((mParaMap[i] = strtok_r(tempBuf, "=", &inPtr)) != NULL) {
444             ret = strncpy_s(mParamValMap[i].value, EXTPARAM_LEN - 1, mParaMap[i], strlen(mParaMap[i]) + 1);
445             if (ret != 0) {
446                 return HDF_FAILURE;
447             }
448             tempBuf = NULL;
449         } else {
450             AUDIO_FUNC_LOGE("Has no value!");
451             return HDF_FAILURE;
452         }
453         tempBuf = NULL;
454         i++;
455     }
456     *count = i;
457     return HDF_SUCCESS;
458 }
459 
AddElementToList(char * keyValueList,int32_t listLenth,const char * key,void * value)460 int32_t AddElementToList(char *keyValueList, int32_t listLenth, const char *key, void *value)
461 {
462     if (keyValueList == NULL || listLenth < 0 || key == NULL || value == NULL) {
463         AUDIO_FUNC_LOGE("param is null!");
464         return HDF_FAILURE;
465     }
466     int32_t ret = HDF_FAILURE;
467     char strValue[MAP_MAX] = { 0 };
468     if (strcmp(key, AUDIO_ATTR_PARAM_ROUTE) == 0) {
469         ret = sprintf_s(strValue, sizeof(strValue), "%s=%d;", key, *((int32_t *)value));
470     } else if (strcmp(key, AUDIO_ATTR_PARAM_FORMAT) == 0) {
471         uint32_t formatBits = 0;
472         ret = FormatToBits((enum AudioFormat)(*((int32_t *)value)), &formatBits);
473         if (ret == 0) {
474             ret = sprintf_s(strValue, sizeof(strValue), "%s=%u;", key, formatBits);
475         }
476     } else if (strcmp(key, AUDIO_ATTR_PARAM_CHANNELS) == 0) {
477         ret = sprintf_s(strValue, sizeof(strValue), "%s=%u;", key, *((uint32_t *)value));
478     } else if (strcmp(key, AUDIO_ATTR_PARAM_FRAME_COUNT) == 0) {
479         ret = sprintf_s(strValue, sizeof(strValue), "%s=%llu;", key, *((uint64_t *)value));
480     } else if (strcmp(key, AUDIO_ATTR_PARAM_SAMPLING_RATE) == 0) {
481         ret = sprintf_s(strValue, sizeof(strValue), "%s=%u", key, *((uint32_t *)value));
482     } else {
483         AUDIO_FUNC_LOGE("NO this key correspond value!");
484         return HDF_FAILURE;
485     }
486     if (ret < 0) {
487         AUDIO_FUNC_LOGE("sprintf_s failed!");
488         return HDF_FAILURE;
489     }
490     if (listLenth < (int32_t)strlen(strValue)) {
491         AUDIO_FUNC_LOGE("keyValueList length too little!");
492         return HDF_FAILURE;
493     }
494     ret = strncat_s(keyValueList, listLenth, strValue, strlen(strValue));
495     if (ret != EOK) {
496         AUDIO_FUNC_LOGE("strcat_s failed!");
497         return HDF_FAILURE;
498     }
499     return HDF_SUCCESS;
500 }
501 
SetExtParam(const char * key,const char * value,struct ExtraParams * mExtraParams)502 int32_t SetExtParam(const char *key, const char *value, struct ExtraParams *mExtraParams)
503 {
504     if (key == NULL || value == NULL || mExtraParams == NULL) {
505         AUDIO_FUNC_LOGE("param key or value or mExtraParams is null!");
506         return HDF_FAILURE;
507     }
508     int ret = HDF_FAILURE;
509     if (strcmp(key, AUDIO_ATTR_PARAM_ROUTE) == 0) {
510         int32_t route;
511         if ((ret = TransferRoute(value, &route)) < 0) {
512             AUDIO_FUNC_LOGE("TransferRoute failed ! ret = %{public}d\n", ret);
513             return HDF_FAILURE;
514         }
515         mExtraParams->route = route;
516     } else if (strcmp(key, AUDIO_ATTR_PARAM_FORMAT) == 0) {
517         int32_t format = 0;
518         if ((ret = TransferFormat(value, &format)) < 0) {
519             AUDIO_FUNC_LOGE("TransferFormat failed ! ret = %{public}d\n", ret);
520             return HDF_FAILURE;
521         }
522         mExtraParams->format = format;
523     } else if (strcmp(key, AUDIO_ATTR_PARAM_CHANNELS) == 0) {
524         uint32_t channels;
525         if ((ret = TransferChannels(value, &channels)) < 0) {
526             AUDIO_FUNC_LOGE("TransferChannels failed ! ret = %{public}d\n", ret);
527             return HDF_FAILURE;
528         }
529         mExtraParams->channels = channels;
530     } else if (strcmp(key, AUDIO_ATTR_PARAM_FRAME_COUNT) == 0) {
531         uint64_t frames;
532         if ((ret = TransferFrames(value, &frames)) < 0) {
533             AUDIO_FUNC_LOGE("TransferFrames failed ! ret = %{public}d\n", ret);
534             return HDF_FAILURE;
535         }
536         mExtraParams->frames = frames;
537         mExtraParams->flag = true;
538     } else if (strcmp(key, AUDIO_ATTR_PARAM_SAMPLING_RATE) == 0) {
539         uint32_t sampleRate = 0;
540         if ((ret = TransferSampleRate(value, &sampleRate)) < 0) {
541             AUDIO_FUNC_LOGE("TransferSampleRate failed ! ret = %{public}d\n", ret);
542             return HDF_FAILURE;
543         }
544         mExtraParams->sampleRate = sampleRate;
545     } else {
546         AUDIO_FUNC_LOGE("NO this key correspond value or value is invalid!");
547         return HDF_FAILURE;
548     }
549     return ret;
550 }
551 
GetErrorReason(int reason,char * reasonDesc)552 int32_t GetErrorReason(int reason, char *reasonDesc)
553 {
554     int32_t ret;
555     if (reasonDesc == NULL) {
556         AUDIO_FUNC_LOGE("param reasonDesc is null!");
557         return HDF_FAILURE;
558     }
559     switch (reason) {
560         case HDF_FAILURE:
561             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("NOT SUPPORT") + 1, "%s", "NOT SUPPORT");
562             break;
563         case HDF_ERR_NOT_SUPPORT:
564             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("BUFFER FULL") + 1, "%s", "BUFFER FULL");
565             break;
566         default:
567             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("UNKNOW") + 1, "%s", "UNKNOW");
568             break;
569     }
570     if (ret < 0) {
571         AUDIO_FUNC_LOGE("sprintf_s failed!");
572         return HDF_FAILURE;
573     }
574     return HDF_SUCCESS;
575 }
GetCurrentTime(char * currentTime)576 int32_t GetCurrentTime(char *currentTime)
577 {
578     if (currentTime == NULL) {
579         AUDIO_FUNC_LOGE("param currentTime is null!");
580         return HDF_FAILURE;
581     }
582     // Get the current time
583     char *week[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
584     time_t timeSec;
585     (void)time(&timeSec);
586     struct tm *specificTime = localtime(&timeSec);
587     if (specificTime == NULL) {
588         AUDIO_FUNC_LOGE("localtime failed!");
589         return HDF_FAILURE;
590     }
591     int32_t ret = sprintf_s(currentTime, ERROR_REASON_DESC_LEN - 1, "%d/%d/%d %s %d:%d:%d",
592         (TIME_BASE_YEAR_1900 + specificTime->tm_year), (1 + specificTime->tm_mon), specificTime->tm_mday,
593         week[specificTime->tm_wday], specificTime->tm_hour, specificTime->tm_min, specificTime->tm_sec);
594     if (ret < 0) {
595         AUDIO_FUNC_LOGE("sprintf_s failed!");
596         return HDF_FAILURE;
597     }
598     return HDF_SUCCESS;
599 }
600 
AudioSetExtraParams(const char * keyValueList,int32_t * count,struct ExtraParams * mExtraParams,int32_t * sumOk)601 int32_t AudioSetExtraParams(const char *keyValueList, int32_t *count,
602     struct ExtraParams *mExtraParams, int32_t *sumOk)
603 {
604     if (keyValueList == NULL || count == NULL || mExtraParams == NULL || sumOk == NULL) {
605         AUDIO_FUNC_LOGE("param keyValueList or count or mExtraParams or sumOk is null!");
606         return AUDIO_HAL_ERR_INTERNAL;
607     }
608     struct ParamValMap mParamValMap[MAP_MAX];
609     int32_t ret = KeyValueListToMap(keyValueList, mParamValMap, count);
610     if (ret < 0) {
611         AUDIO_FUNC_LOGE("Convert to map FAIL!");
612         return AUDIO_HAL_ERR_INTERNAL;
613     }
614     int index = 0;
615     mExtraParams->route = -1;
616     mExtraParams->format = -1;
617     mExtraParams->channels = 0;
618     mExtraParams->frames = 0;
619     mExtraParams->sampleRate = 0;
620     mExtraParams->flag = false;
621     while (index < *count) {
622         ret = SetExtParam(mParamValMap[index].key, mParamValMap[index].value, mExtraParams);
623         if (ret < 0) {
624             return AUDIO_HAL_ERR_INTERNAL;
625         } else {
626             (*sumOk)++;
627         }
628         index++;
629     }
630     return AUDIO_HAL_SUCCESS;
631 }
632