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