1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "audio_adapter_info_common.h"
17 #include <ctype.h>
18 #include <stdio.h>
19 #include <sys/mman.h>
20 #include <unistd.h>
21 #include "audio_common.h"
22 #include "audio_internal.h"
23 #include "audio_uhdf_log.h"
24 #include "osal_mem.h"
25 #include "securec.h"
26 
27 #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL
28 
29 #define AUDIO_ADAPTER_CONFIG HDF_CONFIG_DIR "/audio_adapter.json"
30 #define ADAPTER_NAME_LEN     32
31 #define PORT_NAME_LEN        ADAPTER_NAME_LEN
32 #define SUPPORT_PORT_NUM_MAX 10
33 #define SUPPORT_PORT_ID_MAX  41
34 #define CONFIG_FILE_SIZE_MAX ((SUPPORT_ADAPTER_NUM_MAX) * 1024 * 2) // 16KB
35 #define CONFIG_CHANNEL_COUNT 2                                    // two channels
36 #define TIME_BASE_YEAR_1900  1900
37 #define DECIMAL_SYSTEM       10
38 #define MAX_ADDR_RECORD_NUM  ((SUPPORT_ADAPTER_NUM_MAX) * 3)
39 
40 uint32_t g_adapterNum = 0;
41 struct AudioAdapterDescriptor *g_audioAdapterDescs = NULL;
42 
AudioAdapterGetConfigDescs(void)43 struct AudioAdapterDescriptor *AudioAdapterGetConfigDescs(void)
44 {
45     return g_audioAdapterDescs;
46 }
47 
AudioAdapterGetAdapterNum(void)48 int32_t AudioAdapterGetAdapterNum(void)
49 {
50     return g_adapterNum;
51 }
52 
AudioAdapterExist(const char * adapterName)53 int32_t AudioAdapterExist(const char *adapterName)
54 {
55     if (adapterName == NULL) {
56         AUDIO_FUNC_LOGE("Invalid parameter!");
57         return HDF_ERR_INVALID_PARAM;
58     }
59 
60     if (g_audioAdapterDescs == NULL || g_adapterNum > SUPPORT_ADAPTER_NUM_MAX) {
61         AUDIO_FUNC_LOGE("no adapter info");
62         return HDF_FAILURE;
63     }
64 
65     for (uint32_t i = 0; i < g_adapterNum; i++) {
66         if (strcmp(adapterName, g_audioAdapterDescs[i].adapterName) == 0) {
67             return i;
68         }
69     }
70     AUDIO_FUNC_LOGE("adapterName=%{public}s does not exist!", adapterName);
71 
72     return HDF_FAILURE;
73 }
74 
AudioAdapterJudegReleaseDescs(const struct AudioAdapterDescriptor * desc)75 static void AudioAdapterJudegReleaseDescs(const struct AudioAdapterDescriptor *desc)
76 {
77     uint32_t portIdx;
78 
79     if (desc->adapterName != NULL) {
80         AudioMemFree((void **)&desc->adapterName);
81     }
82 
83     if (desc->ports != NULL) {
84         portIdx = 0;
85         if (desc->portsLen <= 0 || desc->portsLen > SUPPORT_PORT_NUM_MAX) {
86             AUDIO_FUNC_LOGE("desc->portsLen error!");
87             AudioMemFree((void **)&desc->ports);
88             return;
89         }
90 
91         while (portIdx < desc->portsLen) {
92             if (desc->ports[portIdx].portName != NULL) {
93                 AudioMemFree((void **)&desc->ports[portIdx].portName);
94             }
95             portIdx++;
96         }
97         AudioMemFree((void **)&desc->ports);
98     }
99 }
100 
AudioAdapterReleaseDescs(const struct AudioAdapterDescriptor * descs,uint32_t adapterNum)101 static void AudioAdapterReleaseDescs(const struct AudioAdapterDescriptor *descs, uint32_t adapterNum)
102 {
103     uint32_t adapterIdx = 0;
104 
105     if (descs == NULL) {
106         AUDIO_FUNC_LOGE("Invalid parameter!");
107         return;
108     }
109 
110     while (adapterIdx < adapterNum) {
111         AudioAdapterJudegReleaseDescs(&descs[adapterIdx]);
112         adapterIdx++;
113     }
114 }
115 
MatchAdapterType(const char * adapterName,uint32_t portId)116 enum AudioAdapterType MatchAdapterType(const char *adapterName, uint32_t portId)
117 {
118     if (adapterName == NULL) {
119         AUDIO_FUNC_LOGE("Invalid parameter!");
120         return AUDIO_ADAPTER_MAX;
121     }
122 
123     if (strncmp(adapterName, "primary", strlen("primary")) == 0) {
124         if (portId >= AUDIO_PRIMARY_ID_MIN && portId <= AUDIO_PRIMARY_ID_MAX) {
125             return AUDIO_ADAPTER_PRIMARY;
126         }
127         return AUDIO_ADAPTER_PRIMARY_EXT;
128     } else if (strcmp(adapterName, "hdmi") == 0) {
129         return AUDIO_ADAPTER_HDMI;
130     } else if (strcmp(adapterName, "usb") == 0) {
131         return AUDIO_ADAPTER_USB;
132     } else if (strcmp(adapterName, "a2dp") == 0) {
133         return AUDIO_ADAPTER_A2DP;
134     } else {
135         return AUDIO_ADAPTER_MAX;
136     }
137 }
138 
AudioAdaptersForUser(InterfaceLibModeGetAllCardInfo getAllCardInfo,struct AudioAdapterDescriptor * descs,uint32_t * size)139 int32_t AudioAdaptersForUser(InterfaceLibModeGetAllCardInfo getAllCardInfo,
140     struct AudioAdapterDescriptor *descs, uint32_t *size)
141 {
142     if (getAllCardInfo == NULL || descs == NULL || size == NULL) {
143         AUDIO_FUNC_LOGE("Invalid parameter!");
144         return HDF_ERR_INVALID_PARAM;
145     }
146 
147     int realSize = 0;
148 
149     if (getAllCardInfo(&descs, &realSize) != HDF_SUCCESS) {
150         AUDIO_FUNC_LOGE("set descs is failed!");
151         return HDF_FAILURE;
152     }
153 
154     if ((uint32_t)realSize > *size) {
155         AUDIO_FUNC_LOGE("A larger buffer is required! realSize=%{public}d;requestSize=%{public}d", realSize, *size);
156         return HDF_FAILURE;
157     }
158 
159     *size = (uint32_t)realSize;
160 
161     if (g_audioAdapterDescs == NULL || g_adapterNum != (uint32_t)realSize) {
162         AudioAdapterReleaseDescs(g_audioAdapterDescs, g_adapterNum);
163         AudioMemFree((void **)&g_audioAdapterDescs);
164         if (getAllCardInfo(&g_audioAdapterDescs, (int *)&g_adapterNum) != HDF_SUCCESS) {
165             AUDIO_FUNC_LOGE("set g_audioAdapterDescs is failed!");
166             return HDF_FAILURE;
167         }
168     }
169     return HDF_SUCCESS;
170 }
171 
ReleaseAudioManagerObjectComm(struct IAudioManager * object)172 bool ReleaseAudioManagerObjectComm(struct IAudioManager *object)
173 {
174     if (object == NULL) {
175         AUDIO_FUNC_LOGE("object is NULL");
176         return false;
177     }
178 
179     object->GetAllAdapters = NULL;
180     object->LoadAdapter = NULL;
181     object->UnloadAdapter = NULL;
182     object->ReleaseAudioManagerObject = NULL;
183 
184     AudioAdapterReleaseDescs(g_audioAdapterDescs, g_adapterNum);
185     AudioMemFree((void **)&g_audioAdapterDescs);
186     g_adapterNum = 0;
187 
188     return true;
189 }
190 
191 static enum AudioFormat g_formatIdZero = AUDIO_FORMAT_TYPE_PCM_16_BIT;
192 
InitPortForCapabilitySub(struct AudioPort portIndex,struct AudioPortCapability * capabilityIndex)193 int32_t InitPortForCapabilitySub(struct AudioPort portIndex, struct AudioPortCapability *capabilityIndex)
194 {
195     if (capabilityIndex == NULL) {
196         AUDIO_FUNC_LOGE("capabilityIndex Is NULL");
197         return HDF_FAILURE;
198     }
199     if (portIndex.portId == 0 || (portIndex.portId > 1 && portIndex.portId <= AUDIO_PRIMARY_ID_MAX)) {
200         capabilityIndex->deviceId = PIN_OUT_SPEAKER;
201         capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000;
202     } else if (portIndex.portId == 1 ||
203         (portIndex.portId >= AUDIO_USB_ID_MIN && portIndex.portId <= AUDIO_USB_ID_MAX)) {
204         capabilityIndex->deviceId = PIN_OUT_HEADSET;
205         capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000 | AUDIO_SAMPLE_RATE_MASK_8000;
206     } else if (portIndex.portId >= AUDIO_PRIMARY_EXT_ID_MIN && portIndex.portId <= AUDIO_PRIMARY_EXT_ID_MAX) {
207         capabilityIndex->deviceId = PIN_OUT_SPEAKER;
208     } else if (portIndex.portId >= AUDIO_HDMI_ID_MIN && portIndex.portId <= AUDIO_HDMI_ID_MAX) {
209         capabilityIndex->deviceId = PIN_OUT_HDMI;
210         capabilityIndex->sampleRateMasks = AUDIO_SAMPLE_RATE_MASK_16000 | AUDIO_SAMPLE_RATE_MASK_24000;
211     } else {
212         AUDIO_FUNC_LOGE("The port ID not support!");
213         return HDF_ERR_NOT_SUPPORT;
214     }
215     capabilityIndex->hardwareMode = true;
216     capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO;
217     capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT;
218     capabilityIndex->deviceType = portIndex.dir;
219     capabilityIndex->formatNum = 1;
220     capabilityIndex->formatsLen = 1;
221     capabilityIndex->formats = &g_formatIdZero;
222     capabilityIndex->subPortsLen = 1;
223     capabilityIndex->subPorts = (struct AudioSubPortCapability *)OsalMemCalloc(
224         capabilityIndex->subPortsLen * sizeof(struct AudioSubPortCapability));
225     if (capabilityIndex->subPorts == NULL) {
226         AUDIO_FUNC_LOGE("The pointer is null!");
227         return HDF_FAILURE;
228     }
229     capabilityIndex->subPorts->portId = portIndex.portId;
230     capabilityIndex->subPorts->desc = portIndex.portName;
231     capabilityIndex->subPorts->mask = PORT_PASSTHROUGH_LPCM;
232     return HDF_SUCCESS;
233 }
234 
FormatToBits(enum AudioFormat format,uint32_t * formatBits)235 int32_t FormatToBits(enum AudioFormat format, uint32_t *formatBits)
236 {
237     if (formatBits == NULL) {
238         AUDIO_FUNC_LOGE("Invalid parameter!");
239         return HDF_FAILURE;
240     }
241     switch (format) {
242         case AUDIO_FORMAT_TYPE_PCM_32_BIT:
243             *formatBits = BIT_NUM_32;
244             return HDF_SUCCESS;
245         case AUDIO_FORMAT_TYPE_PCM_24_BIT:
246             *formatBits = BIT_NUM_24;
247             return HDF_SUCCESS;
248         case AUDIO_FORMAT_TYPE_PCM_16_BIT:
249             *formatBits = BIT_NUM_16;
250             return HDF_SUCCESS;
251         case AUDIO_FORMAT_TYPE_PCM_8_BIT:
252             *formatBits = BIT_NUM_8;
253             return HDF_SUCCESS;
254         default:
255             return HDF_ERR_NOT_SUPPORT;
256     }
257 }
258 
BitsToFormat(enum AudioFormat * format,long formatBits)259 static int32_t BitsToFormat(enum AudioFormat *format, long formatBits)
260 {
261     switch (formatBits) {
262         case BIT_NUM_32:
263             *format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
264             return HDF_SUCCESS;
265         case BIT_NUM_24:
266             *format = AUDIO_FORMAT_TYPE_PCM_24_BIT;
267             return HDF_SUCCESS;
268         case BIT_NUM_16:
269             *format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
270             return HDF_SUCCESS;
271         case BIT_NUM_8:
272             *format = AUDIO_FORMAT_TYPE_PCM_8_BIT;
273             return HDF_SUCCESS;
274         default:
275             return HDF_ERR_NOT_SUPPORT;
276     }
277 }
278 
CheckAttrRoute(int32_t param)279 static int32_t CheckAttrRoute(int32_t param)
280 {
281     if (param < DEEP_BUFF || param > LOW_LATRNCY) {
282         return HDF_FAILURE;
283     }
284     return HDF_SUCCESS;
285 }
286 
CheckAttrChannel(uint32_t param)287 static int32_t CheckAttrChannel(uint32_t param)
288 {
289     if (param != 1 && param != 2) { // channel 1 and 2
290         return HDF_FAILURE;
291     }
292     return HDF_SUCCESS;
293 }
294 
TransferRoute(const char * value,int32_t * route)295 static int32_t TransferRoute(const char *value, int32_t *route)
296 {
297     errno = 0;
298     char *endptr = NULL;
299 
300     if (value == NULL || route == NULL) {
301         AUDIO_FUNC_LOGE("Invalid parameter!");
302         return HDF_FAILURE;
303     }
304 
305     long tempRoute = strtol(value, &endptr, DECIMAL_SYSTEM);
306     if ((errno == ERANGE && (tempRoute == LONG_MAX || tempRoute == LONG_MIN)) || (errno != 0 && tempRoute == 0)) {
307         return HDF_FAILURE;
308     }
309 
310     int32_t ret = CheckAttrRoute((int32_t)tempRoute);
311     if (ret != HDF_SUCCESS) {
312         return ret;
313     }
314     *route = (int32_t)tempRoute;
315 
316     return HDF_SUCCESS;
317 }
318 
TransferFormat(const char * value,int32_t * format)319 static int32_t TransferFormat(const char *value, int32_t *format)
320 {
321     errno = 0;
322     char *endptr = NULL;
323 
324     if (value == NULL || format == NULL) {
325         AUDIO_FUNC_LOGE("Invalid parameter!");
326         return HDF_FAILURE;
327     }
328 
329     long tempFormat = strtol(value, &endptr, DECIMAL_SYSTEM);
330     if ((errno == ERANGE && (tempFormat == LONG_MAX || tempFormat == LONG_MIN)) || (errno != 0 && tempFormat == 0)) {
331         return HDF_FAILURE;
332     }
333     enum AudioFormat audioFormat;
334     int32_t ret = BitsToFormat(&audioFormat, tempFormat);
335     if (ret != HDF_SUCCESS) {
336         AUDIO_FUNC_LOGE("BitsToFormat fail! ret = %{public}d", ret);
337         return HDF_FAILURE;
338     }
339     ret = CheckAttrFormat(audioFormat);
340     if (ret != HDF_SUCCESS) {
341         AUDIO_FUNC_LOGE("CheckAttrForma fail! ret = %{public}d", ret);
342         return HDF_FAILURE;
343     }
344 
345     *format = audioFormat;
346     return HDF_SUCCESS;
347 }
348 
TransferChannels(const char * value,uint32_t * channels)349 static int32_t TransferChannels(const char *value, uint32_t *channels)
350 {
351     errno = 0;
352     char *endptr = NULL;
353 
354     if (value == NULL || channels == NULL) {
355         AUDIO_FUNC_LOGE("Invalid parameter!");
356         return HDF_FAILURE;
357     }
358 
359     unsigned long tempChannels = strtoul(value, &endptr, DECIMAL_SYSTEM);
360     if ((errno == ERANGE && (tempChannels == ULONG_MAX)) || (errno != 0 && tempChannels == 0)) {
361         return HDF_FAILURE;
362     }
363 
364     if (CheckAttrChannel((uint32_t)tempChannels) != HDF_SUCCESS) {
365         return HDF_FAILURE;
366     }
367     *channels = (uint32_t)tempChannels;
368 
369     return HDF_SUCCESS;
370 }
371 
TransferFrames(const char * value,uint64_t * frames)372 static int32_t TransferFrames(const char *value, uint64_t *frames)
373 {
374     errno = 0;
375     char *endptr = NULL;
376 
377     if (value == NULL || frames == NULL) {
378         AUDIO_FUNC_LOGE("Invalid parameter!");
379         return HDF_FAILURE;
380     }
381 
382     uint64_t tempFrames = strtoull(value, &endptr, 10);
383     if ((errno == ERANGE && (tempFrames == ULLONG_MAX)) || (errno != 0 && tempFrames == 0)) {
384         return HDF_FAILURE;
385     }
386     *frames = tempFrames;
387 
388     return HDF_SUCCESS;
389 }
390 
TransferSampleRate(const char * value,uint32_t * sampleRate)391 static int32_t TransferSampleRate(const char *value, uint32_t *sampleRate)
392 {
393     errno = 0;
394     char *endptr = NULL;
395 
396     if (value == NULL || sampleRate == NULL) {
397         AUDIO_FUNC_LOGE("Invalid parameter!");
398         return HDF_FAILURE;
399     }
400 
401     unsigned long tempSampleRate = strtoul(value, &endptr, DECIMAL_SYSTEM);
402     if ((errno == ERANGE && (tempSampleRate == ULONG_MAX)) || (errno != 0 && tempSampleRate == 0)) {
403         return HDF_FAILURE;
404     }
405 
406     if (CheckAttrSamplingRate(tempSampleRate) != HDF_SUCCESS) {
407         return HDF_FAILURE;
408     }
409     *sampleRate = tempSampleRate;
410 
411     return HDF_SUCCESS;
412 }
413 
KeyValueListToMap(const char * keyValueList,struct ParamValMap mParamValMap[],int32_t * count)414 static int32_t KeyValueListToMap(const char *keyValueList, struct ParamValMap mParamValMap[], int32_t *count)
415 {
416     int32_t i = 0;
417     int32_t ret = 0;
418     char *mParaMap[MAP_MAX];
419     char *outPtr = NULL;
420     char *inPtr = NULL;
421     char buffer[KEY_VALUE_LIST_LEN] = {0};
422 
423     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 
429     char *tempBuf = buffer;
430     while (i < MAP_MAX && ((mParaMap[i] = strtok_r(tempBuf, ";", &outPtr)) != NULL)) {
431         tempBuf = mParaMap[i];
432         if ((mParaMap[i] = strtok_r(tempBuf, "=", &inPtr)) != NULL) {
433             ret = strncpy_s(mParamValMap[i].key, EXTPARAM_LEN - 1, mParaMap[i], strlen(mParaMap[i]) + 1);
434             if (ret != EOK) {
435                 AUDIO_FUNC_LOGE("sprintf_s failed!");
436                 return HDF_FAILURE;
437             }
438             tempBuf = NULL;
439         }
440         if ((mParaMap[i] = strtok_r(tempBuf, "=", &inPtr)) != NULL) {
441             ret = strncpy_s(mParamValMap[i].value, EXTPARAM_LEN - 1, mParaMap[i], strlen(mParaMap[i]) + 1);
442             if (ret != EOK) {
443                 AUDIO_FUNC_LOGE("sprintf_s failed!");
444                 return HDF_FAILURE;
445             }
446             tempBuf = NULL;
447         } else {
448             AUDIO_FUNC_LOGE("Has no value!");
449             return HDF_FAILURE;
450         }
451         tempBuf = NULL;
452         i++;
453     }
454     *count = i;
455     return HDF_SUCCESS;
456 }
457 
AddElementToList(char * keyValueList,int32_t listLenth,const char * key,void * value)458 int32_t AddElementToList(char *keyValueList, int32_t listLenth, const char *key, void *value)
459 {
460     uint32_t formatBits = 0;
461     int32_t ret = HDF_FAILURE;
462     char strValue[MAP_MAX] = {0};
463 
464     if (keyValueList == NULL || key == NULL || value == NULL) {
465         AUDIO_FUNC_LOGE("Invalid parameter!");
466         return HDF_FAILURE;
467     }
468 
469     if (strcmp(key, AUDIO_ATTR_PARAM_ROUTE) == 0) {
470         ret = sprintf_s(strValue, sizeof(strValue), "%s=%d;", key, *((int32_t *)value));
471     } else if (strcmp(key, AUDIO_ATTR_PARAM_FORMAT) == 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     ret = strncat_s(keyValueList, listLenth, strValue, strlen(strValue));
491     if (ret < 0) {
492         AUDIO_FUNC_LOGE("strcat_s failed!");
493         return HDF_FAILURE;
494     }
495     return HDF_SUCCESS;
496 }
497 
SetExtParam(const char * key,const char * value,struct ExtraParams * mExtraParams)498 static int32_t SetExtParam(const char *key, const char *value, struct ExtraParams *mExtraParams)
499 {
500     int ret = HDF_FAILURE;
501 
502     if (key == NULL || value == NULL || mExtraParams == NULL) {
503         AUDIO_FUNC_LOGE("Invalid parameter!");
504         return HDF_FAILURE;
505     }
506     if (strcmp(key, AUDIO_ATTR_PARAM_ROUTE) == 0) {
507         int32_t route;
508         ret = TransferRoute(value, &route);
509         if (ret < 0) {
510             return HDF_FAILURE;
511         }
512         mExtraParams->route = route;
513     } else if (strcmp(key, AUDIO_ATTR_PARAM_FORMAT) == 0) {
514         int32_t format;
515         ret = TransferFormat(value, &format);
516         if (ret < 0) {
517             return HDF_FAILURE;
518         }
519         mExtraParams->format = format;
520     } else if (strcmp(key, AUDIO_ATTR_PARAM_CHANNELS) == 0) {
521         uint32_t channels;
522         ret = TransferChannels(value, &channels);
523         if (ret < 0) {
524             return HDF_FAILURE;
525         }
526         mExtraParams->channels = channels;
527     } else if (strcmp(key, AUDIO_ATTR_PARAM_FRAME_COUNT) == 0) {
528         uint64_t frames;
529         ret = TransferFrames(value, &frames);
530         if (ret < 0) {
531             return HDF_FAILURE;
532         }
533         mExtraParams->frames = frames;
534         mExtraParams->flag = true;
535     } else if (strcmp(key, AUDIO_ATTR_PARAM_SAMPLING_RATE) == 0) {
536         uint32_t sampleRate = 0;
537         ret = TransferSampleRate(value, &sampleRate);
538         if (ret < 0) {
539             return HDF_FAILURE;
540         }
541         mExtraParams->sampleRate = sampleRate;
542     } else {
543         AUDIO_FUNC_LOGE("NO this key correspond value or value is invalid!");
544         return HDF_FAILURE;
545     }
546     return ret;
547 }
548 
GetErrorReason(int reason,char * reasonDesc)549 int32_t GetErrorReason(int reason, char *reasonDesc)
550 {
551     int32_t ret;
552 
553     if (reasonDesc == NULL) {
554         AUDIO_FUNC_LOGE("Invalid parameter!");
555         return HDF_FAILURE;
556     }
557 
558     switch (reason) {
559         case HDF_FAILURE:
560             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("NOT SUPPORT") + 1, "%s", "NOT SUPPORT");
561             break;
562         case HDF_ERR_NOT_SUPPORT:
563             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("BUFFER FULL") + 1, "%s", "BUFFER FULL");
564             break;
565         default:
566             ret = snprintf_s(reasonDesc, ERROR_REASON_DESC_LEN - 1, strlen("UNKNOW") + 1, "%s", "UNKNOW");
567             break;
568     }
569     if (ret < 0) {
570         AUDIO_FUNC_LOGE("sprintf_s failed!");
571         return HDF_FAILURE;
572     }
573     return HDF_SUCCESS;
574 }
GetCurrentTime(char * currentTime)575 int32_t GetCurrentTime(char *currentTime)
576 {
577     time_t timeSec;
578     int32_t ret = 0;
579     char *week[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
580 
581     if (currentTime == NULL) {
582         AUDIO_FUNC_LOGE("Invalid parameter!");
583         return HDF_FAILURE;
584     }
585 
586     // Get the current time
587     (void)time(&timeSec);
588     struct tm *specificTime = localtime(&timeSec);
589     if (specificTime == NULL) {
590         AUDIO_FUNC_LOGE("localtime failed!");
591         return HDF_FAILURE;
592     }
593     ret = sprintf_s(currentTime, ERROR_REASON_DESC_LEN - 1, "%d/%d/%d %s %d:%d:%d",
594         (TIME_BASE_YEAR_1900 + specificTime->tm_year), (1 + specificTime->tm_mon), specificTime->tm_mday,
595         week[specificTime->tm_wday], specificTime->tm_hour, specificTime->tm_min, specificTime->tm_sec);
596     if (ret < 0) {
597         AUDIO_FUNC_LOGE("sprintf_s failed!");
598         return HDF_FAILURE;
599     }
600 
601     return HDF_SUCCESS;
602 }
603 
AudioSetExtraParams(const char * keyValueList,int32_t * count,struct ExtraParams * mExtraParams,int32_t * sumOk)604 int32_t AudioSetExtraParams(const char *keyValueList, int32_t *count, struct ExtraParams *mExtraParams, int32_t *sumOk)
605 {
606     int index = 0;
607     struct ParamValMap mParamValMap[MAP_MAX];
608 
609     if (keyValueList == NULL || count == NULL || mExtraParams == NULL || sumOk == NULL) {
610         AUDIO_FUNC_LOGE("Invalid parameter!");
611         return AUDIO_ERR_INVALID_PARAM;
612     }
613 
614     int32_t ret = KeyValueListToMap(keyValueList, mParamValMap, count);
615     if (ret < 0) {
616         AUDIO_FUNC_LOGE("Convert to map FAIL!");
617         return AUDIO_ERR_INTERNAL;
618     }
619     mExtraParams->route = -1;
620     mExtraParams->format = -1;
621     mExtraParams->channels = 0;
622     mExtraParams->frames = 0;
623     mExtraParams->sampleRate = 0;
624     mExtraParams->flag = false;
625     while (index < *count) {
626         ret = SetExtParam(mParamValMap[index].key, mParamValMap[index].value, mExtraParams);
627         if (ret < 0) {
628             return AUDIO_ERR_INTERNAL;
629         } else {
630             (*sumOk)++;
631         }
632         index++;
633     }
634     return AUDIO_SUCCESS;
635 }
636 
SetDescParam(struct AudioMmapBufferDescriptor * desc,FILE * fp,int32_t reqSize,int64_t * fileSize,int32_t * flags)637 int32_t SetDescParam(
638     struct AudioMmapBufferDescriptor *desc, FILE *fp, int32_t reqSize, int64_t *fileSize, int32_t *flags)
639 {
640     if (fp == NULL || desc == NULL || fileSize == NULL || flags == NULL) {
641         AUDIO_FUNC_LOGE("Invalid parameter!");
642         return AUDIO_ERR_INVALID_PARAM;
643     }
644 
645     *flags = desc->isShareable ? MAP_SHARED : MAP_PRIVATE;
646     desc->memoryFd = fileno(fp);
647     if (desc->memoryFd == -1) {
648         AUDIO_FUNC_LOGE("fileno failed, fd is %{public}d", desc->memoryFd);
649         return AUDIO_ERR_INTERNAL;
650     }
651 
652     *fileSize = lseek(desc->memoryFd, 0, SEEK_END);
653     if ((int64_t)reqSize > *fileSize) {
654         AUDIO_FUNC_LOGE("reqSize is out of file Size!");
655         return AUDIO_ERR_INVALID_PARAM;
656     }
657 
658     desc->memoryAddress = mmap(NULL, reqSize, PROT_READ | PROT_WRITE, *flags, desc->memoryFd, 0);
659     if (desc->memoryAddress == NULL || desc->memoryAddress == (void *)(-1)) {
660         AUDIO_FUNC_LOGE("AudioRenderReqMmapBuffer mmap FAIL and errno is:%{public}d !", errno);
661         return AUDIO_ERR_INTERNAL;
662     }
663 
664     return AUDIO_SUCCESS;
665 }
666