1 /*
2 * Copyright (c) 2021-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_pathselect.h"
17 #include "audio_uhdf_log.h"
18 #include "cJSON.h"
19 #include "osal_mem.h"
20 #include "securec.h"
21
22 #ifdef IDL_MODE
23 #define HDF_LOG_TAG AUDIO_HDI_IMPL
24 #else
25 #define HDF_LOG_TAG HDF_AUDIO_HAL_IMPL
26 #endif
27
28 #define SPEAKER "Speaker"
29 #define HEADPHONES "Headphones"
30 #define MIC "MIC"
31 #define HS_MIC "micHs"
32 #define EARPIECE "earpiece"
33 #define BLUETOOTH_SCO "Bluetooth"
34 #define BLUETOOTH_SCO_HEADSET "Bluetooth_SCO_Headset"
35 #define JSON_UNPRINT 1
36
37 #define OUTPUT_MASK 0xFFF
38 #define OUTPUT_OFFSET 12
39 #define INPUT_MASK 0x80000FF
40 #define INPUT_OFFSET 27
41
42 #define AUDIO_DEV_ON 1
43 #define AUDIO_DEV_OFF 0
44
45 #define HDF_PATH_NUM_MAX 32
46
47 static cJSON *g_cJsonObj = NULL;
48
AudioPathSelGetConfToJsonObj(void)49 int32_t AudioPathSelGetConfToJsonObj(void)
50 {
51 FILE *fpJson = NULL;
52 char *pJsonStr = NULL;
53 if (g_cJsonObj != NULL) {
54 return HDF_SUCCESS;
55 }
56 fpJson = fopen(CJSONFILE_CONFIG_PATH, "r");
57 if (fpJson == NULL) {
58 AUDIO_FUNC_LOGE("open %{pulbic}s fail!", CJSONFILE_CONFIG_PATH);
59 return HDF_FAILURE;
60 }
61 if (fseek(fpJson, 0, SEEK_END) != HDF_SUCCESS) {
62 AUDIO_FUNC_LOGE("fseek fail!");
63 (void)fclose(fpJson);
64 return HDF_FAILURE;
65 }
66 int32_t jsonStrSize = ftell(fpJson);
67 rewind(fpJson);
68 if (jsonStrSize <= 0) {
69 (void)fclose(fpJson);
70 return HDF_FAILURE;
71 }
72 pJsonStr = (char *)OsalMemCalloc(jsonStrSize + 1);
73 if (pJsonStr == NULL) {
74 (void)fclose(fpJson);
75 return HDF_FAILURE;
76 }
77 if (fread(pJsonStr, jsonStrSize, 1, fpJson) != 1) {
78 AUDIO_FUNC_LOGE("read to file fail!");
79 (void)fclose(fpJson);
80 fpJson = NULL;
81 OsalMemFree(pJsonStr);
82 return HDF_FAILURE;
83 }
84 (void)fclose(fpJson);
85 fpJson = NULL;
86 #ifndef JSON_UNPRINT
87 AUDIO_FUNC_LOGI("pJsonStr = %{public}s", pJsonStr);
88 #endif
89 g_cJsonObj = cJSON_Parse(pJsonStr);
90 if (g_cJsonObj == NULL) {
91 AUDIO_FUNC_LOGE("cJSON_GetErrorPtr() = %{public}s", cJSON_GetErrorPtr());
92 OsalMemFree(pJsonStr);
93 return HDF_FAILURE;
94 }
95 OsalMemFree(pJsonStr);
96 return HDF_SUCCESS;
97 }
98
AudioPathSelGetDeviceType(enum AudioPortPin pin)99 static const char *AudioPathSelGetDeviceType(enum AudioPortPin pin)
100 {
101 if (pin < PIN_OUT_SPEAKER || pin > PIN_IN_BLUETOOTH_SCO_HEADSET) {
102 return NULL;
103 }
104 switch (pin) {
105 case PIN_OUT_SPEAKER:
106 return SPEAKER;
107 case PIN_OUT_HEADSET:
108 return HEADPHONES;
109 case PIN_IN_MIC:
110 return MIC;
111 case PIN_IN_HS_MIC:
112 return HS_MIC;
113 case PIN_OUT_EARPIECE:
114 return EARPIECE;
115 case PIN_OUT_BLUETOOTH_SCO:
116 return BLUETOOTH_SCO;
117 case PIN_IN_BLUETOOTH_SCO_HEADSET:
118 return BLUETOOTH_SCO_HEADSET;
119 default:
120 AUDIO_FUNC_LOGE("UseCase not support!");
121 break;
122 }
123 return NULL;
124 }
125
AudioPathSelGetUseCase(enum AudioCategory type)126 static const char *AudioPathSelGetUseCase(enum AudioCategory type)
127 {
128 static const char *usecaseType[AUDIO_MMAP_NOIRQ + 1] = {
129 [AUDIO_IN_MEDIA] = "deep-buffer-playback",
130 [AUDIO_IN_COMMUNICATION] = "low-latency-communication",
131 [AUDIO_IN_RINGTONE] = "ringtone-playback",
132 [AUDIO_IN_CALL] = "voice-call",
133 [AUDIO_MMAP_NOIRQ] = "low-latency-noirq-playback",
134 };
135
136 if (type < 0 || type > AUDIO_MMAP_NOIRQ) {
137 return NULL;
138 }
139 return usecaseType[type];
140 }
141
SetRenderPathDefaultValue(cJSON * renderSwObj,struct AudioHwRenderParam * renderParam)142 static int32_t SetRenderPathDefaultValue(cJSON *renderSwObj, struct AudioHwRenderParam *renderParam)
143 {
144 if (renderSwObj == NULL || renderParam == NULL) {
145 AUDIO_FUNC_LOGE("param Is NULL");
146 return HDF_ERR_INVALID_PARAM;
147 }
148 char *devKey = NULL;
149 int32_t renderDevNum;
150
151 renderDevNum = renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceNum;
152 int32_t renderPathNum = cJSON_GetArraySize(renderSwObj);
153 if (renderPathNum < 0 || renderPathNum > HDF_PATH_NUM_MAX) {
154 AUDIO_FUNC_LOGE("renderPathNum is invalid!");
155 return HDF_FAILURE;
156 }
157 for (int32_t i = 0; i < renderPathNum; i++) {
158 cJSON *tmpValue = cJSON_GetArrayItem(renderSwObj, i);
159 cJSON *renderSwName = tmpValue->child;
160 cJSON *renderSwVal = renderSwName->next;
161 if (renderSwName->valuestring == NULL) {
162 AUDIO_FUNC_LOGE("renderSwName->valuestring is null!");
163 return HDF_FAILURE;
164 }
165
166 devKey = renderSwName->valuestring;
167 (void)memset_s(renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[renderDevNum].deviceSwitch,
168 PATHPLAN_LEN, 0, PATHPLAN_LEN);
169 int32_t ret =
170 strncpy_s(renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[renderDevNum].deviceSwitch,
171 PATHPLAN_COUNT, devKey, strlen(devKey) + 1);
172 if (ret != 0) {
173 AUDIO_FUNC_LOGE("strcpy_s failed!");
174 return HDF_FAILURE;
175 }
176
177 renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[renderDevNum].value = renderSwVal->valueint;
178 renderDevNum++;
179 }
180 renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceNum = renderDevNum;
181 return HDF_SUCCESS;
182 }
183
SetCapturePathDefaultValue(cJSON * captureSwObj,struct AudioHwCaptureParam * captureParam)184 static int32_t SetCapturePathDefaultValue(cJSON *captureSwObj, struct AudioHwCaptureParam *captureParam)
185 {
186 if (captureSwObj == NULL || captureParam == NULL) {
187 AUDIO_FUNC_LOGE("param Is NULL");
188 return HDF_ERR_INVALID_PARAM;
189 }
190 char *devKey = NULL;
191
192 int32_t devNum = captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceNum;
193 int32_t pathNum = cJSON_GetArraySize(captureSwObj);
194 if (pathNum < 0 || pathNum > HDF_PATH_NUM_MAX) {
195 AUDIO_FUNC_LOGE("pathNum is invalid!");
196 return HDF_FAILURE;
197 }
198 for (int32_t i = 0; i < pathNum; i++) {
199 cJSON *tmpValue = cJSON_GetArrayItem(captureSwObj, i);
200 cJSON *captureSwName = tmpValue->child;
201 cJSON *captureSwVal = captureSwName->next;
202 if (captureSwName->valuestring == NULL) {
203 AUDIO_FUNC_LOGE("captureSwName->valuestring is null!");
204 return HDF_FAILURE;
205 }
206
207 devKey = captureSwName->valuestring;
208 (void)memset_s(captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[devNum].deviceSwitch,
209 PATHPLAN_LEN, 0, PATHPLAN_LEN);
210 int32_t ret =
211 strncpy_s(captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[devNum].deviceSwitch,
212 PATHPLAN_COUNT, devKey, strlen(devKey) + 1);
213 if (ret != 0) {
214 AUDIO_FUNC_LOGE("strcpy_s failed!");
215 return HDF_FAILURE;
216 }
217 captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[devNum].value = captureSwVal->valueint;
218
219 devNum++;
220 }
221 captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceNum = devNum;
222 return HDF_SUCCESS;
223 }
224
SetRenderPathValue(int32_t tpins,cJSON * renderObj,struct AudioHwRenderParam * renderParam,int32_t value)225 static int32_t SetRenderPathValue(
226 int32_t tpins, cJSON *renderObj, struct AudioHwRenderParam *renderParam, int32_t value)
227 {
228 if (renderObj == NULL || renderParam == NULL) {
229 AUDIO_FUNC_LOGE("param Is NULL");
230 return HDF_ERR_INVALID_PARAM;
231 }
232 char *devKey = NULL;
233 int32_t devNum;
234 const char *renderDeviceType = AudioPathSelGetDeviceType(tpins);
235 if (renderDeviceType == NULL) {
236 AUDIO_FUNC_LOGE("DeviceType not found.");
237 return HDF_FAILURE;
238 }
239 devNum = renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceNum;
240 /* pins = 0, parse default value */
241 if (strcasecmp(renderDeviceType, renderObj->string) == 0) {
242 int32_t pathNum = cJSON_GetArraySize(renderObj);
243 if (pathNum < 0 || pathNum > HDF_PATH_NUM_MAX) {
244 AUDIO_FUNC_LOGE("pathNum is invalid!");
245 return HDF_FAILURE;
246 }
247 for (int32_t i = 0; i < pathNum; i++) {
248 cJSON *tmpValue = cJSON_GetArrayItem(renderObj, i);
249 cJSON *swName = tmpValue->child;
250 cJSON *swVal = swName->next;
251 if (swName->valuestring == NULL) {
252 AUDIO_FUNC_LOGE("ValueString is null!");
253 return HDF_FAILURE;
254 }
255
256 devKey = swName->valuestring;
257 (void)memset_s(renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[devNum].deviceSwitch,
258 PATHPLAN_LEN, 0, PATHPLAN_LEN);
259 int32_t ret =
260 strncpy_s(renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[devNum].deviceSwitch,
261 PATHPLAN_COUNT, devKey, strlen(devKey) + 1);
262 if (ret != 0) {
263 AUDIO_FUNC_LOGE("strcpy_s failed!");
264 return HDF_FAILURE;
265 }
266 if (swVal->valueint > AUDIO_DEV_ON) {
267 /* alsa Adaptation */
268 renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[devNum].value = swVal->valueint;
269 } else {
270 renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[devNum].value = value;
271 }
272 devNum++;
273 }
274 renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceNum = devNum;
275 }
276 return HDF_SUCCESS;
277 }
278
SetMatchRenderDevicePath(int32_t tpins,struct AudioHwRenderParam * renderParam,cJSON * cJsonObj,const char * deviceType,int32_t value)279 static int32_t SetMatchRenderDevicePath(
280 int32_t tpins, struct AudioHwRenderParam *renderParam, cJSON *cJsonObj, const char *deviceType, int32_t value)
281 {
282 if (cJsonObj == NULL || renderParam == NULL) {
283 AUDIO_FUNC_LOGE("param Is NULL");
284 return HDF_ERR_INVALID_PARAM;
285 }
286 if (strcasecmp(cJsonObj->string, deviceType) == 0) {
287 int32_t ret = SetRenderPathValue(tpins, cJsonObj, renderParam, value);
288 if (ret != HDF_SUCCESS) {
289 AUDIO_FUNC_LOGE("set value failed!");
290 return ret;
291 }
292 }
293 return HDF_SUCCESS;
294 }
295
SetMatchRenderDefaultDevicePath(struct AudioHwRenderParam * renderParam,cJSON * cJsonObj)296 static int32_t SetMatchRenderDefaultDevicePath(struct AudioHwRenderParam *renderParam, cJSON *cJsonObj)
297 {
298 int32_t ret;
299 if (cJsonObj == NULL || renderParam == NULL) {
300 AUDIO_FUNC_LOGE("param Is NULL");
301 return HDF_ERR_INVALID_PARAM;
302 }
303 for (int32_t i = PIN_OUT_SPEAKER; i <= PIN_OUT_EARPIECE; i = i << 1) {
304 const char *deviceType = AudioPathSelGetDeviceType(i);
305 if (deviceType == NULL) {
306 AUDIO_FUNC_LOGE("DeviceType not found.");
307 return HDF_FAILURE;
308 }
309 if (strcasecmp(deviceType, cJsonObj->string) == 0) {
310 ret = SetRenderPathDefaultValue(cJsonObj, renderParam);
311 if (ret != HDF_SUCCESS) {
312 AUDIO_FUNC_LOGE("set default value failed!");
313 return ret;
314 }
315 break;
316 }
317 }
318 return HDF_SUCCESS;
319 }
320
SetMatchRenderOtherDevicePath(int32_t tpins,struct AudioHwRenderParam * renderParam,cJSON * cJsonObj,int32_t value)321 static int32_t SetMatchRenderOtherDevicePath(
322 int32_t tpins, struct AudioHwRenderParam *renderParam, cJSON *cJsonObj, int32_t value)
323 {
324 int32_t ret;
325 if (cJsonObj == NULL || renderParam == NULL) {
326 AUDIO_FUNC_LOGE("param Is NULL");
327 return HDF_ERR_INVALID_PARAM;
328 }
329 for (int32_t j = PIN_OUT_SPEAKER; j <= PIN_OUT_EARPIECE; j = j << 1) {
330 if ((j & tpins) == j) {
331 ret = SetRenderPathValue(j, cJsonObj, renderParam, AUDIO_DEV_ON);
332 if (ret != HDF_SUCCESS) {
333 AUDIO_FUNC_LOGW("set value failed!");
334 continue;
335 }
336 }
337 }
338 return HDF_SUCCESS;
339 }
340
AudioRenderParseDevice(struct AudioHwRenderParam * renderParam,cJSON * cJsonObj)341 static int32_t AudioRenderParseDevice(struct AudioHwRenderParam *renderParam, cJSON *cJsonObj)
342 {
343 int32_t ret;
344 if (cJsonObj == NULL || renderParam == NULL) {
345 AUDIO_FUNC_LOGE("param Is NULL");
346 return HDF_ERR_INVALID_PARAM;
347 }
348 int32_t pins = renderParam->renderMode.hwInfo.deviceDescript.pins;
349 if (pins < 0) {
350 AUDIO_FUNC_LOGE("deviceDescript pins error!");
351 return HDF_FAILURE;
352 }
353
354 int32_t tpins = pins & OUTPUT_MASK;
355 if ((pins >> OUTPUT_OFFSET) != 0) {
356 AUDIO_FUNC_LOGE("pins: %d, error!\n", pins);
357 return HDF_FAILURE;
358 }
359
360 if (strcasecmp(cJsonObj->string, MIC) == 0 || strcasecmp(cJsonObj->string, HS_MIC) == 0 ||
361 strcasecmp(cJsonObj->string, BLUETOOTH_SCO_HEADSET) == 0) {
362 return HDF_SUCCESS;
363 }
364
365 switch (tpins) {
366 case PIN_NONE:
367 /* pins = 0, parse default value */
368 ret = SetMatchRenderDefaultDevicePath(renderParam, cJsonObj);
369 break;
370 case PIN_OUT_SPEAKER:
371 /* 1.open speaker */
372 ret = SetMatchRenderDevicePath(tpins, renderParam, cJsonObj, SPEAKER, AUDIO_DEV_ON);
373 #ifndef ALSA_LIB_MODE
374 /* 2.close headphones */
375 ret |= SetMatchRenderDevicePath(PIN_OUT_HEADSET, renderParam, cJsonObj, HEADPHONES, AUDIO_DEV_OFF);
376 #endif
377 break;
378 case PIN_OUT_HEADSET:
379 /* 1、open headphone */
380 ret = SetMatchRenderDevicePath(tpins, renderParam, cJsonObj, HEADPHONES, AUDIO_DEV_ON);
381 #ifndef ALSA_LIB_MODE
382 /* 2、close speaker */
383 ret |= SetMatchRenderDevicePath(PIN_OUT_SPEAKER, renderParam, cJsonObj, SPEAKER, AUDIO_DEV_OFF);
384 #endif
385 break;
386 case PIN_OUT_EARPIECE:
387 /* 1、open earpiece */
388 ret = SetMatchRenderDevicePath(tpins, renderParam, cJsonObj, EARPIECE, AUDIO_DEV_ON);
389 break;
390 case PIN_OUT_BLUETOOTH_SCO:
391 /* 1、open bluetooth */
392 ret = SetMatchRenderDevicePath(tpins, renderParam, cJsonObj, BLUETOOTH_SCO, AUDIO_DEV_ON);
393 break;
394 default:
395 ret = SetMatchRenderOtherDevicePath(tpins, renderParam, cJsonObj, AUDIO_DEV_ON);
396 break;
397 }
398
399 return ret;
400 }
401
AudioRenderParseUsecase(struct AudioHwRenderParam * renderParam,const char * useCase)402 static int32_t AudioRenderParseUsecase(struct AudioHwRenderParam *renderParam, const char *useCase)
403 {
404 /* reset path numbers */
405 renderParam->renderMode.hwInfo.pathSelect.deviceInfo.deviceNum = 0;
406
407 cJSON *cardNode = cJSON_GetObjectItem(g_cJsonObj, renderParam->renderMode.hwInfo.cardServiceName);
408 if (cardNode == NULL) {
409 AUDIO_FUNC_LOGE(
410 "failed to check item when [%{public}s] gets object!", renderParam->renderMode.hwInfo.cardServiceName);
411 return HDF_FAILURE;
412 }
413 cJSON *cardList = cardNode->child;
414 if (cardList == NULL) {
415 AUDIO_FUNC_LOGE("no child when [%{public}s] gets object!", renderParam->renderMode.hwInfo.cardServiceName);
416 return HDF_FAILURE;
417 }
418
419 cJSON *useCaseNode = cJSON_GetObjectItem(cardList, useCase);
420 if (useCaseNode == NULL) {
421 AUDIO_FUNC_LOGE("failed to check item when [%{public}s] gets object!", useCase);
422 return HDF_FAILURE;
423 }
424
425 cJSON *useCaseList = useCaseNode->child;
426 if (useCaseList == NULL) {
427 AUDIO_FUNC_LOGE("no child when [%{public}s] gets object!", useCase);
428 return HDF_FAILURE;
429 }
430
431 int32_t len = cJSON_GetArraySize(useCaseList);
432 if (len < 0 || len > HDF_PATH_NUM_MAX) {
433 AUDIO_FUNC_LOGE("len is invalid!");
434 return HDF_FAILURE;
435 }
436 for (int32_t i = 0; i < len; i++) {
437 cJSON *tmpValue = cJSON_GetArrayItem(useCaseList, i);
438 /* Each device in the incoming scene */
439 int32_t ret = AudioRenderParseDevice(renderParam, tmpValue);
440 if (ret != HDF_SUCCESS) {
441 return ret;
442 }
443 }
444 return HDF_SUCCESS;
445 }
446
AudioPathSelGetPlanRender(struct AudioHwRenderParam * renderParam)447 static int32_t AudioPathSelGetPlanRender(struct AudioHwRenderParam *renderParam)
448 {
449 if (renderParam == NULL) {
450 AUDIO_FUNC_LOGE("param Is NULL");
451 return HDF_ERR_INVALID_PARAM;
452 }
453 const char *useCase = AudioPathSelGetUseCase(renderParam->frameRenderMode.attrs.type);
454 if (useCase == NULL) {
455 AUDIO_FUNC_LOGE("useCase not support!");
456 return HDF_FAILURE;
457 }
458 return AudioRenderParseUsecase(renderParam, useCase);
459 }
460
SetCapturePathValue(int32_t tpins,cJSON * captureSwitchObj,struct AudioHwCaptureParam * captureParam,int32_t value)461 static int32_t SetCapturePathValue(
462 int32_t tpins, cJSON *captureSwitchObj, struct AudioHwCaptureParam *captureParam, int32_t value)
463 {
464 if (captureParam == NULL || captureSwitchObj == NULL) {
465 AUDIO_FUNC_LOGE("param Is NULL");
466 return HDF_ERR_INVALID_PARAM;
467 }
468 const char *captureDeviceType = AudioPathSelGetDeviceType(tpins);
469 if (captureDeviceType == NULL) {
470 AUDIO_FUNC_LOGE("DeviceType not found.");
471 return HDF_FAILURE;
472 }
473
474 int32_t devNum = captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceNum;
475 if (strcasecmp(captureDeviceType, captureSwitchObj->string) == 0) {
476 int32_t pathNum = cJSON_GetArraySize(captureSwitchObj);
477 if (pathNum < 0 || pathNum > HDF_PATH_NUM_MAX) {
478 AUDIO_FUNC_LOGE("pathNum is invalid!");
479 return HDF_FAILURE;
480 }
481 for (int32_t i = 0; i < pathNum; i++) {
482 cJSON *captureTmpValue = cJSON_GetArrayItem(captureSwitchObj, i);
483 cJSON *swName = captureTmpValue->child;
484 cJSON *swVal = swName->next;
485 if (swName->valuestring == NULL) {
486 AUDIO_FUNC_LOGE("ValueString is null!");
487 return HDF_FAILURE;
488 }
489
490 (void)memset_s(captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[devNum].deviceSwitch,
491 PATHPLAN_LEN, 0, PATHPLAN_LEN);
492 int32_t ret =
493 strncpy_s(captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[devNum].deviceSwitch,
494 PATHPLAN_COUNT, swName->valuestring, strlen(swName->valuestring) + 1);
495 if (ret != 0) {
496 AUDIO_FUNC_LOGE("strcpy_s failed!");
497 return HDF_FAILURE;
498 }
499 if (swVal->valueint > AUDIO_DEV_ON) {
500 /* alsa Adaptation */
501 captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[devNum].value = swVal->valueint;
502 } else {
503 captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[devNum].value = value;
504 }
505
506 devNum++;
507 }
508 captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceNum = devNum;
509 }
510 return HDF_SUCCESS;
511 }
512
SetMatchCaptureDevicePath(struct AudioHwCaptureParam * captureParam,cJSON * cJsonObj,int32_t tpins,char * deviceType,int32_t value)513 static int32_t SetMatchCaptureDevicePath(
514 struct AudioHwCaptureParam *captureParam, cJSON *cJsonObj, int32_t tpins, char *deviceType, int32_t value)
515 {
516 if (captureParam == NULL || cJsonObj == NULL) {
517 AUDIO_FUNC_LOGE("param Is NULL");
518 return HDF_ERR_INVALID_PARAM;
519 }
520 if (strcasecmp(cJsonObj->string, deviceType) == 0) {
521 int32_t ret = SetCapturePathValue(tpins, cJsonObj, captureParam, value);
522 if (ret != HDF_SUCCESS) {
523 AUDIO_FUNC_LOGE("set value failed!");
524 return ret;
525 }
526 }
527 return HDF_SUCCESS;
528 }
529
SetMatchCaptureDefaultDevicePath(struct AudioHwCaptureParam * captureParam,cJSON * cJsonObj)530 static int32_t SetMatchCaptureDefaultDevicePath(struct AudioHwCaptureParam *captureParam, cJSON *cJsonObj)
531 {
532 int32_t ret;
533 if (captureParam == NULL || cJsonObj == NULL) {
534 AUDIO_FUNC_LOGE("param Is NULL");
535 return HDF_ERR_INVALID_PARAM;
536 }
537 for (int32_t i = PIN_IN_MIC; i <= PIN_IN_BLUETOOTH_SCO_HEADSET;
538 i = (1 << INPUT_OFFSET) | ((i & OUTPUT_MASK) << 1)) {
539 const char *deviceType = AudioPathSelGetDeviceType(i);
540 if (deviceType == NULL) {
541 AUDIO_FUNC_LOGE("DeviceType not found.");
542 return HDF_FAILURE;
543 }
544
545 if (strcasecmp(deviceType, cJsonObj->string) == 0) {
546 ret = SetCapturePathDefaultValue(cJsonObj, captureParam);
547 if (ret != HDF_SUCCESS) {
548 AUDIO_FUNC_LOGE("set default value failed!");
549 return ret;
550 }
551 break;
552 }
553 }
554 return HDF_SUCCESS;
555 }
556
SetMatchCaptureOtherDevicePath(struct AudioHwCaptureParam * captureParam,cJSON * cJsonObj,int32_t tpins,int32_t value)557 static int32_t SetMatchCaptureOtherDevicePath(
558 struct AudioHwCaptureParam *captureParam, cJSON *cJsonObj, int32_t tpins, int32_t value)
559 {
560 int32_t ret;
561 int32_t i;
562 if (captureParam == NULL || cJsonObj == NULL) {
563 AUDIO_FUNC_LOGE("param Is NULL");
564 return HDF_ERR_INVALID_PARAM;
565 }
566 for (i = PIN_IN_MIC; i <= PIN_IN_BLUETOOTH_SCO_HEADSET; i = (1 << INPUT_OFFSET) | ((i & OUTPUT_MASK) << 1)) {
567 if ((i & tpins) == i) { /* Select which device to open and get the pin of which device */
568 ret = SetCapturePathValue(i, cJsonObj, captureParam, value);
569 if (ret != HDF_SUCCESS) {
570 AUDIO_FUNC_LOGE("set value failed!");
571 continue;
572 }
573 }
574 }
575 return HDF_SUCCESS;
576 }
577
AudioCaptureParseDevice(struct AudioHwCaptureParam * captureParam,cJSON * cJsonObj)578 static int32_t AudioCaptureParseDevice(struct AudioHwCaptureParam *captureParam, cJSON *cJsonObj)
579 {
580 int32_t ret;
581 if (captureParam == NULL || cJsonObj == NULL) {
582 AUDIO_FUNC_LOGE("param Is NULL");
583 return HDF_ERR_INVALID_PARAM;
584 }
585 int32_t pins = captureParam->captureMode.hwInfo.deviceDescript.pins;
586 if (pins < 0) {
587 AUDIO_FUNC_LOGE("deviceDescript pins error!");
588 return HDF_FAILURE;
589 }
590
591 if (!((pins >> INPUT_OFFSET) & 0x01)) {
592 AUDIO_FUNC_LOGE("pins: %{public}d, error!", pins);
593 return HDF_FAILURE;
594 }
595
596 if (strcasecmp(cJsonObj->string, SPEAKER) == 0 || strcasecmp(cJsonObj->string, HEADPHONES) == 0 ||
597 strcasecmp(cJsonObj->string, EARPIECE) == 0 || strcasecmp(cJsonObj->string, BLUETOOTH_SCO) == 0) {
598 return HDF_SUCCESS;
599 }
600
601 int32_t tpins = pins & INPUT_MASK;
602 switch (tpins) {
603 case (1 << INPUT_OFFSET):
604 /* pins = 0, parse default value */
605 ret = SetMatchCaptureDefaultDevicePath(captureParam, cJsonObj);
606 break;
607 case PIN_IN_MIC:
608 /* 1.open main mic */
609 ret = SetMatchCaptureDevicePath(captureParam, cJsonObj, tpins, MIC, AUDIO_DEV_ON);
610 #ifndef ALSA_LIB_MODE
611 /* 2.close headset mic */
612 ret |= SetMatchCaptureDevicePath(captureParam, cJsonObj, PIN_IN_HS_MIC, HS_MIC, AUDIO_DEV_OFF);
613 #endif
614 break;
615 case PIN_IN_HS_MIC:
616 /* 1、open headset mic */
617 ret = SetMatchCaptureDevicePath(captureParam, cJsonObj, tpins, HS_MIC, AUDIO_DEV_ON);
618 #ifndef ALSA_LIB_MODE
619 /* 2、close main mic */
620 ret |= SetMatchCaptureDevicePath(captureParam, cJsonObj, PIN_IN_MIC, MIC, AUDIO_DEV_OFF);
621 #endif
622 break;
623 case PIN_IN_BLUETOOTH_SCO_HEADSET:
624 /* 1、open bluetooth sco headset mic */
625 ret = SetMatchCaptureDevicePath(captureParam, cJsonObj, tpins, BLUETOOTH_SCO_HEADSET, AUDIO_DEV_ON);
626 break;
627 default:
628 ret = SetMatchCaptureOtherDevicePath(captureParam, cJsonObj, tpins, AUDIO_DEV_ON);
629 break;
630 }
631 return ret;
632 }
633
AudioCaptureParseUsecase(struct AudioHwCaptureParam * captureParam,const char * useCase)634 static int32_t AudioCaptureParseUsecase(struct AudioHwCaptureParam *captureParam, const char *useCase)
635 {
636 if (captureParam == NULL || useCase == NULL) {
637 AUDIO_FUNC_LOGE("param Is NULL");
638 return HDF_ERR_INVALID_PARAM;
639 }
640 /* reset path numbers */
641 captureParam->captureMode.hwInfo.pathSelect.deviceInfo.deviceNum = 0;
642
643 cJSON *cardNode = cJSON_GetObjectItem(g_cJsonObj, captureParam->captureMode.hwInfo.cardServiceName);
644 if (cardNode == NULL) {
645 AUDIO_FUNC_LOGE(
646 "failed to check item when [%{public}s] gets object!", captureParam->captureMode.hwInfo.cardServiceName);
647 return HDF_FAILURE;
648 }
649 cJSON *cardList = cardNode->child;
650 if (cardList == NULL) {
651 AUDIO_FUNC_LOGE("no child when [%{public}s] gets object!", captureParam->captureMode.hwInfo.cardServiceName);
652 return HDF_FAILURE;
653 }
654
655 cJSON *useCaseNode = cJSON_GetObjectItem(cardList, useCase);
656 if (useCaseNode == NULL) {
657 AUDIO_FUNC_LOGE("failed to check item when [%{public}s] gets object!", useCase);
658 return HDF_FAILURE;
659 }
660 cJSON *useCaseList = useCaseNode->child;
661 if (useCaseList == NULL) {
662 AUDIO_FUNC_LOGE("no child when [%{public}s] gets object!", useCase);
663 return HDF_FAILURE;
664 }
665
666 int32_t len = cJSON_GetArraySize(useCaseList);
667 if (len < 0 || len > HDF_PATH_NUM_MAX) {
668 AUDIO_FUNC_LOGE("len is invalid!");
669 return HDF_FAILURE;
670 }
671 for (int32_t i = 0; i < len; i++) {
672 cJSON *tmpValue = cJSON_GetArrayItem(useCaseList, i);
673 int32_t ret = AudioCaptureParseDevice(captureParam, tmpValue);
674 if (ret != HDF_SUCCESS) {
675 return ret;
676 }
677 }
678 return HDF_SUCCESS;
679 }
680
AudioPathSelGetPlanCapture(struct AudioHwCaptureParam * captureParam)681 static int32_t AudioPathSelGetPlanCapture(struct AudioHwCaptureParam *captureParam)
682 {
683 enum AudioCategory type = captureParam->frameCaptureMode.attrs.type;
684
685 if (type == AUDIO_IN_RINGTONE) {
686 AUDIO_FUNC_LOGE("useCase not support!");
687 return HDF_ERR_NOT_SUPPORT;
688 }
689
690 if (type == AUDIO_MMAP_NOIRQ) {
691 AUDIO_FUNC_LOGE("useCase set as AUDIO_IN_MEDIA");
692 type = AUDIO_IN_MEDIA;
693 }
694
695 const char *useCase = AudioPathSelGetUseCase(type);
696 if (useCase == NULL) {
697 AUDIO_FUNC_LOGE("useCase not support!");
698 return HDF_FAILURE;
699 }
700
701 return AudioCaptureParseUsecase(captureParam, useCase);
702 }
703
AudioPathSelRenderChkScene(struct AudioHwRenderParam * renderSceneParam)704 static int32_t AudioPathSelRenderChkScene(struct AudioHwRenderParam *renderSceneParam)
705 {
706 return AudioPathSelGetPlanRender(renderSceneParam);
707 }
708
AudioPathSelCaptureChkScene(struct AudioHwCaptureParam * captureSceneParam)709 static int32_t AudioPathSelCaptureChkScene(struct AudioHwCaptureParam *captureSceneParam)
710 {
711 return AudioPathSelGetPlanCapture(captureSceneParam);
712 }
713
AudioPathSelAnalysisJson(const AudioHandle adapterParam,enum AudioAdaptType adaptType)714 int32_t AudioPathSelAnalysisJson(const AudioHandle adapterParam, enum AudioAdaptType adaptType)
715 {
716 AUDIO_FUNC_LOGI();
717 if (adaptType < 0 || adapterParam == NULL) {
718 AUDIO_FUNC_LOGE("Param Invaild!");
719 return HDF_ERR_INVALID_PARAM;
720 }
721 struct AudioHwRenderParam *renderParam = NULL;
722 struct AudioHwCaptureParam *captureParam = NULL;
723 struct AudioHwRenderParam *renderSceneCheck = NULL;
724 struct AudioHwCaptureParam *captureScenceCheck = NULL;
725 switch (adaptType) {
726 case RENDER_PATH_SELECT:
727 renderParam = (struct AudioHwRenderParam *)adapterParam;
728 if (strcasecmp(renderParam->renderMode.hwInfo.adapterName, USB) == 0 ||
729 strcasecmp(renderParam->renderMode.hwInfo.adapterName, HDMI) == 0) {
730 return HDF_SUCCESS;
731 }
732 return (AudioPathSelGetPlanRender(renderParam));
733 case CAPTURE_PATH_SELECT:
734 captureParam = (struct AudioHwCaptureParam *)adapterParam;
735 if (strcasecmp(captureParam->captureMode.hwInfo.adapterName, USB) == 0 ||
736 strcasecmp(captureParam->captureMode.hwInfo.adapterName, HDMI) == 0) {
737 return HDF_SUCCESS;
738 }
739 return (AudioPathSelGetPlanCapture(captureParam));
740 /* Scene is supported */
741 case CHECKSCENE_PATH_SELECT:
742 renderSceneCheck = (struct AudioHwRenderParam *)adapterParam;
743 if (strcasecmp(renderSceneCheck->renderMode.hwInfo.adapterName, USB) == 0 ||
744 strcasecmp(renderSceneCheck->renderMode.hwInfo.adapterName, HDMI) == 0) {
745 return HDF_SUCCESS;
746 }
747 return (AudioPathSelRenderChkScene(renderSceneCheck));
748 case CHECKSCENE_PATH_SELECT_CAPTURE:
749 captureScenceCheck = (struct AudioHwCaptureParam *)adapterParam;
750 if (strcasecmp(captureScenceCheck->captureMode.hwInfo.adapterName, USB) == 0 ||
751 strcasecmp(captureScenceCheck->captureMode.hwInfo.adapterName, HDMI) == 0) {
752 return HDF_SUCCESS;
753 }
754 return (AudioPathSelCaptureChkScene(captureScenceCheck));
755 default:
756 AUDIO_FUNC_LOGE("Path select mode invalid");
757 break;
758 }
759 return HDF_FAILURE;
760 }
761