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 "audio_common.h"
18 #include "audio_interface_lib_capture.h"
19 #include "audio_interface_lib_render.h"
20 #include "audio_internal.h"
21 #include "audio_uhdf_log.h"
22 #include "hdf_types.h"
23 #include "osal_mem.h"
24 #include "securec.h"
25 #include "stub_collector.h"
26 
27 #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL
28 
29 #define CONFIG_CHANNEL_COUNT            2 // two channels
30 #define GAIN_MAX                        50.0
31 #define DEFAULT_RENDER_SAMPLING_RATE    48000
32 #define DEEP_BUFFER_RENDER_PERIOD_SIZE  4096
33 #define DEEP_BUFFER_RENDER_PERIOD_COUNT 8
34 #define TYPE_RENDER                     "Render"
35 #define TYPE_CAPTURE                    "Capture"
36 #define INT_32_MAX                      0x7fffffff
37 #define SHIFT_RIGHT_31_BITS             31
38 
AudioHwRenderInit(struct AudioHwRender * hwRender)39 static int32_t AudioHwRenderInit(struct AudioHwRender *hwRender)
40 {
41     if (hwRender == NULL) {
42         AUDIO_FUNC_LOGE("Parameter error!");
43         return HDF_ERR_INVALID_PARAM;
44     }
45     hwRender->common.Start = AudioRenderStart;
46     hwRender->common.Stop = AudioRenderStop;
47     hwRender->common.Pause = AudioRenderPause;
48     hwRender->common.Resume = AudioRenderResume;
49     hwRender->common.Flush = AudioRenderFlush;
50     hwRender->common.TurnStandbyMode = AudioRenderTurnStandbyMode;
51     hwRender->common.AudioDevDump = AudioRenderAudioDevDump;
52     hwRender->common.GetFrameSize = AudioRenderGetFrameSize;
53     hwRender->common.GetFrameCount = AudioRenderGetFrameCount;
54     hwRender->common.SetSampleAttributes = AudioRenderSetSampleAttributes;
55     hwRender->common.GetSampleAttributes = AudioRenderGetSampleAttributes;
56     hwRender->common.GetCurrentChannelId = AudioRenderGetCurrentChannelId;
57     hwRender->common.SetExtraParams = AudioRenderSetExtraParams;
58     hwRender->common.GetExtraParams = AudioRenderGetExtraParams;
59     hwRender->common.ReqMmapBuffer = AudioRenderReqMmapBuffer;
60     hwRender->common.GetMmapPosition = AudioRenderGetMmapPosition;
61     hwRender->common.CheckSceneCapability = AudioRenderCheckSceneCapability;
62     hwRender->common.SelectScene = AudioRenderSelectScene;
63     hwRender->common.SetMute = AudioRenderSetMute;
64     hwRender->common.GetMute = AudioRenderGetMute;
65     hwRender->common.SetVolume = AudioRenderSetVolume;
66     hwRender->common.GetVolume = AudioRenderGetVolume;
67     hwRender->common.GetGainThreshold = AudioRenderGetGainThreshold;
68     hwRender->common.GetGain = AudioRenderGetGain;
69     hwRender->common.SetGain = AudioRenderSetGain;
70     hwRender->common.GetLatency = AudioRenderGetLatency;
71     hwRender->common.RenderFrame = AudioRenderRenderFrame;
72     hwRender->common.GetRenderPosition = AudioRenderGetRenderPosition;
73     hwRender->common.SetRenderSpeed = AudioRenderSetRenderSpeed;
74     hwRender->common.GetRenderSpeed = AudioRenderGetRenderSpeed;
75     hwRender->common.SetChannelMode = AudioRenderSetChannelMode;
76     hwRender->common.GetChannelMode = AudioRenderGetChannelMode;
77     hwRender->common.RegCallback = AudioRenderRegCallback;
78     hwRender->common.DrainBuffer = AudioRenderDrainBuffer;
79     hwRender->renderParam.frameRenderMode.callbackProcess = CallbackProcessing;
80     return HDF_SUCCESS;
81 }
82 
CheckParaDesc(const struct AudioDeviceDescriptor * desc,const char * type)83 int32_t CheckParaDesc(const struct AudioDeviceDescriptor *desc, const char *type)
84 {
85     if (desc == NULL || type == NULL) {
86         AUDIO_FUNC_LOGE("Parameter error!");
87         return HDF_ERR_INVALID_PARAM;
88     }
89 
90     if ((desc->portId) >> SHIFT_RIGHT_31_BITS) {
91         AUDIO_FUNC_LOGE("portId error!");
92         return HDF_ERR_NOT_SUPPORT;
93     }
94 
95     enum AudioPortPin pins = desc->pins;
96     if (!strcmp(type, TYPE_CAPTURE)) {
97         if (pins == PIN_IN_MIC || pins == PIN_IN_HS_MIC || pins == PIN_IN_LINEIN) {
98             return HDF_SUCCESS;
99         }
100     } else if (!strcmp(type, TYPE_RENDER)) {
101         if (pins == PIN_OUT_SPEAKER || pins == PIN_OUT_HEADSET || pins == PIN_OUT_LINEOUT || pins == PIN_OUT_HDMI
102             || pins == (PIN_OUT_SPEAKER | PIN_OUT_HEADSET)) {
103             return HDF_SUCCESS;
104         }
105     }
106     AUDIO_FUNC_LOGE("Unknow pin!");
107 
108     return HDF_ERR_NOT_SUPPORT;
109 }
110 
CheckParaAttr(const struct AudioSampleAttributes * attrs)111 int32_t CheckParaAttr(const struct AudioSampleAttributes *attrs)
112 {
113     if (attrs == NULL) {
114         AUDIO_FUNC_LOGE("Parameter error!");
115         return HDF_ERR_INVALID_PARAM;
116     }
117 
118     int32_t ret = ((attrs->sampleRate) >> SHIFT_RIGHT_31_BITS) + ((attrs->channelCount) >> SHIFT_RIGHT_31_BITS) +
119         ((attrs->period) >> SHIFT_RIGHT_31_BITS) + ((attrs->frameSize) >> SHIFT_RIGHT_31_BITS) +
120         ((attrs->startThreshold) >> SHIFT_RIGHT_31_BITS) + ((attrs->stopThreshold) >> SHIFT_RIGHT_31_BITS) +
121         ((attrs->silenceThreshold) >> SHIFT_RIGHT_31_BITS);
122     if (ret > 0) {
123         AUDIO_FUNC_LOGE("Sample attributes error!");
124         return HDF_ERR_NOT_SUPPORT;
125     }
126 
127     enum AudioCategory audioCategory = attrs->type;
128     if (audioCategory < AUDIO_IN_MEDIA || audioCategory > AUDIO_MMAP_NOIRQ) {
129         AUDIO_FUNC_LOGE("Audio category error!");
130         return HDF_ERR_NOT_SUPPORT;
131     }
132 
133     enum AudioFormat audioFormat = attrs->format;
134     return CheckAttrFormat(audioFormat);
135 }
136 
AttrFormatToBit(const struct AudioSampleAttributes * attrs,int32_t * format)137 int32_t AttrFormatToBit(const struct AudioSampleAttributes *attrs, int32_t *format)
138 {
139     if (attrs == NULL || format == NULL) {
140         AUDIO_FUNC_LOGE("Parameter error!");
141         return HDF_ERR_INVALID_PARAM;
142     }
143 
144     enum AudioFormat audioFormat = attrs->format;
145     switch (audioFormat) {
146         case AUDIO_FORMAT_TYPE_PCM_8_BIT:
147             *format = BIT_NUM_8;
148             break;
149         case AUDIO_FORMAT_TYPE_PCM_16_BIT:
150             *format = BIT_NUM_16;
151             break;
152         case AUDIO_FORMAT_TYPE_PCM_24_BIT:
153             *format = BIT_NUM_24;
154             break;
155         case AUDIO_FORMAT_TYPE_PCM_32_BIT:
156             *format = BIT_NUM_32;
157             break;
158         default:
159             AUDIO_FUNC_LOGE("Audio format error!");
160             return HDF_ERR_NOT_SUPPORT;
161     }
162 
163     return HDF_SUCCESS;
164 }
165 
AudioFormatServiceName(char * cardServiceName,char * adapterName,uint32_t id)166 static int32_t AudioFormatServiceName(char *cardServiceName, char *adapterName, uint32_t id)
167 {
168     if (cardServiceName == NULL || adapterName == NULL) {
169         AUDIO_FUNC_LOGE("Parameter error!");
170         return HDF_ERR_INVALID_PARAM;
171     }
172 
173     if (snprintf_s(cardServiceName, NAME_LEN, NAME_LEN - 1, "%s%u", adapterName, id) < 0) {
174         AUDIO_FUNC_LOGE("snprintf_s failed!");
175         return HDF_FAILURE;
176     }
177     return HDF_SUCCESS;
178 }
179 
AudioCheckDescPortId(const struct AudioAdapterDescriptor * adapterDescriptor,uint32_t portId,uint32_t * id)180 static int32_t AudioCheckDescPortId(
181     const struct AudioAdapterDescriptor *adapterDescriptor, uint32_t portId, uint32_t *id)
182 {
183     if (adapterDescriptor == NULL || adapterDescriptor->ports == NULL || id == NULL) {
184         AUDIO_FUNC_LOGE("Parameter error!");
185         return HDF_ERR_INVALID_PARAM;
186     }
187 
188     int adapterNum = AudioAdapterGetAdapterNum();
189     if (adapterNum <= 0) {
190         AUDIO_FUNC_LOGE("Get adapterNum fail!");
191         return HDF_FAILURE;
192     }
193     struct AudioAdapterDescriptor *descs = AudioAdapterGetConfigDescs();
194     if (descs == NULL) {
195         AUDIO_FUNC_LOGE("Get adapterDescs is NULL!");
196         return HDF_FAILURE;
197     }
198     bool checkFlag = false;
199     for (int index = 0; index < adapterNum; index++) {
200         if (strcmp(descs[index].adapterName, adapterDescriptor->adapterName) == 0) {
201             if (descs[index].ports[0].portId == portId) {
202                 checkFlag = true;
203                 break;
204             } else {
205                 AUDIO_FUNC_LOGE("The Audio Port ID is invalid, please check!");
206                 return HDF_FAILURE;
207             }
208         }
209     }
210     if (!checkFlag) {
211         AUDIO_FUNC_LOGE("The Audio AdapterName is illegal, please check!");
212         return HDF_FAILURE;
213     }
214     for (int index = 0; index < adapterNum; index++) {
215         if (strncmp(descs[index].adapterName, PRIMARY, strlen(PRIMARY)) == 0) {
216             if (descs[index].ports[0].portId <= AUDIO_PRIMARY_ID_MAX &&
217                 descs[index].ports[0].portId >= AUDIO_PRIMARY_ID_MIN) {
218                 *id = descs[index].ports[0].portId;
219                 break;
220             }
221         }
222     }
223 
224     return HDF_SUCCESS;
225 }
226 
AudioMakeCardServiceName(char * cardServiceName,const struct AudioAdapterDescriptor * adapterDescriptor,uint32_t portId)227 static int32_t AudioMakeCardServiceName(
228     char *cardServiceName, const struct AudioAdapterDescriptor *adapterDescriptor, uint32_t portId)
229 {
230     uint32_t priPortId = 0;
231 
232     if (cardServiceName == NULL || adapterDescriptor == NULL || adapterDescriptor->ports == NULL) {
233         AUDIO_FUNC_LOGE("Parameter error!");
234         return HDF_ERR_INVALID_PARAM;
235     }
236 
237     int32_t ret = AudioCheckDescPortId(adapterDescriptor, portId, &priPortId);
238     if (ret != HDF_SUCCESS) {
239         AUDIO_FUNC_LOGE("The Audio Port ID is illegal, please check!");
240         return HDF_FAILURE;
241     }
242     if (strncmp(adapterDescriptor->adapterName, PRIMARY, strlen(PRIMARY)) == 0) {
243         ret = AudioFormatServiceName(cardServiceName, HDF_AUDIO_CODEC_PRIMARY_DEV, portId);
244     } else if (strncmp(adapterDescriptor->adapterName, HDMI, strlen(HDMI)) == 0) {
245         ret = AudioFormatServiceName(cardServiceName, HDF_AUDIO_CODEC_HDMI_DEV, priPortId);
246     } else if (strncmp(adapterDescriptor->adapterName, USB, strlen(USB)) == 0) {
247         ret = AudioFormatServiceName(cardServiceName, HDF_AUDIO_CODEC_USB_DEV, priPortId);
248     } else if (strncmp(adapterDescriptor->adapterName, A2DP, strlen(A2DP)) == 0) {
249         ret = AudioFormatServiceName(cardServiceName, HDF_AUDIO_CODEC_A2DP_DEV, portId);
250     } else {
251         AUDIO_FUNC_LOGE("The selected sound card is not in the range of sound card list, please check!");
252         return HDF_FAILURE;
253     }
254 
255     return ret;
256 }
257 
InitHwRenderParam(struct AudioHwRender * hwRender,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs)258 int32_t InitHwRenderParam(
259     struct AudioHwRender *hwRender, const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs)
260 {
261     if (hwRender == NULL || desc == NULL || attrs == NULL) {
262         AUDIO_FUNC_LOGE("Parameter error!");
263         return HDF_ERR_INVALID_PARAM;
264     }
265 
266     int32_t ret = CheckParaDesc(desc, TYPE_RENDER);
267     if (ret != HDF_SUCCESS) {
268         AUDIO_FUNC_LOGE("CheckParaDesc Fail");
269         return ret;
270     }
271     ret = CheckParaAttr(attrs);
272     if (ret != HDF_SUCCESS) {
273         AUDIO_FUNC_LOGE("CheckParaAttr Fail");
274         return ret;
275     }
276     int32_t formatValue = -1;
277     ret = AttrFormatToBit(attrs, &formatValue);
278     if (ret != HDF_SUCCESS) {
279         AUDIO_FUNC_LOGE("AttrFormatToBit Fail");
280         return ret;
281     }
282     if (attrs->channelCount == 0) {
283         AUDIO_FUNC_LOGE("channelCount is zero!");
284         return HDF_FAILURE;
285     }
286     hwRender->renderParam.renderMode.hwInfo.deviceDescript = *desc;
287     hwRender->renderParam.renderMode.hwInfo.callBackEnable = false;
288     hwRender->renderParam.frameRenderMode.attrs = *attrs;
289     hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax = GAIN_MAX; // init gainMax
290     hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin = 0;
291     hwRender->renderParam.frameRenderMode.frames = 0;
292     hwRender->renderParam.frameRenderMode.time.tvNSec = 0;
293     hwRender->renderParam.frameRenderMode.time.tvSec = 0;
294     hwRender->renderParam.frameRenderMode.byteRate = DEFAULT_RENDER_SAMPLING_RATE;
295     hwRender->renderParam.frameRenderMode.periodSize = DEEP_BUFFER_RENDER_PERIOD_SIZE;
296     hwRender->renderParam.frameRenderMode.periodCount = DEEP_BUFFER_RENDER_PERIOD_COUNT;
297     hwRender->renderParam.frameRenderMode.renderhandle = (AudioHandle)hwRender;
298     pthread_mutex_init(&hwRender->renderParam.frameRenderMode.mutex, NULL);
299     hwRender->renderParam.renderMode.ctlParam.turnStandbyStatus = AUDIO_TURN_STANDBY_LATER;
300     return HDF_SUCCESS;
301 }
302 
InitForGetPortCapability(struct AudioPort portIndex,struct AudioPortCapability * capabilityIndex)303 int32_t InitForGetPortCapability(struct AudioPort portIndex, struct AudioPortCapability *capabilityIndex)
304 {
305     if (capabilityIndex == NULL) {
306         AUDIO_FUNC_LOGE("Parameter error!");
307         return HDF_ERR_INVALID_PARAM;
308     }
309 
310     /* get capabilityIndex from driver or default */
311     if (portIndex.dir != PORT_OUT) {
312         capabilityIndex->hardwareMode = true;
313         capabilityIndex->channelMasks = AUDIO_CHANNEL_STEREO;
314         capabilityIndex->channelCount = CONFIG_CHANNEL_COUNT;
315         return HDF_SUCCESS;
316     }
317 
318     if (InitPortForCapabilitySub(portIndex, capabilityIndex) != HDF_SUCCESS) {
319         AUDIO_FUNC_LOGE("PortInitForCapability fail");
320         return HDF_FAILURE;
321     }
322     return HDF_SUCCESS;
323 }
324 
AudioAdapterReleaseCapSubPorts(const struct AudioPortAndCapability * portCapabilitys,int32_t num)325 void AudioAdapterReleaseCapSubPorts(const struct AudioPortAndCapability *portCapabilitys, int32_t num)
326 {
327     int32_t i = 0;
328 
329     if (portCapabilitys == NULL) {
330         AUDIO_FUNC_LOGE("Parameter error!");
331         return;
332     }
333 
334     while (i < num) {
335         if (&portCapabilitys[i] == NULL) {
336             break;
337         }
338         AudioMemFree((void **)(&portCapabilitys[i].capability.subPorts));
339         i++;
340     }
341 }
342 
AudioAdapterInitAllPorts(struct IAudioAdapter * adapter)343 int32_t AudioAdapterInitAllPorts(struct IAudioAdapter *adapter)
344 {
345     AUDIO_FUNC_LOGD("Enter.");
346     struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
347     if (hwAdapter == NULL) {
348         AUDIO_FUNC_LOGE("hwAdapter Is NULL");
349         return AUDIO_ERR_INVALID_PARAM;
350     }
351     if (hwAdapter->portCapabilitys != NULL) {
352         AUDIO_FUNC_LOGI("portCapabilitys already Init!");
353         return AUDIO_SUCCESS;
354     }
355     uint32_t portsLen = hwAdapter->adapterDescriptor.portsLen;
356     struct AudioPort *ports = hwAdapter->adapterDescriptor.ports;
357     if (ports == NULL) {
358         AUDIO_FUNC_LOGE("ports is NULL!");
359         return AUDIO_ERR_INTERNAL;
360     }
361     if (portsLen == 0) {
362         AUDIO_FUNC_LOGE("portsLen is 0!");
363         return AUDIO_ERR_INTERNAL;
364     }
365     struct AudioPortAndCapability *portCapability =
366         (struct AudioPortAndCapability *)OsalMemCalloc(portsLen * sizeof(struct AudioPortAndCapability));
367     if (portCapability == NULL) {
368         AUDIO_FUNC_LOGE("portCapability is NULL!");
369         return AUDIO_ERR_INTERNAL;
370     }
371     for (uint32_t i = 0; i < portsLen; i++) {
372         portCapability[i].port = ports[i];
373         if (InitForGetPortCapability(ports[i], &portCapability[i].capability)) {
374             AUDIO_FUNC_LOGE("ports Init Fail!");
375             AudioAdapterReleaseCapSubPorts(portCapability, portsLen);
376             AudioMemFree((void **)&portCapability);
377             return AUDIO_ERR_INTERNAL;
378         }
379     }
380     hwAdapter->portCapabilitys = portCapability;
381     hwAdapter->portCapabilitys->mode = PORT_PASSTHROUGH_LPCM;
382     return AUDIO_SUCCESS;
383 }
384 
AudioReleaseRenderHandle(struct AudioHwRender * hwRender)385 void AudioReleaseRenderHandle(struct AudioHwRender *hwRender)
386 {
387     if (hwRender == NULL) {
388         AUDIO_FUNC_LOGE("Parameter error!");
389         return;
390     }
391     CloseServiceRenderPassthrough *pCloseRenderService = AudioPassthroughGetCloseServiceRender();
392     if (pCloseRenderService == NULL || (*pCloseRenderService) == NULL) {
393         AUDIO_FUNC_LOGE("pCloseRenderService func not exist");
394         return;
395     }
396     if (hwRender->devDataHandle != NULL) {
397         (*pCloseRenderService)(hwRender->devDataHandle);
398         hwRender->devDataHandle = NULL;
399     }
400     if (hwRender->devCtlHandle != NULL) {
401         (*pCloseRenderService)(hwRender->devCtlHandle);
402         hwRender->devCtlHandle = NULL;
403     }
404 }
405 
AudioAdapterCreateRenderPre(struct AudioHwRender * hwRender,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,const struct AudioHwAdapter * hwAdapter)406 int32_t AudioAdapterCreateRenderPre(struct AudioHwRender *hwRender, const struct AudioDeviceDescriptor *desc,
407     const struct AudioSampleAttributes *attrs, const struct AudioHwAdapter *hwAdapter)
408 {
409     if (hwAdapter == NULL || hwRender == NULL || desc == NULL || attrs == NULL) {
410         AUDIO_FUNC_LOGE("Parameter error!");
411         return HDF_FAILURE;
412     }
413 #ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT
414     PathSelAnalysisJson *pPathSelAnalysisJson = AudioPassthroughGetPathSelAnalysisJson();
415     if (pPathSelAnalysisJson == NULL || *pPathSelAnalysisJson == NULL) {
416         AUDIO_FUNC_LOGE("PathSelAnalysisJson not exist");
417         return HDF_FAILURE;
418     }
419 #endif
420     if (AudioHwRenderInit(hwRender) < 0) {
421         AUDIO_FUNC_LOGE("AudioHwRenderInit error!");
422         return HDF_FAILURE;
423     }
424     /* Fill hwRender para */
425     if (InitHwRenderParam(hwRender, desc, attrs) < 0) {
426         AUDIO_FUNC_LOGE("InitHwRenderParam error!");
427         return HDF_FAILURE;
428     }
429 
430     if (hwAdapter->adapterDescriptor.adapterName == NULL) {
431         AUDIO_FUNC_LOGE("pointer is null!");
432         return HDF_FAILURE;
433     }
434     uint32_t adapterNameLen = strlen(hwAdapter->adapterDescriptor.adapterName);
435     if (adapterNameLen == 0) {
436         AUDIO_FUNC_LOGE("adapterNameLen is null!");
437         return HDF_FAILURE;
438     }
439     /* Get Adapter name */
440     int32_t ret = strncpy_s(hwRender->renderParam.renderMode.hwInfo.adapterName, NAME_LEN - 1,
441         hwAdapter->adapterDescriptor.adapterName, adapterNameLen);
442     if (ret != EOK) {
443         AUDIO_FUNC_LOGE("copy fail");
444         return HDF_FAILURE;
445     }
446     uint32_t portId = hwRender->renderParam.renderMode.hwInfo.deviceDescript.portId;
447     ret = AudioMakeCardServiceName(
448         hwRender->renderParam.renderMode.hwInfo.cardServiceName, &hwAdapter->adapterDescriptor, portId);
449     if (ret != HDF_SUCCESS) {
450         AUDIO_FUNC_LOGE("AudioMakeCardServiceName fail");
451         return HDF_FAILURE;
452     }
453 
454     /* Select Path */
455 #ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT
456     if ((*pPathSelAnalysisJson)((void *)&hwRender->renderParam, RENDER_PATH_SELECT) < 0) {
457         AUDIO_FUNC_LOGE("Path Select Fail!");
458         return HDF_FAILURE;
459     }
460 #endif
461     return HDF_SUCCESS;
462 }
463 
BindServiceRenderOpen(struct AudioHwRender * hwRender,InterfaceLibModeRenderPassthrough * pInterfaceLibModeRender)464 static int32_t BindServiceRenderOpen(struct AudioHwRender *hwRender,
465     InterfaceLibModeRenderPassthrough *pInterfaceLibModeRender)
466 {
467     if (hwRender == NULL || hwRender->devDataHandle == NULL || pInterfaceLibModeRender == NULL ||
468         *pInterfaceLibModeRender == NULL) {
469         AUDIO_FUNC_LOGE("Parameter error!");
470         return HDF_FAILURE;
471     }
472 
473     int32_t ret =
474         (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN);
475     if (ret < 0) {
476         AUDIO_FUNC_LOGE("IAudioRender render open FAIL");
477         return HDF_FAILURE;
478     }
479     return HDF_SUCCESS;
480 }
481 
AudioCtrlRenderClose(struct AudioHwRender * hwRender,InterfaceLibModeRenderPassthrough * pInterfaceLibModeRender)482 int32_t AudioCtrlRenderClose(struct AudioHwRender *hwRender, InterfaceLibModeRenderPassthrough *pInterfaceLibModeRender)
483 {
484     if (hwRender == NULL || hwRender->devDataHandle == NULL || pInterfaceLibModeRender == NULL ||
485         *pInterfaceLibModeRender == NULL) {
486         AUDIO_FUNC_LOGE("Parameter error!");
487         return HDF_FAILURE;
488     }
489 
490     int32_t ret =
491         (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE);
492     if (ret < 0) {
493         AUDIO_FUNC_LOGE("Audio render close fail, ret is %{public}d", ret);
494         return HDF_FAILURE;
495     }
496     return HDF_SUCCESS;
497 }
498 
AudioAdapterBindServiceRender(struct AudioHwRender * hwRender)499 int32_t AudioAdapterBindServiceRender(struct AudioHwRender *hwRender)
500 {
501     int32_t ret;
502     if (hwRender == NULL || hwRender->devDataHandle == NULL || hwRender->devCtlHandle == NULL) {
503         AUDIO_FUNC_LOGE("Parameter error!");
504         return HDF_FAILURE;
505     }
506 
507     InterfaceLibModeRenderPassthrough *pInterfaceLibModeRender = AudioPassthroughGetInterfaceLibModeRender();
508     if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
509         AUDIO_FUNC_LOGE("InterfaceLibModeRender not exist");
510         return HDF_FAILURE;
511     }
512     if (BindServiceRenderOpen(hwRender, pInterfaceLibModeRender) != HDF_SUCCESS) {
513         return HDF_FAILURE;
514     }
515 
516     /* Init RenderPathSelect send first */
517     /* Internel Indicates the path selection for the sound card */
518 #ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT
519     uint32_t portId = hwRender->renderParam.renderMode.hwInfo.deviceDescript.portId;
520     if (portId < AUDIO_USB_ID_MIN) {
521         ret = (*pInterfaceLibModeRender)(
522             hwRender->devCtlHandle, &hwRender->renderParam, AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE);
523         if (ret < 0) {
524             AUDIO_FUNC_LOGE("SetParams FAIL!");
525             (void)AudioCtrlRenderClose(hwRender, pInterfaceLibModeRender);
526             return HDF_FAILURE;
527         }
528     }
529 #endif
530     /* set Attr Para */
531     ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, AUDIO_DRV_PCM_IOCTL_HW_PARAMS);
532     if (ret < 0) {
533         AUDIO_FUNC_LOGE("IAudioRender SetParams FAIL");
534         (void)AudioCtrlRenderClose(hwRender, pInterfaceLibModeRender);
535         return HDF_FAILURE;
536     }
537 
538     /* get volThreshold */
539     ret = (*pInterfaceLibModeRender)(
540         hwRender->devCtlHandle, &hwRender->renderParam, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ);
541     if (ret < 0) {
542         AUDIO_FUNC_LOGE("SetParams FAIL!");
543         (void)AudioCtrlRenderClose(hwRender, pInterfaceLibModeRender);
544         return HDF_FAILURE;
545     }
546 
547     ret = (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, AUDIO_DRV_PCM_IOCTL_PREPARE);
548     if (ret < 0) {
549         AUDIO_FUNC_LOGE("IAudioRender perpare FAIL");
550         (void)AudioCtrlRenderClose(hwRender, pInterfaceLibModeRender);
551         return HDF_FAILURE;
552     }
553     return HDF_SUCCESS;
554 }
555 
AudioRenderBindService(struct AudioHwRender * hwRender,BindServiceRenderPassthrough * pBindServiceRender)556 static int32_t AudioRenderBindService(struct AudioHwRender *hwRender, BindServiceRenderPassthrough *pBindServiceRender)
557 {
558     if (hwRender == NULL || pBindServiceRender == NULL || *pBindServiceRender == NULL) {
559         AUDIO_FUNC_LOGE("Parameter error!");
560         return AUDIO_ERR_INVALID_PARAM;
561     }
562 
563     /* bindRenderService */
564     hwRender->devDataHandle = (*pBindServiceRender)(RENDER_CMD);
565     if (hwRender->devDataHandle == NULL) {
566         AUDIO_FUNC_LOGE("Render bind service failed");
567         return AUDIO_ERR_INTERNAL;
568     }
569 
570     hwRender->devCtlHandle = (*pBindServiceRender)(CTRL_CMD);
571     if (hwRender->devCtlHandle == NULL) {
572         AUDIO_FUNC_LOGE("Render bind service failed");
573         return AUDIO_ERR_INTERNAL;
574     }
575 
576     int32_t ret = AudioAdapterBindServiceRender(hwRender);
577     if (ret != HDF_SUCCESS) {
578         return AUDIO_ERR_INTERNAL;
579     }
580     return AUDIO_SUCCESS;
581 }
582 
GetAvailableRenderID(struct AudioHwAdapter * hwAdapter)583 static uint32_t GetAvailableRenderID(struct AudioHwAdapter *hwAdapter)
584 {
585     uint32_t renderId = MAX_AUDIO_STREAM_NUM;
586     uint32_t index = 0;
587     if (hwAdapter == NULL) {
588         AUDIO_FUNC_LOGE("Parameter error!");
589         return renderId;
590     }
591 
592     if (hwAdapter->infos.renderCnt < MAX_AUDIO_STREAM_NUM) {
593         renderId = hwAdapter->infos.renderCnt;
594         hwAdapter->infos.renderCnt++;
595     } else {
596         for (index = 0; index < MAX_AUDIO_STREAM_NUM; index++) {
597             if (hwAdapter->infos.renderServicePtr[index] == NULL) {
598                 renderId = index;
599                 break;
600             }
601         }
602     }
603 
604     return renderId;
605 }
606 
AudioAdapterCreateRender(struct IAudioAdapter * adapter,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,struct IAudioRender ** render,uint32_t * renderId)607 int32_t AudioAdapterCreateRender(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc,
608     const struct AudioSampleAttributes *attrs, struct IAudioRender **render, uint32_t *renderId)
609 {
610     AUDIO_FUNC_LOGD("Enter.");
611     struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
612     if (hwAdapter == NULL || desc == NULL || attrs == NULL || render == NULL || renderId == NULL) {
613         AUDIO_FUNC_LOGE("Parameter error!");
614         return AUDIO_ERR_INVALID_PARAM;
615     }
616 
617     BindServiceRenderPassthrough *pBindServiceRender = AudioPassthroughGetBindServiceRender();
618     if (pBindServiceRender == NULL || *pBindServiceRender == NULL) {
619         AUDIO_FUNC_LOGE("lib render func not exist");
620         return AUDIO_ERR_INTERNAL;
621     }
622 
623     struct AudioHwRender *hwRender = (struct AudioHwRender *)OsalMemCalloc(sizeof(*hwRender));
624     if (hwRender == NULL) {
625         AUDIO_FUNC_LOGE("hwRender is NULL!");
626         return AUDIO_ERR_MALLOC_FAIL;
627     }
628 
629     int32_t ret = AudioAdapterCreateRenderPre(hwRender, desc, attrs, hwAdapter);
630     if (ret != HDF_SUCCESS) {
631         AudioMemFree((void **)&hwRender);
632         return AUDIO_ERR_INTERNAL;
633     }
634 
635     ret = AudioRenderBindService(hwRender, pBindServiceRender);
636     if (ret != AUDIO_SUCCESS) {
637         AudioReleaseRenderHandle(hwRender);
638         AudioMemFree((void **)&hwRender);
639         return ret;
640     }
641 
642     *renderId = GetAvailableRenderID(hwAdapter);
643     if (*renderId == MAX_AUDIO_STREAM_NUM) {
644         AUDIO_FUNC_LOGE("there is no available renderId");
645         AudioReleaseRenderHandle(hwRender);
646         AudioMemFree((void **)&hwRender);
647         return HDF_FAILURE;
648     }
649     hwAdapter->infos.renderServicePtr[*renderId] = hwRender;
650 
651     *render = &hwRender->common;
652     return AUDIO_SUCCESS;
653 }
654 
AudioAdapterDestroyRender(struct IAudioAdapter * adapter,uint32_t renderId)655 int32_t AudioAdapterDestroyRender(struct IAudioAdapter *adapter, uint32_t renderId)
656 {
657     AUDIO_FUNC_LOGD("Enter.");
658     int32_t ret = 0;
659     struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
660     if (hwAdapter == NULL || renderId >= MAX_AUDIO_STREAM_NUM) {
661         AUDIO_FUNC_LOGE("Invalid input param!");
662         return AUDIO_ERR_INVALID_PARAM;
663     }
664 
665     struct IAudioRender *render = (struct IAudioRender *)hwAdapter->infos.renderServicePtr[renderId];
666     StubCollectorRemoveObject(IAUDIORENDER_INTERFACE_DESC, render);
667 
668     struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
669     if (hwRender == NULL) {
670         AUDIO_FUNC_LOGE("hwRender is NULL!");
671         return AUDIO_ERR_INTERNAL;
672     }
673     pthread_mutex_lock(&hwRender->renderParam.frameRenderMode.mutex);
674     if (hwRender->renderParam.frameRenderMode.buffer != NULL) {
675         ret = render->Stop((AudioHandle)render);
676         if (ret < 0) {
677             AUDIO_FUNC_LOGE("render Stop failed");
678         }
679     }
680 
681     InterfaceLibModeRenderPassthrough *pInterfaceLibModeRender = AudioPassthroughGetInterfaceLibModeRender();
682     if (pInterfaceLibModeRender == NULL || *pInterfaceLibModeRender == NULL) {
683         AUDIO_FUNC_LOGE("InterfaceLibModeRender not exist");
684         pthread_mutex_unlock(&hwRender->renderParam.frameRenderMode.mutex);
685         return HDF_FAILURE;
686     }
687     ret =
688         (*pInterfaceLibModeRender)(hwRender->devDataHandle, &hwRender->renderParam, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE);
689     if (ret < 0) {
690         AUDIO_FUNC_LOGE("Audio RENDER_CLOSE FAIL");
691     }
692     AudioReleaseRenderHandle(hwRender);
693     AudioMemFree((void **)&hwRender->renderParam.frameRenderMode.buffer);
694     pthread_mutex_unlock(&hwRender->renderParam.frameRenderMode.mutex);
695     pthread_mutex_destroy(&hwRender->renderParam.frameRenderMode.mutex);
696     for (int i = 0; i < ERROR_LOG_MAX_NUM; i++) {
697         AudioMemFree((void **)&hwRender->errorLog.errorDump[i].reason);
698         AudioMemFree((void **)&hwRender->errorLog.errorDump[i].currentTime);
699     }
700     AudioMemFree((void **)&render);
701     hwAdapter->infos.renderServicePtr[renderId] = NULL;
702     return AUDIO_SUCCESS;
703 }
704 
AudioHwCaptureInit(struct AudioHwCapture * hwCapture)705 static int32_t AudioHwCaptureInit(struct AudioHwCapture *hwCapture)
706 {
707     if (hwCapture == NULL) {
708         AUDIO_FUNC_LOGE("Parameter error!");
709         return HDF_FAILURE;
710     }
711     hwCapture->common.Start = AudioCaptureStart;
712     hwCapture->common.Stop = AudioCaptureStop;
713     hwCapture->common.Pause = AudioCapturePause;
714     hwCapture->common.Resume = AudioCaptureResume;
715     hwCapture->common.Flush = AudioCaptureFlush;
716     hwCapture->common.TurnStandbyMode = AudioCaptureTurnStandbyMode;
717     hwCapture->common.AudioDevDump = AudioCaptureAudioDevDump;
718     hwCapture->common.GetFrameSize = AudioCaptureGetFrameSize;
719     hwCapture->common.GetFrameCount = AudioCaptureGetFrameCount;
720     hwCapture->common.SetSampleAttributes = AudioCaptureSetSampleAttributes;
721     hwCapture->common.GetSampleAttributes = AudioCaptureGetSampleAttributes;
722     hwCapture->common.GetCurrentChannelId = AudioCaptureGetCurrentChannelId;
723     hwCapture->common.SetExtraParams = AudioCaptureSetExtraParams;
724     hwCapture->common.GetExtraParams = AudioCaptureGetExtraParams;
725     hwCapture->common.ReqMmapBuffer = AudioCaptureReqMmapBuffer;
726     hwCapture->common.GetMmapPosition = AudioCaptureGetMmapPosition;
727     hwCapture->common.CheckSceneCapability = AudioCaptureCheckSceneCapability;
728     hwCapture->common.SelectScene = AudioCaptureSelectScene;
729     hwCapture->common.SetMute = AudioCaptureSetMute;
730     hwCapture->common.GetMute = AudioCaptureGetMute;
731     hwCapture->common.SetVolume = AudioCaptureSetVolume;
732     hwCapture->common.GetVolume = AudioCaptureGetVolume;
733     hwCapture->common.GetGainThreshold = AudioCaptureGetGainThreshold;
734     hwCapture->common.GetGain = AudioCaptureGetGain;
735     hwCapture->common.SetGain = AudioCaptureSetGain;
736     hwCapture->common.CaptureFrame = AudioCaptureCaptureFrame;
737     hwCapture->common.GetCapturePosition = AudioCaptureGetCapturePosition;
738     return HDF_SUCCESS;
739 }
740 
InitHwCaptureParam(struct AudioHwCapture * hwCapture,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs)741 int32_t InitHwCaptureParam(struct AudioHwCapture *hwCapture, const struct AudioDeviceDescriptor *desc,
742     const struct AudioSampleAttributes *attrs)
743 {
744     if (hwCapture == NULL || desc == NULL || attrs == NULL) {
745         AUDIO_FUNC_LOGE("Parameter error!");
746         return HDF_FAILURE;
747     }
748     int32_t ret = CheckParaDesc(desc, TYPE_CAPTURE);
749     if (ret != HDF_SUCCESS) {
750         return ret;
751     }
752     ret = CheckParaAttr(attrs);
753     if (ret != HDF_SUCCESS) {
754         return ret;
755     }
756     int32_t formatValue = -1;
757     ret = AttrFormatToBit(attrs, &formatValue);
758     if (ret != HDF_SUCCESS) {
759         return ret;
760     }
761     if (attrs->channelCount == 0) {
762         AUDIO_FUNC_LOGE("channelCount is zero!");
763         return HDF_FAILURE;
764     }
765     hwCapture->captureParam.captureMode.hwInfo.deviceDescript = *desc;
766     hwCapture->captureParam.frameCaptureMode.attrs = *attrs;
767     hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMax = GAIN_MAX; // init gainMax
768     hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMin = 0;
769     hwCapture->captureParam.frameCaptureMode.frames = 0;
770     hwCapture->captureParam.frameCaptureMode.time.tvNSec = 0;
771     hwCapture->captureParam.frameCaptureMode.time.tvSec = 0;
772     hwCapture->captureParam.frameCaptureMode.byteRate = DEFAULT_RENDER_SAMPLING_RATE;
773     hwCapture->captureParam.frameCaptureMode.periodSize = DEEP_BUFFER_RENDER_PERIOD_SIZE;
774     hwCapture->captureParam.frameCaptureMode.periodCount = DEEP_BUFFER_RENDER_PERIOD_COUNT;
775     hwCapture->captureParam.frameCaptureMode.attrs.period = attrs->period;
776     hwCapture->captureParam.frameCaptureMode.attrs.frameSize = attrs->frameSize;
777     hwCapture->captureParam.frameCaptureMode.attrs.startThreshold = attrs->startThreshold;
778     hwCapture->captureParam.frameCaptureMode.attrs.stopThreshold = attrs->stopThreshold;
779     hwCapture->captureParam.frameCaptureMode.attrs.silenceThreshold = attrs->silenceThreshold;
780     hwCapture->captureParam.frameCaptureMode.attrs.isBigEndian = attrs->isBigEndian;
781     hwCapture->captureParam.frameCaptureMode.attrs.isSignedData = attrs->isSignedData;
782     return HDF_SUCCESS;
783 }
784 
AudioReleaseCaptureHandle(struct AudioHwCapture * hwCapture)785 void AudioReleaseCaptureHandle(struct AudioHwCapture *hwCapture)
786 {
787     if (hwCapture == NULL) {
788         AUDIO_FUNC_LOGE("Parameter error!");
789         return;
790     }
791 
792     CloseServiceCapturePassthrough *pCloseCaptureService = AudioPassthroughGetCloseServiceCapture();
793     if (pCloseCaptureService == NULL || (*pCloseCaptureService) == NULL) {
794         AUDIO_FUNC_LOGE("pCloseCaptureService func not exist");
795         return;
796     }
797     if (hwCapture->devDataHandle != NULL) {
798         (*pCloseCaptureService)(hwCapture->devDataHandle);
799         hwCapture->devDataHandle = NULL;
800     }
801     if (hwCapture->devCtlHandle != NULL) {
802         (*pCloseCaptureService)(hwCapture->devCtlHandle);
803         hwCapture->devCtlHandle = NULL;
804     }
805 }
806 
AudioAdapterCreateCapturePre(struct AudioHwCapture * hwCapture,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,struct AudioHwAdapter * hwAdapter)807 int32_t AudioAdapterCreateCapturePre(struct AudioHwCapture *hwCapture, const struct AudioDeviceDescriptor *desc,
808     const struct AudioSampleAttributes *attrs, struct AudioHwAdapter *hwAdapter)
809 {
810     if (hwCapture == NULL || desc == NULL || attrs == NULL || hwAdapter == NULL) {
811         AUDIO_FUNC_LOGE("Parameter error!");
812         return HDF_FAILURE;
813     }
814 
815 #ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT
816     PathSelAnalysisJson *pPathSelAnalysisJson = AudioPassthroughGetPathSelAnalysisJson();
817     if (pPathSelAnalysisJson == NULL || *pPathSelAnalysisJson == NULL) {
818         AUDIO_FUNC_LOGE("PathSelAnalysisJson not exist");
819         return HDF_FAILURE;
820     }
821 #endif
822     if (AudioHwCaptureInit(hwCapture) < 0) {
823         return HDF_FAILURE;
824     }
825     if (InitHwCaptureParam(hwCapture, desc, attrs) < 0) {
826         AUDIO_FUNC_LOGE("InitHwCaptureParam error!");
827         return HDF_FAILURE;
828     }
829 
830     if (hwAdapter->adapterDescriptor.adapterName == NULL) {
831         AUDIO_FUNC_LOGE("adapterName is NULL!");
832         return HDF_FAILURE;
833     }
834     uint32_t adapterNameLen = strlen(hwAdapter->adapterDescriptor.adapterName);
835     if (adapterNameLen == 0) {
836         AUDIO_FUNC_LOGE("adapterNameLen is zero!");
837         return HDF_FAILURE;
838     }
839     int32_t ret = strncpy_s(hwCapture->captureParam.captureMode.hwInfo.adapterName, NAME_LEN - 1,
840         hwAdapter->adapterDescriptor.adapterName, adapterNameLen);
841     if (ret != EOK) {
842         AUDIO_FUNC_LOGE("Copy adapterName is failed!");
843         return HDF_FAILURE;
844     }
845     uint32_t portId = hwCapture->captureParam.captureMode.hwInfo.deviceDescript.portId;
846     ret = AudioMakeCardServiceName(
847         hwCapture->captureParam.captureMode.hwInfo.cardServiceName, &hwAdapter->adapterDescriptor, portId);
848     if (ret != HDF_SUCCESS) {
849         AUDIO_FUNC_LOGE("AudioMakeCardServiceName fail");
850         return HDF_FAILURE;
851     }
852 
853 #ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT
854     if ((*pPathSelAnalysisJson)((void *)&hwCapture->captureParam, CAPTURE_PATH_SELECT) < 0) {
855         AUDIO_FUNC_LOGE("Path Select Fail!");
856         return HDF_FAILURE;
857     }
858 #endif
859 
860     return HDF_SUCCESS;
861 }
862 
AudioCtrlCaptureClose(struct AudioHwCapture * hwCapture,InterfaceLibModeCapturePassthrough * pInterfaceLibModeCapture)863 static int32_t AudioCtrlCaptureClose(struct AudioHwCapture *hwCapture,
864     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture)
865 {
866     if (hwCapture == NULL || hwCapture->devDataHandle == NULL || pInterfaceLibModeCapture == NULL ||
867         *pInterfaceLibModeCapture == NULL) {
868         AUDIO_FUNC_LOGE("Parameter error!");
869         return HDF_FAILURE;
870     }
871 
872     int32_t ret = (*pInterfaceLibModeCapture)(
873         hwCapture->devDataHandle, &hwCapture->captureParam, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE);
874     if (ret < 0) {
875         AUDIO_FUNC_LOGE("Audio capture close fail, ret is %{public}d", ret);
876         return HDF_FAILURE;
877     }
878     return HDF_SUCCESS;
879 }
880 
AudioAdapterInterfaceLibModeCapture(struct AudioHwCapture * hwCapture)881 int32_t AudioAdapterInterfaceLibModeCapture(struct AudioHwCapture *hwCapture)
882 {
883     if (hwCapture == NULL || hwCapture->devCtlHandle == NULL || hwCapture->devDataHandle == NULL) {
884         AUDIO_FUNC_LOGE("Parameter error!");
885         return HDF_FAILURE;
886     }
887 
888     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
889     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
890         AUDIO_FUNC_LOGE("lib capture func not exist");
891         return HDF_FAILURE;
892     }
893     int32_t ret = (*pInterfaceLibModeCapture)(
894         hwCapture->devDataHandle, &hwCapture->captureParam, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN);
895     if (ret < 0) {
896         AUDIO_FUNC_LOGE("CAPTURE_OPEN FAIL");
897         return HDF_FAILURE;
898     }
899 #ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT
900     ret = (*pInterfaceLibModeCapture)(
901         hwCapture->devCtlHandle, &hwCapture->captureParam, AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE);
902     if (ret < 0) {
903         AUDIO_FUNC_LOGE("SetParams FAIL!");
904         (void)AudioCtrlCaptureClose(hwCapture, pInterfaceLibModeCapture);
905         return HDF_FAILURE;
906     }
907 #endif
908     ret =
909         (*pInterfaceLibModeCapture)(hwCapture->devDataHandle, &hwCapture->captureParam, AUDIO_DRV_PCM_IOCTL_HW_PARAMS);
910     if (ret < 0) {
911         AUDIO_FUNC_LOGE("AudioCaptureStart SetParams FAIL");
912         (void)AudioCtrlCaptureClose(hwCapture, pInterfaceLibModeCapture);
913         return HDF_FAILURE;
914     }
915     ret = (*pInterfaceLibModeCapture)(
916         hwCapture->devCtlHandle, &hwCapture->captureParam, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE);
917     if (ret < 0) {
918         AUDIO_FUNC_LOGE("SetParams FAIL!");
919         (void)AudioCtrlCaptureClose(hwCapture, pInterfaceLibModeCapture);
920         return HDF_FAILURE;
921     }
922     ret = (*pInterfaceLibModeCapture)(
923         hwCapture->devDataHandle, &hwCapture->captureParam, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE);
924     if (ret < 0) {
925         AUDIO_FUNC_LOGE("AudioCaptureStart prepare FAIL");
926         (void)AudioCtrlCaptureClose(hwCapture, pInterfaceLibModeCapture);
927         return HDF_FAILURE;
928     }
929     return HDF_SUCCESS;
930 }
931 
AudioCaptureBindService(struct AudioHwCapture * hwCapture,BindServiceCapturePassthrough * pBindServiceCapture)932 int32_t AudioCaptureBindService(struct AudioHwCapture *hwCapture, BindServiceCapturePassthrough *pBindServiceCapture)
933 {
934     if (hwCapture == NULL || pBindServiceCapture == NULL || *pBindServiceCapture == NULL) {
935         AUDIO_FUNC_LOGE("Parameter error!");
936         return AUDIO_ERR_INVALID_PARAM;
937     }
938 
939     hwCapture->devDataHandle = (*pBindServiceCapture)(CAPTURE_CMD);
940     if (hwCapture->devDataHandle == NULL) {
941         AUDIO_FUNC_LOGE("Capture bind service failed");
942         return AUDIO_ERR_INTERNAL;
943     }
944     hwCapture->devCtlHandle = (*pBindServiceCapture)(CTRL_CMD);
945     if (hwCapture->devCtlHandle == NULL) {
946         AUDIO_FUNC_LOGE("Capture bind service failed");
947         return AUDIO_ERR_INTERNAL;
948     }
949     int32_t ret = AudioAdapterInterfaceLibModeCapture(hwCapture);
950     if (ret != 0) {
951         AUDIO_FUNC_LOGE("AudioAdapterInterfaceLibModeCapture failed");
952         return AUDIO_ERR_INTERNAL;
953     }
954     return AUDIO_SUCCESS;
955 }
956 
GetAvailableCaptureID(struct AudioHwAdapter * hwAdapter)957 static uint32_t GetAvailableCaptureID(struct AudioHwAdapter *hwAdapter)
958 {
959     uint32_t captureId = MAX_AUDIO_STREAM_NUM;
960     uint32_t index = 0;
961     if (hwAdapter == NULL) {
962         AUDIO_FUNC_LOGE("Parameter error!");
963         return captureId;
964     }
965 
966     if (hwAdapter->infos.captureCnt < MAX_AUDIO_STREAM_NUM) {
967         captureId = hwAdapter->infos.captureCnt;
968         hwAdapter->infos.captureCnt++;
969     } else {
970         for (index = 0; index < MAX_AUDIO_STREAM_NUM; index++) {
971             if (hwAdapter->infos.captureServicePtr[index] == NULL) {
972                 captureId = index;
973                 break;
974             }
975         }
976     }
977 
978     return captureId;
979 }
980 
AudioAdapterCreateCapture(struct IAudioAdapter * adapter,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,struct IAudioCapture ** capture,uint32_t * captureId)981 int32_t AudioAdapterCreateCapture(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc,
982     const struct AudioSampleAttributes *attrs, struct IAudioCapture **capture, uint32_t *captureId)
983 {
984     AUDIO_FUNC_LOGD("Enter.");
985     struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
986     if (hwAdapter == NULL || desc == NULL || attrs == NULL || capture == NULL || captureId == NULL) {
987         AUDIO_FUNC_LOGE("Parameter error!");
988         return AUDIO_ERR_INVALID_PARAM;
989     }
990 
991     BindServiceCapturePassthrough *pBindServiceCapture = AudioPassthroughGetBindServiceCapture();
992     if (pBindServiceCapture == NULL || *pBindServiceCapture == NULL) {
993         AUDIO_FUNC_LOGE("lib capture func not exist");
994         return AUDIO_ERR_INTERNAL;
995     }
996     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)OsalMemCalloc(sizeof(*hwCapture));
997     if (hwCapture == NULL) {
998         AUDIO_FUNC_LOGE("calloc AudioHwCapture failed!");
999         return AUDIO_ERR_MALLOC_FAIL;
1000     }
1001     int32_t ret = AudioAdapterCreateCapturePre(hwCapture, desc, attrs, hwAdapter);
1002     if (ret != AUDIO_SUCCESS) {
1003         AUDIO_FUNC_LOGE("call AudioAdapterCreateCapturePre failed %{public}d", ret);
1004         AudioMemFree((void **)&hwCapture);
1005         return AUDIO_ERR_INTERNAL;
1006     }
1007     ret = AudioCaptureBindService(hwCapture, pBindServiceCapture);
1008     if (ret < 0) {
1009         AudioReleaseCaptureHandle(hwCapture);
1010         AudioMemFree((void **)&hwCapture);
1011         return ret;
1012     }
1013 
1014     *captureId = GetAvailableCaptureID(hwAdapter);
1015     if (*captureId == MAX_AUDIO_STREAM_NUM) {
1016         AUDIO_FUNC_LOGE("there is no available captureId");
1017         AudioReleaseCaptureHandle(hwCapture);
1018         AudioMemFree((void **)&hwCapture);
1019         return HDF_FAILURE;
1020     }
1021     hwAdapter->infos.captureServicePtr[*captureId] = hwCapture;
1022 
1023     *capture = &hwCapture->common;
1024     return AUDIO_SUCCESS;
1025 }
1026 
AudioAdapterDestroyCapture(struct IAudioAdapter * adapter,uint32_t captureId)1027 int32_t AudioAdapterDestroyCapture(struct IAudioAdapter *adapter, uint32_t captureId)
1028 {
1029     AUDIO_FUNC_LOGD("Enter.");
1030     int32_t ret = 0;
1031     struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
1032     if (hwAdapter == NULL || captureId >= MAX_AUDIO_STREAM_NUM) {
1033         AUDIO_FUNC_LOGE("Parameter error!");
1034         return AUDIO_ERR_INVALID_PARAM;
1035     }
1036     struct IAudioCapture *capture = (struct IAudioCapture *)hwAdapter->infos.captureServicePtr[captureId];
1037 
1038     StubCollectorRemoveObject(IAUDIOCAPTURE_INTERFACE_DESC, capture);
1039 
1040     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
1041     if (hwCapture == NULL) {
1042         AUDIO_FUNC_LOGE("hwCapture is NULL!");
1043         return AUDIO_ERR_INTERNAL;
1044     }
1045     if (hwCapture->captureParam.frameCaptureMode.buffer != NULL) {
1046         ret = capture->Stop((AudioHandle)capture);
1047         if (ret < 0) {
1048             AUDIO_FUNC_LOGE("capture Stop failed");
1049         }
1050     }
1051     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
1052     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
1053         AUDIO_FUNC_LOGE("lib capture func not exist");
1054         return HDF_FAILURE;
1055     }
1056     ret = (*pInterfaceLibModeCapture)(
1057         hwCapture->devDataHandle, &hwCapture->captureParam, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE);
1058     if (ret < 0) {
1059         AUDIO_FUNC_LOGE("CAPTURE_CLOSE FAIL");
1060     }
1061     AudioReleaseCaptureHandle(hwCapture);
1062     AudioMemFree((void **)&hwCapture->captureParam.frameCaptureMode.buffer);
1063     for (int i = 0; i < ERROR_LOG_MAX_NUM; i++) {
1064         AudioMemFree((void **)&hwCapture->errorLog.errorDump[i].reason);
1065         AudioMemFree((void **)&hwCapture->errorLog.errorDump[i].currentTime);
1066     }
1067     AudioMemFree((void **)&capture);
1068     hwAdapter->infos.captureServicePtr[captureId] = NULL;
1069     return AUDIO_SUCCESS;
1070 }
1071 
AudioSubPortCapabilityDestroy(struct AudioSubPortCapability * dataBlock,bool freeSelf)1072 static void AudioSubPortCapabilityDestroy(struct AudioSubPortCapability *dataBlock, bool freeSelf)
1073 {
1074     if (dataBlock == NULL) {
1075         return;
1076     }
1077 
1078     if (dataBlock->desc != NULL) {
1079         OsalMemFree(dataBlock->desc);
1080         dataBlock->desc = NULL;
1081     }
1082 
1083     if (freeSelf) {
1084         OsalMemFree(dataBlock);
1085     }
1086 }
1087 
AudioPortCapabilityDeepFree(struct AudioPortCapability * dataBlock,bool freeSelf)1088 static void AudioPortCapabilityDeepFree(struct AudioPortCapability *dataBlock, bool freeSelf)
1089 {
1090     if (dataBlock == NULL) {
1091         return;
1092     }
1093 
1094     if (dataBlock->formats != NULL) {
1095         OsalMemFree(dataBlock->formats);
1096         dataBlock->formats = NULL;
1097     }
1098 
1099     if (dataBlock->subPorts != NULL) {
1100         for (uint32_t i = 0; i < dataBlock->subPortsLen; i++) {
1101             AudioSubPortCapabilityDestroy(&dataBlock->subPorts[i], false);
1102         }
1103         OsalMemFree(dataBlock->subPorts);
1104         dataBlock->subPorts = NULL;
1105     }
1106 
1107     if (dataBlock->supportSampleFormats != NULL) {
1108         OsalMemFree(dataBlock->supportSampleFormats);
1109         dataBlock->supportSampleFormats = NULL;
1110     }
1111 
1112     if (freeSelf) {
1113         OsalMemFree(dataBlock);
1114     }
1115 }
1116 
AudioDeepCopySubCapability(struct AudioSubPortCapability ** dstSubPortsOut,struct AudioSubPortCapability * srcSubPorts,uint32_t subPortsLen)1117 static int32_t AudioDeepCopySubCapability(
1118     struct AudioSubPortCapability **dstSubPortsOut, struct AudioSubPortCapability *srcSubPorts, uint32_t subPortsLen)
1119 {
1120     struct AudioSubPortCapability *dstSubPorts = NULL;
1121 
1122     if (dstSubPortsOut == NULL || srcSubPorts == NULL || subPortsLen == 0) {
1123         AUDIO_FUNC_LOGE("Parameter error!");
1124         return AUDIO_ERR_INVALID_PARAM;
1125     }
1126     dstSubPorts = (struct AudioSubPortCapability *)OsalMemCalloc(subPortsLen * sizeof(struct AudioSubPortCapability));
1127     if (dstSubPorts == NULL) {
1128         AUDIO_FUNC_LOGE("OsalMemCalloc fail");
1129         return AUDIO_ERR_MALLOC_FAIL;
1130     }
1131     *dstSubPortsOut = dstSubPorts;
1132     for (uint32_t i = 0; i < subPortsLen; i++) {
1133         dstSubPorts[i] = srcSubPorts[i];
1134         if (srcSubPorts[i].desc != NULL) {
1135             dstSubPorts[i].desc = (char *)OsalMemCalloc(strlen(srcSubPorts[i].desc) + 1);
1136             if (dstSubPorts[i].desc == NULL) {
1137                 AUDIO_FUNC_LOGE("OsalMemCalloc fail");
1138                 return AUDIO_ERR_MALLOC_FAIL;
1139             }
1140             int32_t ret = memcpy_s(
1141                 dstSubPorts[i].desc, strlen(srcSubPorts[i].desc), srcSubPorts[i].desc, strlen(srcSubPorts[i].desc));
1142             if (ret != EOK) {
1143                 AUDIO_FUNC_LOGE("memcpy_s fail");
1144                 return AUDIO_ERR_INTERNAL;
1145             }
1146         }
1147     }
1148     return AUDIO_SUCCESS;
1149 }
1150 
AudioDeepCopyCapability(struct AudioPortCapability * destCap,struct AudioPortCapability * sourceCap)1151 static int32_t AudioDeepCopyCapability(struct AudioPortCapability *destCap, struct AudioPortCapability *sourceCap)
1152 {
1153     if (destCap == NULL || sourceCap == NULL) {
1154         AUDIO_FUNC_LOGE("Parameter error!");
1155         return AUDIO_ERR_INVALID_PARAM;
1156     }
1157 
1158     *destCap = *sourceCap;
1159     destCap->formats = NULL;
1160     destCap->supportSampleFormats = NULL;
1161     destCap->subPorts = NULL;
1162 
1163     if (sourceCap->formats != NULL) {
1164         destCap->formats = (enum AudioFormat *)OsalMemCalloc(sizeof(enum AudioFormat));
1165         if (destCap->formats == NULL) {
1166             AUDIO_FUNC_LOGE("OsalMemCalloc fail");
1167             return AUDIO_ERR_MALLOC_FAIL;
1168         }
1169         *destCap->formats = *sourceCap->formats;
1170     }
1171     if (sourceCap->supportSampleFormats != NULL) {
1172         destCap->supportSampleFormats = (enum AudioSampleFormat *)OsalMemCalloc(sizeof(enum AudioSampleFormat));
1173         if (destCap->supportSampleFormats == NULL) {
1174             AUDIO_FUNC_LOGE("OsalMemCalloc fail");
1175             AudioPortCapabilityDeepFree(destCap, false);
1176             return AUDIO_ERR_MALLOC_FAIL;
1177         }
1178         *destCap->supportSampleFormats = *sourceCap->supportSampleFormats;
1179     }
1180     int32_t ret = AudioDeepCopySubCapability(&(destCap->subPorts), sourceCap->subPorts, sourceCap->subPortsLen);
1181     if (ret < 0) {
1182         AUDIO_FUNC_LOGE("AudioDeepCopySubCapability copy fail");
1183         AudioPortCapabilityDeepFree(destCap, false);
1184         return AUDIO_ERR_MALLOC_FAIL;
1185     }
1186     return AUDIO_SUCCESS;
1187 }
1188 
AudioAdapterGetPortCapability(struct IAudioAdapter * adapter,const struct AudioPort * port,struct AudioPortCapability * capability)1189 int32_t AudioAdapterGetPortCapability(
1190     struct IAudioAdapter *adapter, const struct AudioPort *port, struct AudioPortCapability *capability)
1191 {
1192     AUDIO_FUNC_LOGD("Enter.");
1193     struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
1194     if (hwAdapter == NULL || port == NULL || port->portName == NULL || capability == NULL) {
1195         AUDIO_FUNC_LOGE("Parameter error!");
1196         return AUDIO_ERR_INVALID_PARAM;
1197     }
1198     struct AudioPortAndCapability *hwAdapterPortCapabilitys = hwAdapter->portCapabilitys;
1199     if (hwAdapterPortCapabilitys == NULL) {
1200         AUDIO_FUNC_LOGE("hwAdapter portCapabilitys is NULL!");
1201         return AUDIO_ERR_INTERNAL;
1202     }
1203     uint32_t portsLen = hwAdapter->adapterDescriptor.portsLen;
1204     while (hwAdapterPortCapabilitys != NULL && portsLen > 0) {
1205         if (hwAdapterPortCapabilitys->port.portId == port->portId) {
1206             if (AudioDeepCopyCapability(capability, &hwAdapterPortCapabilitys->capability) < 0) {
1207                 return AUDIO_ERR_INTERNAL;
1208             }
1209             return AUDIO_SUCCESS;
1210         }
1211         hwAdapterPortCapabilitys++;
1212         portsLen--;
1213     }
1214     return AUDIO_ERR_INTERNAL;
1215 }
1216 
AudioAdapterSetPassthroughMode(struct IAudioAdapter * adapter,const struct AudioPort * port,enum AudioPortPassthroughMode mode)1217 int32_t AudioAdapterSetPassthroughMode(
1218     struct IAudioAdapter *adapter, const struct AudioPort *port, enum AudioPortPassthroughMode mode)
1219 {
1220     AUDIO_FUNC_LOGD("Enter.");
1221     if (adapter == NULL || port == NULL || port->portName == NULL) {
1222         AUDIO_FUNC_LOGE("Parameter error!");
1223         return AUDIO_ERR_INVALID_PARAM;
1224     }
1225     if (port->dir != PORT_OUT || port->portId < 0 || strcmp(port->portName, "AOP") != 0) {
1226         AUDIO_FUNC_LOGE("Port error!");
1227         return AUDIO_ERR_INTERNAL;
1228     }
1229     struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
1230     if (hwAdapter->portCapabilitys == NULL) {
1231         AUDIO_FUNC_LOGE("The pointer is null!");
1232         return AUDIO_ERR_INTERNAL;
1233     }
1234     struct AudioPortAndCapability *portCapabilityTemp = hwAdapter->portCapabilitys;
1235     struct AudioPortCapability *portCapability = NULL;
1236     uint32_t portsLen = hwAdapter->adapterDescriptor.portsLen;
1237     while (portCapabilityTemp != NULL && portsLen > 0) {
1238         if (portCapabilityTemp->port.portId == port->portId) {
1239             portCapability = &portCapabilityTemp->capability;
1240             break;
1241         }
1242         portCapabilityTemp++;
1243         portsLen--;
1244     }
1245     if (portCapability == NULL || portsLen == 0) {
1246         AUDIO_FUNC_LOGE("hwAdapter portCapabilitys is Not Find!");
1247         return AUDIO_ERR_INTERNAL;
1248     }
1249     struct AudioSubPortCapability *subPortCapability = portCapability->subPorts;
1250     if (subPortCapability == NULL) {
1251         AUDIO_FUNC_LOGE("portCapability->subPorts is NULL!");
1252         return AUDIO_ERR_INTERNAL;
1253     }
1254     uint32_t subportsLen = portCapability->subPortsLen;
1255     while (subPortCapability != NULL && subportsLen > 0) {
1256         if (subPortCapability->mask == mode) {
1257             portCapabilityTemp->mode = mode;
1258             break;
1259         }
1260         subPortCapability++;
1261         subportsLen--;
1262     }
1263     if (subportsLen == 0) {
1264         AUDIO_FUNC_LOGE("subPortCapability's Temp mode is not find!");
1265         return AUDIO_ERR_INTERNAL;
1266     }
1267     return AUDIO_SUCCESS;
1268 }
1269 
AudioAdapterGetPassthroughMode(struct IAudioAdapter * adapter,const struct AudioPort * port,enum AudioPortPassthroughMode * mode)1270 int32_t AudioAdapterGetPassthroughMode(
1271     struct IAudioAdapter *adapter, const struct AudioPort *port, enum AudioPortPassthroughMode *mode)
1272 {
1273     AUDIO_FUNC_LOGD("Enter.");
1274     if (adapter == NULL || port == NULL || port->portName == NULL || mode == NULL) {
1275         AUDIO_FUNC_LOGE("Parameter error!");
1276         return AUDIO_ERR_INVALID_PARAM;
1277     }
1278     if (port->dir != PORT_OUT || port->portId < 0 || strcmp(port->portName, "AOP") != 0) {
1279         AUDIO_FUNC_LOGE("Port error!");
1280         return AUDIO_ERR_INTERNAL;
1281     }
1282     struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
1283     if (hwAdapter->portCapabilitys == NULL) {
1284         AUDIO_FUNC_LOGE("portCapabilitys pointer is null!");
1285         return AUDIO_ERR_INTERNAL;
1286     }
1287     struct AudioPortAndCapability *portCapabilitys = hwAdapter->portCapabilitys;
1288     uint32_t portsLen = hwAdapter->adapterDescriptor.portsLen;
1289     while (portCapabilitys != NULL && portsLen > 0) {
1290         if (portCapabilitys->port.portId == port->portId) {
1291             *mode = portCapabilitys->mode;
1292             return AUDIO_SUCCESS;
1293         }
1294         portCapabilitys++;
1295         portsLen--;
1296     }
1297     return AUDIO_ERR_INTERNAL;
1298 }
AudioAdapterGetDeviceStatus(struct IAudioAdapter * adapter,struct AudioDeviceStatus * status)1299 int32_t AudioAdapterGetDeviceStatus(struct IAudioAdapter *adapter, struct AudioDeviceStatus *status)
1300 {
1301     AUDIO_FUNC_LOGD("Enter.");
1302     (void)adapter;
1303     (void)status;
1304     return AUDIO_SUCCESS;
1305 }
AudioAdapterRelease(struct IAudioAdapter * instance)1306 void AudioAdapterRelease(struct IAudioAdapter *instance)
1307 {
1308     (void)instance;
1309 }
1310