1 /*
2  * Copyright (c) 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_vdi.h"
17 
18 #include <limits.h>
19 #include "osal_mem.h"
20 #include "securec.h"
21 #include <hdf_base.h>
22 #include "audio_uhdf_log.h"
23 #include "audio_capture_vdi.h"
24 #include "audio_common_vdi.h"
25 #include "audio_render_vdi.h"
26 #include "audio_dfx_vdi.h"
27 #include "v4_0/iaudio_callback.h"
28 
29 #define HDF_LOG_TAG    HDF_AUDIO_PRIMARY_IMPL
30 static pthread_mutex_t g_adapterMutex;
31 
32 struct AudioAdapterInfo {
33     struct IAudioAdapterVdi *vdiAdapter;
34     struct IAudioAdapter *adapter;
35     uint32_t refCnt;
36     char *adapterName;
37 };
38 
39 struct AudioAdapterPrivVdi {
40     struct AudioAdapterInfo adapterInfo[AUDIO_VDI_ADAPTER_NUM_MAX];
41     struct IAudioCallback *callback;
42     bool isRegCb;
43 };
44 
45 static struct AudioAdapterPrivVdi g_audioAdapterVdi;
46 
AudioAdapterGetPrivVdi(void)47 static struct AudioAdapterPrivVdi *AudioAdapterGetPrivVdi(void)
48 {
49     return &g_audioAdapterVdi;
50 }
51 
AudioGetVdiAdapterByDescIndexVdi(uint32_t descIndex)52 struct IAudioAdapterVdi *AudioGetVdiAdapterByDescIndexVdi(uint32_t descIndex)
53 {
54     struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
55 
56     if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
57         AUDIO_FUNC_LOGE("get vdiAdapter error, descIndex=%{public}d", descIndex);
58         return NULL;
59     }
60 
61     return priv->adapterInfo[descIndex].vdiAdapter;
62 }
63 
AudioGetVdiAdapterVdi(const struct IAudioAdapter *adapter)64 static struct IAudioAdapterVdi *AudioGetVdiAdapterVdi(const struct IAudioAdapter *adapter)
65 {
66     struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
67 
68     if (adapter == NULL) {
69         AUDIO_FUNC_LOGE("get vdiAdapter error");
70         return NULL;
71     }
72 
73     for (uint32_t i = 0; i < AUDIO_VDI_ADAPTER_NUM_MAX; i++) {
74         if (adapter == priv->adapterInfo[i].adapter) {
75             return priv->adapterInfo[i].vdiAdapter;
76         }
77     }
78 
79     AUDIO_FUNC_LOGE("audio get vdiadapter fail");
80     return NULL;
81 }
82 
AudioGetAdapterNameVdi(const struct IAudioAdapter *adapter)83 static char *AudioGetAdapterNameVdi(const struct IAudioAdapter *adapter)
84 {
85     struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
86 
87     if (adapter == NULL) {
88         AUDIO_FUNC_LOGE("get AdapterName error");
89         return NULL;
90     }
91 
92     for (uint32_t i = 0; i < AUDIO_VDI_ADAPTER_NUM_MAX; i++) {
93         if (adapter == priv->adapterInfo[i].adapter) {
94             return priv->adapterInfo[i].adapterName;
95         }
96     }
97 
98     AUDIO_FUNC_LOGE("audio get adapterName fail");
99     return NULL;
100 }
101 
AudioInitAllPortsVdi(struct IAudioAdapter *adapter)102 int32_t AudioInitAllPortsVdi(struct IAudioAdapter *adapter)
103 {
104     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
105 
106     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
107     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
108 
109     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->InitAllPorts, HDF_ERR_INVALID_PARAM);
110     pthread_mutex_lock(&g_adapterMutex);
111     int32_t ret = vdiAdapter->InitAllPorts(vdiAdapter);
112     if (ret != HDF_SUCCESS) {
113         AUDIO_FUNC_LOGE("audio vdiAdapter InitAllPorts fail, ret=%{public}d", ret);
114         pthread_mutex_unlock(&g_adapterMutex);
115         return HDF_FAILURE;
116     }
117     pthread_mutex_unlock(&g_adapterMutex);
118 
119     return HDF_SUCCESS;
120 }
121 
VerifyParamsOfAudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs, struct IAudioRender **render, uint32_t *renderId)122 static int32_t VerifyParamsOfAudioCreateRenderVdi(struct IAudioAdapter *adapter,
123     const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs,
124     struct IAudioRender **render, uint32_t *renderId)
125 {
126     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
127     CHECK_NULL_PTR_RETURN_VALUE(desc, HDF_ERR_INVALID_PARAM);
128     CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
129     CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
130     CHECK_NULL_PTR_RETURN_VALUE(renderId, HDF_ERR_INVALID_PARAM);
131     CHECK_VALID_RANGE_RETURN(*renderId, 0, AUDIO_VDI_STREAM_NUM_MAX - 1, HDF_ERR_INVALID_PARAM);
132 
133     if (desc->pins == PIN_OUT_LINEOUT || desc->pins == PIN_OUT_HDMI ||
134         desc->pins == PIN_NONE || desc->pins >= PIN_IN_MIC) {
135         AUDIO_FUNC_LOGE("invalid pin [%{public}d]", desc->pins);
136         return HDF_FAILURE;
137     }
138     return HDF_SUCCESS;
139 }
140 
AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs, struct IAudioRender **render, uint32_t *renderId)141 int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc,
142     const struct AudioSampleAttributes *attrs, struct IAudioRender **render, uint32_t *renderId)
143 {
144     AUDIO_FUNC_LOGD("enter to %{public}s", __func__);
145     struct AudioDeviceDescriptorVdi vdiDesc;
146     struct AudioSampleAttributesVdi vdiAttrs;
147     struct IAudioRenderVdi *vdiRender = NULL;
148 
149     int32_t ret = VerifyParamsOfAudioCreateRenderVdi(adapter, desc, attrs, render, renderId);
150     if (ret != HDF_SUCCESS) {
151         return ret;
152     }
153 
154     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
155     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
156     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->CreateRender, HDF_ERR_INVALID_PARAM);
157     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->DestroyRender, HDF_ERR_INVALID_PARAM);
158 
159     pthread_mutex_lock(&g_adapterMutex);
160     char *adapterName = AudioGetAdapterNameVdi(adapter);
161     *render = FindRenderCreated(desc->pins, attrs, renderId, adapterName);
162     if (*render != NULL) {
163         AUDIO_FUNC_LOGE("already created");
164         pthread_mutex_unlock(&g_adapterMutex);
165         return HDF_SUCCESS;
166     }
167     if (AudioCommonDevDescToVdiDevDescVdi(desc, &vdiDesc) != HDF_SUCCESS) {
168         pthread_mutex_unlock(&g_adapterMutex);
169         return HDF_FAILURE;
170     }
171     AudioCommonAttrsToVdiAttrsVdi(attrs, &vdiAttrs);
172 
173     int32_t id = SetTimer("Hdi:CreateRender");
174     ret = vdiAdapter->CreateRender(vdiAdapter, &vdiDesc, &vdiAttrs, &vdiRender);
175     CancelTimer(id);
176     OsalMemFree((void *)vdiDesc.desc);
177     if (ret != HDF_SUCCESS) {
178         AUDIO_FUNC_LOGE("audio vdiAdapter call CreateRender fail, ret=%{public}d", ret);
179         pthread_mutex_unlock(&g_adapterMutex);
180         return HDF_FAILURE;
181     }
182     *render = AudioCreateRenderByIdVdi(attrs, renderId, vdiRender, desc, adapterName);
183     vdiRender->AddAudioEffect = NULL;
184     vdiRender->RemoveAudioEffect = NULL;
185     vdiRender->GetFrameBufferSize = NULL;
186     vdiRender->IsSupportsPauseAndResume = NULL;
187     if (*render == NULL) {
188         (void)vdiAdapter->DestroyRender(vdiAdapter, vdiRender);
189         AUDIO_FUNC_LOGE("Create audio render failed");
190         pthread_mutex_unlock(&g_adapterMutex);
191         return HDF_ERR_INVALID_PARAM;
192     }
193     pthread_mutex_unlock(&g_adapterMutex);
194     AUDIO_FUNC_LOGI("AudioCreateRenderVdi Success");
195     return HDF_SUCCESS;
196 }
197 
AudioDestroyRenderVdi(struct IAudioAdapter *adapter, uint32_t renderId)198 int32_t AudioDestroyRenderVdi(struct IAudioAdapter *adapter, uint32_t renderId)
199 {
200     AUDIO_FUNC_LOGD("enter to %{public}s", __func__);
201     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
202     CHECK_VALID_RANGE_RETURN(renderId, 0, AUDIO_VDI_STREAM_NUM_MAX - 1, HDF_ERR_INVALID_PARAM);
203     if (DecreaseRenderUsrCount(renderId) > 0) {
204         AUDIO_FUNC_LOGE("render destroy: more than one usr");
205         return HDF_SUCCESS;
206     }
207     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
208     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
209 
210     pthread_mutex_lock(&g_adapterMutex);
211     struct IAudioRenderVdi *vdiRender = AudioGetVdiRenderByIdVdi(renderId);
212     if (vdiRender == NULL) {
213         AUDIO_FUNC_LOGE("vdiRender pointer is null");
214         pthread_mutex_unlock(&g_adapterMutex);
215         return HDF_ERR_INVALID_PARAM;
216     }
217 
218     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->DestroyRender, HDF_ERR_INVALID_PARAM);
219     int32_t ret = vdiAdapter->DestroyRender(vdiAdapter, vdiRender);
220     if (ret != HDF_SUCCESS) {
221         AUDIO_FUNC_LOGE("audio vdiAdapter call DestroyRender fail, ret=%{public}d", ret);
222         pthread_mutex_unlock(&g_adapterMutex);
223         return HDF_FAILURE;
224     }
225 
226     AudioDestroyRenderByIdVdi(renderId);
227     pthread_mutex_unlock(&g_adapterMutex);
228     return HDF_SUCCESS;
229 }
230 
AudioCreateCaptureVdi(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs, struct IAudioCapture **capture, uint32_t *captureId)231 int32_t AudioCreateCaptureVdi(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc,
232     const struct AudioSampleAttributes *attrs, struct IAudioCapture **capture, uint32_t *captureId)
233 {
234     AUDIO_FUNC_LOGD("enter to %{public}s", __func__);
235     struct IAudioCaptureVdi *vdiCapture = NULL;
236 
237     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
238     CHECK_NULL_PTR_RETURN_VALUE(desc, HDF_ERR_INVALID_PARAM);
239     CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
240     CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
241     CHECK_NULL_PTR_RETURN_VALUE(captureId, HDF_ERR_INVALID_PARAM);
242     CHECK_VALID_RANGE_RETURN(*captureId, 0, AUDIO_VDI_STREAM_NUM_MAX - 1, HDF_ERR_INVALID_PARAM);
243 
244     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
245     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
246 
247     struct AudioDeviceDescriptorVdi vdiDesc;
248     struct AudioSampleAttributesVdi vdiAttrs;
249     (void)memset_s((void *)&vdiDesc, sizeof(vdiDesc), 0, sizeof(vdiDesc));
250     (void)memset_s((void *)&vdiAttrs, sizeof(vdiAttrs), 0, sizeof(vdiAttrs));
251     if (AudioCommonDevDescToVdiDevDescVdi(desc, &vdiDesc) != HDF_SUCCESS) {
252         return HDF_FAILURE;
253     }
254     AudioCommonAttrsToVdiAttrsVdi(attrs, &vdiAttrs);
255 
256     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->CreateCapture, HDF_ERR_INVALID_PARAM);
257     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->DestroyCapture, HDF_ERR_INVALID_PARAM);
258     pthread_mutex_lock(&g_adapterMutex);
259     int32_t id = SetTimer("Hdi:CreateCapture");
260     int32_t ret = vdiAdapter->CreateCapture(vdiAdapter, &vdiDesc, &vdiAttrs, &vdiCapture);
261     CancelTimer(id);
262     OsalMemFree((void *)vdiDesc.desc);
263     if (ret != HDF_SUCCESS) {
264         AUDIO_FUNC_LOGE("audio vdiAdapter call CreateCapture fail, ret=%{public}d", ret);
265         pthread_mutex_unlock(&g_adapterMutex);
266         return HDF_FAILURE;
267     }
268     vdiCapture->AddAudioEffect = NULL;
269     vdiCapture->RemoveAudioEffect = NULL;
270     vdiCapture->GetFrameBufferSize = NULL;
271     vdiCapture->IsSupportsPauseAndResume = NULL;
272     *capture = AudioCreateCaptureByIdVdi(attrs, captureId, vdiCapture, desc);
273     if (*capture == NULL) {
274         (void)vdiAdapter->DestroyCapture(vdiAdapter, vdiCapture);
275         AUDIO_FUNC_LOGE("create audio capture failed");
276         pthread_mutex_unlock(&g_adapterMutex);
277         return HDF_ERR_INVALID_PARAM;
278     }
279     AUDIO_FUNC_LOGI("AudioCreateCaptureVdi Success");
280     pthread_mutex_unlock(&g_adapterMutex);
281     return HDF_SUCCESS;
282 }
283 
AudioDestroyCaptureVdi(struct IAudioAdapter *adapter, uint32_t captureId)284 int32_t AudioDestroyCaptureVdi(struct IAudioAdapter *adapter, uint32_t captureId)
285 {
286     AUDIO_FUNC_LOGD("enter to %{public}s", __func__);
287     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
288     CHECK_VALID_RANGE_RETURN(captureId, 0, AUDIO_VDI_STREAM_NUM_MAX - 1, HDF_ERR_INVALID_PARAM);
289     if (DecreaseCaptureUsrCount(captureId) > 0) {
290         AUDIO_FUNC_LOGE("capture destroy: more than one usr");
291         return HDF_SUCCESS;
292     }
293 
294     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
295     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
296 
297     pthread_mutex_lock(&g_adapterMutex);
298     struct IAudioCaptureVdi *vdiCapture = AudioGetVdiCaptureByIdVdi(captureId);
299     if (vdiCapture == NULL || vdiAdapter->DestroyCapture == NULL) {
300         AUDIO_FUNC_LOGE("invalid parameter");
301         pthread_mutex_unlock(&g_adapterMutex);
302         return HDF_ERR_INVALID_PARAM;
303     }
304     int32_t ret = vdiAdapter->DestroyCapture(vdiAdapter, vdiCapture);
305     if (ret != HDF_SUCCESS) {
306         AUDIO_FUNC_LOGE("audio vdiAdapter call DestroyCapture fail, ret=%{public}d", ret);
307         pthread_mutex_unlock(&g_adapterMutex);
308         return HDF_FAILURE;
309     }
310 
311     AudioDestroyCaptureByIdVdi(captureId);
312     pthread_mutex_unlock(&g_adapterMutex);
313     return HDF_SUCCESS;
314 }
315 
AudioGetPortCapabilityVdi(struct IAudioAdapter *adapter, const struct AudioPort *port, struct AudioPortCapability* capability)316 int32_t AudioGetPortCapabilityVdi(struct IAudioAdapter *adapter, const struct AudioPort *port,
317     struct AudioPortCapability* capability)
318 {
319     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
320     CHECK_NULL_PTR_RETURN_VALUE(port, HDF_ERR_INVALID_PARAM);
321     CHECK_NULL_PTR_RETURN_VALUE(capability, HDF_ERR_INVALID_PARAM);
322 
323     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
324     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
325 
326     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->GetPortCapability, HDF_ERR_INVALID_PARAM);
327     struct AudioPortCapabilityVdi vdiCap;
328     struct AudioPortVdi vdiPort;
329     (void)memset_s(&vdiCap, sizeof(vdiCap), 0, sizeof(vdiCap));
330     (void)memset_s(&vdiPort, sizeof(vdiPort), 0, sizeof(vdiPort));
331 
332     int32_t ret = AudioCommonPortToVdiPortVdi(port, &vdiPort);
333     if (ret != HDF_SUCCESS) {
334         OsalMemFree((void *)vdiPort.portName);
335         AUDIO_FUNC_LOGE("audio vdiAdapter call PortCapToVdiPortCap fail, ret=%{public}d", ret);
336         return ret;
337     }
338 
339     ret = vdiAdapter->GetPortCapability(vdiAdapter, &vdiPort, &vdiCap);
340     OsalMemFree((void *)vdiPort.portName);
341     if (ret != HDF_SUCCESS) {
342         AUDIO_FUNC_LOGE("audio vdiAdapter call GetPortCapability fail, ret=%{public}d", ret);
343         return ret;
344     }
345 
346     AudioCommonVdiPortCapToPortCapVdi(&vdiCap, capability);
347     return HDF_SUCCESS;
348 }
349 
AudioSetPassthroughModeVdi(struct IAudioAdapter *adapter, const struct AudioPort *port, enum AudioPortPassthroughMode mode)350 int32_t AudioSetPassthroughModeVdi(struct IAudioAdapter *adapter, const struct AudioPort *port,
351     enum AudioPortPassthroughMode mode)
352 {
353     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
354     CHECK_NULL_PTR_RETURN_VALUE(port, HDF_ERR_INVALID_PARAM);
355 
356     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
357     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
358     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->SetPassthroughMode, HDF_ERR_INVALID_PARAM);
359 
360     struct AudioPortVdi vdiPort;
361     (void)memset_s((void *)&vdiPort, sizeof(vdiPort), 0, sizeof(vdiPort));
362     int32_t ret = AudioCommonPortToVdiPortVdi(port, &vdiPort);
363     if (ret != HDF_SUCCESS) {
364         OsalMemFree((void *)vdiPort.portName);
365         AUDIO_FUNC_LOGE("audio vdiAdapter call PortCapToVdiPortCap fail, ret=%{public}d", ret);
366         return ret;
367     }
368 
369     ret = vdiAdapter->SetPassthroughMode(vdiAdapter, &vdiPort, (enum AudioPortPassthroughModeVdi)mode);
370     OsalMemFree((void *)vdiPort.portName);
371     if (ret != HDF_SUCCESS) {
372         AUDIO_FUNC_LOGE("audio vdiAdapter call SetPassthroughMode fail, ret=%{public}d", ret);
373         return HDF_FAILURE;
374     }
375 
376     return HDF_SUCCESS;
377 }
378 
AudioGetPassthroughModeVdi(struct IAudioAdapter *adapter, const struct AudioPort *port, enum AudioPortPassthroughMode *mode)379 int32_t AudioGetPassthroughModeVdi(struct IAudioAdapter *adapter, const struct AudioPort *port,
380     enum AudioPortPassthroughMode *mode)
381 {
382     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
383     CHECK_NULL_PTR_RETURN_VALUE(port, HDF_ERR_INVALID_PARAM);
384     CHECK_NULL_PTR_RETURN_VALUE(mode, HDF_ERR_INVALID_PARAM);
385 
386     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
387     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
388     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->GetPassthroughMode, HDF_ERR_INVALID_PARAM);
389 
390     struct AudioPortVdi vdiPort;
391     (void)memset_s((void *)&vdiPort, sizeof(vdiPort), 0, sizeof(vdiPort));
392     int32_t ret = AudioCommonPortToVdiPortVdi(port, &vdiPort);
393     if (ret != HDF_SUCCESS) {
394         OsalMemFree((void *)vdiPort.portName);
395         AUDIO_FUNC_LOGE("audio vdiAdapter call PortCapToVdiPortCap fail, ret=%{public}d", ret);
396         return ret;
397     }
398 
399     ret = vdiAdapter->GetPassthroughMode(vdiAdapter, &vdiPort, (enum AudioPortPassthroughModeVdi *)mode);
400     OsalMemFree((void *)vdiPort.portName);
401     if (ret != HDF_SUCCESS) {
402         AUDIO_FUNC_LOGE("audio vdiAdapter call GetPassthroughMode fail, ret=%{public}d", ret);
403         return HDF_FAILURE;
404     }
405 
406     return HDF_SUCCESS;
407 }
408 
AudioGetDeviceStatusVdi(struct IAudioAdapter *adapter, struct AudioDeviceStatus *status)409 int32_t AudioGetDeviceStatusVdi(struct IAudioAdapter *adapter, struct AudioDeviceStatus *status)
410 {
411     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
412     CHECK_NULL_PTR_RETURN_VALUE(status, HDF_ERR_INVALID_PARAM);
413 
414     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
415     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
416     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->GetDeviceStatus, HDF_ERR_INVALID_PARAM);
417 
418     struct AudioDeviceStatusVdi vdiStatus;
419     (void)memset_s((void *)&vdiStatus, sizeof(vdiStatus), 0, sizeof(vdiStatus));
420     int32_t ret = vdiAdapter->GetDeviceStatus(vdiAdapter, &vdiStatus);
421     if (ret != HDF_SUCCESS) {
422         AUDIO_FUNC_LOGE("audio vdiAdapter call GetDeviceStatus fail, ret=%{public}d", ret);
423         return HDF_FAILURE;
424     }
425 
426     status->pnpStatus = vdiStatus.pnpStatus;
427     return HDF_SUCCESS;
428 }
429 
AudioUpdateAudioRouteVdi(struct IAudioAdapter *adapter, const struct AudioRoute *route, int32_t *routeHandle)430 int32_t AudioUpdateAudioRouteVdi(struct IAudioAdapter *adapter, const struct AudioRoute *route, int32_t *routeHandle)
431 {
432     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
433     CHECK_NULL_PTR_RETURN_VALUE(route, HDF_ERR_INVALID_PARAM);
434     CHECK_NULL_PTR_RETURN_VALUE(routeHandle, HDF_ERR_INVALID_PARAM);
435 
436     if (route->sinksLen == 0 && route->sourcesLen == 0) {
437         AUDIO_FUNC_LOGE("invalid route value");
438         return HDF_FAILURE;
439     }
440 
441     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
442     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
443     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->UpdateAudioRoute, HDF_ERR_INVALID_PARAM);
444 
445     struct AudioRouteVdi vdiRoute;
446     (void)memset_s(&vdiRoute, sizeof(vdiRoute), 0, sizeof(vdiRoute));
447 
448     int32_t ret = AudioCommonRouteToVdiRouteVdi(route, &vdiRoute);
449     if (ret != HDF_SUCCESS) {
450         AUDIO_FUNC_LOGE("audio vdiAdapter route To vdiRoute fail");
451         return HDF_FAILURE;
452     }
453 
454     ret = vdiAdapter->UpdateAudioRoute(vdiAdapter, &vdiRoute, routeHandle);
455     AudioCommonFreeVdiRouteVdi(&vdiRoute);
456     if (ret != HDF_SUCCESS) {
457         AUDIO_FUNC_LOGE("audio vdiAdapter call UpdateAudioRoute fail, ret=%{public}d", ret);
458         return HDF_FAILURE;
459     }
460 
461     return HDF_SUCCESS;
462 }
463 
AudioReleaseAudioRouteVdi(struct IAudioAdapter *adapter, int32_t routeHandle)464 int32_t AudioReleaseAudioRouteVdi(struct IAudioAdapter *adapter, int32_t routeHandle)
465 {
466     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
467 
468     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
469     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
470     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->ReleaseAudioRoute, HDF_ERR_INVALID_PARAM);
471 
472     int32_t ret = vdiAdapter->ReleaseAudioRoute(vdiAdapter, routeHandle);
473     if (ret != HDF_SUCCESS) {
474         AUDIO_FUNC_LOGE("audio vdiAdapter call ReleaseAudioRoute fail, ret=%{public}d", ret);
475         return HDF_FAILURE;
476     }
477 
478     return HDF_SUCCESS;
479 }
480 
AudioSetMicMuteVdi(struct IAudioAdapter *adapter, bool mute)481 int32_t AudioSetMicMuteVdi(struct IAudioAdapter *adapter, bool mute)
482 {
483     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
484 
485     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
486     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
487     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->SetMicMute, HDF_ERR_INVALID_PARAM);
488 
489     int32_t ret = vdiAdapter->SetMicMute(vdiAdapter, mute);
490     if (ret != HDF_SUCCESS) {
491         AUDIO_FUNC_LOGE("audio vdiAdapter call SetMicMute fail, ret=%{public}d", ret);
492         return HDF_FAILURE;
493     }
494 
495     return HDF_SUCCESS;
496 }
497 
AudioGetMicMuteVdi(struct IAudioAdapter *adapter, bool *mute)498 int32_t AudioGetMicMuteVdi(struct IAudioAdapter *adapter, bool *mute)
499 {
500     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
501     CHECK_NULL_PTR_RETURN_VALUE(mute, HDF_ERR_INVALID_PARAM);
502 
503     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
504     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
505     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->GetMicMute, HDF_ERR_INVALID_PARAM);
506 
507     int32_t ret = vdiAdapter->GetMicMute(vdiAdapter, mute);
508     if (ret != HDF_SUCCESS) {
509         AUDIO_FUNC_LOGE("audio vdiAdapter call GetMicMute fail, ret=%{public}d", ret);
510         return HDF_FAILURE;
511     }
512 
513     return HDF_SUCCESS;
514 }
515 
AudioSetVoiceVolumeVdi(struct IAudioAdapter *adapter, float volume)516 int32_t AudioSetVoiceVolumeVdi(struct IAudioAdapter *adapter, float volume)
517 {
518     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
519 
520     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
521     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
522     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->SetVoiceVolume, HDF_ERR_INVALID_PARAM);
523 
524     int32_t ret = vdiAdapter->SetVoiceVolume(vdiAdapter, volume);
525     if (ret != HDF_SUCCESS) {
526         AUDIO_FUNC_LOGE("audio vdiAdapter call SetVoiceVolume fail, ret=%{public}d", ret);
527         return HDF_FAILURE;
528     }
529 
530     return HDF_SUCCESS;
531 }
532 
AudioSetExtraParamsVdi(struct IAudioAdapter *adapter, enum AudioExtParamKey key, const char *condition, const char *value)533 int32_t AudioSetExtraParamsVdi(struct IAudioAdapter *adapter, enum AudioExtParamKey key, const char *condition,
534     const char *value)
535 {
536     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
537     CHECK_NULL_PTR_RETURN_VALUE(condition, HDF_ERR_INVALID_PARAM);
538     CHECK_NULL_PTR_RETURN_VALUE(value, HDF_ERR_INVALID_PARAM);
539 
540     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
541     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
542     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->SetExtraParams, HDF_ERR_INVALID_PARAM);
543 
544     int32_t ret = vdiAdapter->SetExtraParams(vdiAdapter, (enum AudioExtParamKeyVdi)key, condition, value);
545     if (ret != HDF_SUCCESS) {
546         AUDIO_FUNC_LOGE("audio vdiAdapter call SetExtraParams fail, ret=%{public}d", ret);
547         return HDF_FAILURE;
548     }
549 
550     return HDF_SUCCESS;
551 }
552 
AudioGetExtraParamsVdi(struct IAudioAdapter *adapter, enum AudioExtParamKey key, const char *condition, char *value, uint32_t valueLen)553 int32_t AudioGetExtraParamsVdi(struct IAudioAdapter *adapter, enum AudioExtParamKey key, const char *condition,
554     char *value, uint32_t valueLen)
555 {
556     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
557     CHECK_NULL_PTR_RETURN_VALUE(condition, HDF_ERR_INVALID_PARAM);
558     CHECK_NULL_PTR_RETURN_VALUE(value, HDF_ERR_INVALID_PARAM);
559 
560     struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
561     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter, HDF_ERR_INVALID_PARAM);
562     CHECK_NULL_PTR_RETURN_VALUE(vdiAdapter->GetExtraParams, HDF_ERR_INVALID_PARAM);
563 
564     int32_t ret = vdiAdapter->GetExtraParams(vdiAdapter, (enum AudioExtParamKeyVdi)key, condition, value,
565         (int32_t)valueLen);
566     if (ret != HDF_SUCCESS) {
567         AUDIO_FUNC_LOGE("audio vdiAdapter call GetExtraParams fail, ret=%{public}d", ret);
568         return HDF_FAILURE;
569     }
570 
571     return HDF_SUCCESS;
572 }
573 
AudioInitAdapterInstanceVdi(struct IAudioAdapter *adapter)574 static void AudioInitAdapterInstanceVdi(struct IAudioAdapter *adapter)
575 {
576     adapter->InitAllPorts = AudioInitAllPortsVdi;
577     adapter->CreateRender = AudioCreateRenderVdi;
578     adapter->DestroyRender = AudioDestroyRenderVdi;
579     adapter->CreateCapture = AudioCreateCaptureVdi;
580     adapter->DestroyCapture = AudioDestroyCaptureVdi;
581 
582     adapter->GetPortCapability = AudioGetPortCapabilityVdi;
583     adapter->SetPassthroughMode = AudioSetPassthroughModeVdi;
584     adapter->GetPassthroughMode = AudioGetPassthroughModeVdi;
585     adapter->GetDeviceStatus = AudioGetDeviceStatusVdi;
586     adapter->UpdateAudioRoute = AudioUpdateAudioRouteVdi;
587 
588     adapter->ReleaseAudioRoute = AudioReleaseAudioRouteVdi;
589     adapter->SetMicMute = AudioSetMicMuteVdi;
590     adapter->GetMicMute = AudioGetMicMuteVdi;
591     adapter->SetVoiceVolume = AudioSetVoiceVolumeVdi;
592     adapter->SetExtraParams = AudioSetExtraParamsVdi;
593 
594     adapter->GetExtraParams = AudioGetExtraParamsVdi;
595 }
596 
AudioGetAdapterRefCntVdi(uint32_t descIndex)597 uint32_t AudioGetAdapterRefCntVdi(uint32_t descIndex)
598 {
599     if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
600         AUDIO_FUNC_LOGE("get adapter ref error, descIndex=%{public}d", descIndex);
601         return UINT_MAX;
602     }
603 
604     struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
605     return priv->adapterInfo[descIndex].refCnt;
606 }
607 
AudioIncreaseAdapterRefVdi(uint32_t descIndex, struct IAudioAdapter **adapter)608 int32_t AudioIncreaseAdapterRefVdi(uint32_t descIndex, struct IAudioAdapter **adapter)
609 {
610     CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
611     if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
612         AUDIO_FUNC_LOGE("increase adapter ref error, descIndex=%{public}d", descIndex);
613         return HDF_ERR_INVALID_PARAM;
614     }
615 
616     struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
617     if (priv->adapterInfo[descIndex].adapter == NULL) {
618         AUDIO_FUNC_LOGE("Invalid adapter param!");
619         return HDF_ERR_INVALID_PARAM;
620     }
621 
622     priv->adapterInfo[descIndex].refCnt++;
623     *adapter = priv->adapterInfo[descIndex].adapter;
624     AUDIO_FUNC_LOGI("increase adapternameIndex[%{public}d], refCount[%{public}d]", descIndex,
625         priv->adapterInfo[descIndex].refCnt);
626 
627     return HDF_SUCCESS;
628 }
629 
AudioDecreaseAdapterRefVdi(uint32_t descIndex)630 void AudioDecreaseAdapterRefVdi(uint32_t descIndex)
631 {
632     if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
633         AUDIO_FUNC_LOGE("decrease adapter ref error, descIndex=%{public}d", descIndex);
634     }
635 
636     struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
637     if (priv->adapterInfo[descIndex].refCnt == 0) {
638         AUDIO_FUNC_LOGE("Invalid adapterInfo[%{public}d] had released", descIndex);
639         return;
640     }
641     priv->adapterInfo[descIndex].refCnt--;
642     AUDIO_FUNC_LOGI("decrease adapternameIndex[%{public}d], refCount[%{public}d]", descIndex,
643         priv->adapterInfo[descIndex].refCnt);
644 }
645 
AudioEnforceClearAdapterRefCntVdi(uint32_t descIndex)646 void AudioEnforceClearAdapterRefCntVdi(uint32_t descIndex)
647 {
648     if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
649         AUDIO_FUNC_LOGE("decrease adapter descIndex error, descIndex=%{public}d", descIndex);
650     }
651 
652     struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
653     priv->adapterInfo[descIndex].refCnt = 0;
654     AUDIO_FUNC_LOGI("clear adapter ref count zero");
655 }
656 
AudioCreateAdapterVdi(uint32_t descIndex, struct IAudioAdapterVdi *vdiAdapter, char *adapterName)657 struct IAudioAdapter *AudioCreateAdapterVdi(uint32_t descIndex, struct IAudioAdapterVdi *vdiAdapter,
658     char *adapterName)
659 {
660     if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
661         AUDIO_FUNC_LOGE("create adapter error, descIndex=%{public}d", descIndex);
662         return NULL;
663     }
664 
665     if (vdiAdapter == NULL) {
666         AUDIO_FUNC_LOGE("audio vdiAdapter is null");
667         return NULL;
668     }
669 
670     struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
671     struct IAudioAdapter *adapter = priv->adapterInfo[descIndex].adapter;
672     if (adapter != NULL) {
673         return adapter;
674     }
675 
676     adapter = (struct IAudioAdapter *)OsalMemCalloc(sizeof(struct IAudioAdapter));
677     if (adapter == NULL) {
678         AUDIO_FUNC_LOGE("OsalMemCalloc adapter fail");
679         return NULL;
680     }
681 
682     AudioInitAdapterInstanceVdi(adapter);
683     priv->adapterInfo[descIndex].vdiAdapter = vdiAdapter;
684     priv->adapterInfo[descIndex].adapter = adapter;
685     priv->adapterInfo[descIndex].refCnt = 1;
686     priv->adapterInfo[descIndex].adapterName = strdup(adapterName);
687     if (priv->adapterInfo[descIndex].adapterName == NULL) {
688         OsalMemFree((void *)priv->adapterInfo[descIndex].adapter);
689         priv->adapterInfo[descIndex].adapter = NULL;
690         return NULL;
691     }
692 
693     AUDIO_FUNC_LOGD(" audio vdiAdapter create adapter success, refcount[1]");
694     return adapter;
695 }
696 
AudioReleaseAdapterVdi(uint32_t descIndex)697 void AudioReleaseAdapterVdi(uint32_t descIndex)
698 {
699     if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
700         AUDIO_FUNC_LOGE("adapter release fail descIndex=%{public}d", descIndex);
701         return;
702     }
703 
704     struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
705 
706     OsalMemFree((void *)priv->adapterInfo[descIndex].adapter);
707     priv->adapterInfo[descIndex].adapter = NULL;
708     priv->adapterInfo[descIndex].vdiAdapter = NULL;
709     priv->adapterInfo[descIndex].refCnt = UINT_MAX;
710     OsalMemFree((void *)priv->adapterInfo[descIndex].adapterName);
711     priv->adapterInfo[descIndex].adapterName = NULL;
712 
713     priv->isRegCb = false;
714     priv->callback = NULL;
715 
716     AUDIO_FUNC_LOGD(" audio vdiAdapter release adapter success");
717 }
718 
InitAdapterMutex(void)719 int32_t InitAdapterMutex(void)
720 {
721     if (pthread_mutex_init(&g_adapterMutex, NULL) != HDF_SUCCESS) {
722         AUDIO_FUNC_LOGE("init g_adapterMutex failed.");
723         return HDF_FAILURE;
724     }
725     return HDF_SUCCESS;
726 }
727 
DeinitAdapterMutex(void)728 void DeinitAdapterMutex(void)
729 {
730     pthread_mutex_destroy(&g_adapterMutex);
731 }
732