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_rwlock_t g_rwAdapterLock = PTHREAD_RWLOCK_INITIALIZER;
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 static int32_t AudioInitAllPortsVdi(struct IAudioAdapter *adapter)
104 {
105 pthread_rwlock_rdlock(&g_rwAdapterLock);
106 int32_t ret = HDF_SUCCESS;
107 if (adapter == NULL) {
108 AUDIO_FUNC_LOGE("invalid param");
109 ret = HDF_ERR_INVALID_PARAM;
110 goto EXIT;
111 }
112
113 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
114 if (vdiAdapter == NULL || vdiAdapter->InitAllPorts == NULL) {
115 AUDIO_FUNC_LOGE("invalid param");
116 ret = HDF_ERR_INVALID_PARAM;
117 goto EXIT;
118 }
119 ret = vdiAdapter->InitAllPorts(vdiAdapter);
120 if (ret != HDF_SUCCESS) {
121 AUDIO_FUNC_LOGE("audio vdiAdapter InitAllPorts fail, ret=%{public}d", ret);
122 ret = HDF_FAILURE;
123 goto EXIT;
124 }
125 EXIT:
126 pthread_rwlock_unlock(&g_rwAdapterLock);
127 return ret;
128 }
129
VerifyParamsOfAudioCreateRenderVdi(struct IAudioAdapter * adapter,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,struct IAudioRender ** render,uint32_t * renderId)130 static int32_t VerifyParamsOfAudioCreateRenderVdi(struct IAudioAdapter *adapter,
131 const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs,
132 struct IAudioRender **render, uint32_t *renderId)
133 {
134 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
135 CHECK_NULL_PTR_RETURN_VALUE(desc, HDF_ERR_INVALID_PARAM);
136 CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
137 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
138 CHECK_NULL_PTR_RETURN_VALUE(renderId, HDF_ERR_INVALID_PARAM);
139
140 if (desc->pins == PIN_OUT_LINEOUT || desc->pins == PIN_NONE || desc->pins >= PIN_IN_MIC) {
141 AUDIO_FUNC_LOGE("invalid pin [%{public}d]", desc->pins);
142 return HDF_FAILURE;
143 }
144 return HDF_SUCCESS;
145 }
146
CreateRenderPre(struct IAudioAdapterVdi * vdiAdapter,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,uint32_t * renderId,struct IAudioRenderVdi ** vdiRender)147 static int32_t CreateRenderPre(struct IAudioAdapterVdi *vdiAdapter,
148 const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs,
149 uint32_t *renderId, struct IAudioRenderVdi **vdiRender)
150 {
151 struct AudioDeviceDescriptorVdi vdiDesc;
152 struct AudioSampleAttributesVdi vdiAttrs;
153 if (AudioCommonDevDescToVdiDevDescVdi(desc, &vdiDesc) != HDF_SUCCESS) {
154 AUDIO_FUNC_LOGE("desc to vdiDesc fail");
155 return HDF_FAILURE;
156 }
157 AudioCommonAttrsToVdiAttrsVdi(attrs, &vdiAttrs);
158
159 int32_t id = SetTimer("Hdi:CreateRender");
160 pthread_rwlock_wrlock(GetRenderLock());
161 int32_t ret = vdiAdapter->CreateRender(vdiAdapter, &vdiDesc, &vdiAttrs, vdiRender);
162 pthread_rwlock_unlock(GetRenderLock());
163 CancelTimer(id);
164 OsalMemFree((void *)vdiDesc.desc);
165 if (ret != HDF_SUCCESS) {
166 AUDIO_FUNC_LOGE("audio vdiAdapter call CreateRender fail, ret=%{public}d", ret);
167 return ret;
168 }
169 (*vdiRender)->AddAudioEffect = NULL;
170 (*vdiRender)->RemoveAudioEffect = NULL;
171 (*vdiRender)->GetFrameBufferSize = NULL;
172 (*vdiRender)->IsSupportsPauseAndResume = NULL;
173
174 return HDF_SUCCESS;
175 }
176
AudioCreateRenderVdi(struct IAudioAdapter * adapter,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,struct IAudioRender ** render,uint32_t * renderId)177 static int32_t AudioCreateRenderVdi(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc,
178 const struct AudioSampleAttributes *attrs, struct IAudioRender **render, uint32_t *renderId)
179 {
180 pthread_rwlock_rdlock(&g_rwAdapterLock);
181 AUDIO_FUNC_LOGD("enter to %{public}s", __func__);
182
183 int32_t ret = VerifyParamsOfAudioCreateRenderVdi(adapter, desc, attrs, render, renderId);
184 if (ret != HDF_SUCCESS) {
185 AUDIO_FUNC_LOGE("invalid param");
186 goto EXIT;
187 }
188
189 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
190 if (vdiAdapter == NULL || vdiAdapter->CreateRender == NULL || vdiAdapter->DestroyRender == NULL) {
191 AUDIO_FUNC_LOGE("invalid param");
192 ret = HDF_ERR_INVALID_PARAM;
193 goto EXIT;
194 }
195
196 char *adapterName = AudioGetAdapterNameVdi(adapter);
197 *render = FindRenderCreated(desc->pins, attrs, renderId, adapterName);
198 if (*render != NULL) {
199 AUDIO_FUNC_LOGE("already created");
200 ret = HDF_SUCCESS;
201 goto EXIT;
202 }
203 struct IAudioRenderVdi *vdiRender = NULL;
204 ret = CreateRenderPre(vdiAdapter, desc, attrs, renderId, &vdiRender);
205 if (ret != HDF_SUCCESS) {
206 AUDIO_FUNC_LOGE("CreateRenderPre failed, ret = [%{public}d]", ret);
207 goto EXIT;
208 }
209 *render = AudioCreateRenderByIdVdi(attrs, renderId, vdiRender, desc, adapterName);
210 if (*render == NULL) {
211 (void)vdiAdapter->DestroyRender(vdiAdapter, vdiRender);
212 AUDIO_FUNC_LOGE("Create audio render failed");
213 ret = HDF_FAILURE;
214 goto EXIT;
215 }
216 AUDIO_FUNC_LOGI("AudioCreateRenderVdi Success, renderId = [%{public}u]", *renderId);
217 EXIT:
218 pthread_rwlock_unlock(&g_rwAdapterLock);
219 return ret;
220 }
221
AudioDestroyRenderVdi(struct IAudioAdapter * adapter,uint32_t renderId)222 static int32_t AudioDestroyRenderVdi(struct IAudioAdapter *adapter, uint32_t renderId)
223 {
224 pthread_rwlock_rdlock(&g_rwAdapterLock);
225 AUDIO_FUNC_LOGD("enter to %{public}s", __func__);
226 int32_t ret = HDF_SUCCESS;
227 if (adapter == NULL) {
228 AUDIO_FUNC_LOGE("invalid param");
229 ret = HDF_ERR_INVALID_PARAM;
230 goto EXIT;
231 }
232 if (renderId < 0 || renderId > AUDIO_VDI_STREAM_NUM_MAX - 1) {
233 AUDIO_FUNC_LOGE("renderId is invalid[%{public}u] and return ret=%{public}d", renderId, ret);
234 ret = HDF_ERR_INVALID_PARAM;
235 goto EXIT;
236 }
237 if (DecreaseRenderUsrCount(renderId) > 0) {
238 AUDIO_FUNC_LOGE("render destroy: more than one usr");
239 ret = HDF_SUCCESS;
240 goto EXIT;
241 }
242 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
243 if (vdiAdapter == NULL) {
244 AUDIO_FUNC_LOGE("invalid param");
245 ret = HDF_ERR_INVALID_PARAM;
246 goto EXIT;
247 }
248
249 struct IAudioRenderVdi *vdiRender = AudioGetVdiRenderByIdVdi(renderId);
250 if (vdiRender == NULL) {
251 AUDIO_FUNC_LOGE("vdiRender pointer is null");
252 ret = HDF_ERR_INVALID_PARAM;
253 goto EXIT;
254 }
255 if (vdiAdapter->DestroyRender == NULL) {
256 AUDIO_FUNC_LOGE("invalid param");
257 ret = HDF_ERR_INVALID_PARAM;
258 goto EXIT;
259 }
260 pthread_rwlock_wrlock(GetRenderLock());
261 ret = vdiAdapter->DestroyRender(vdiAdapter, vdiRender);
262 pthread_rwlock_unlock(GetRenderLock());
263 if (ret != HDF_SUCCESS) {
264 AUDIO_FUNC_LOGE("audio vdiAdapter call DestroyRender fail, ret=%{public}d", ret);
265 ret = HDF_FAILURE;
266 goto EXIT;
267 }
268 AudioDestroyRenderByIdVdi(renderId);
269 EXIT:
270 pthread_rwlock_unlock(&g_rwAdapterLock);
271 return ret;
272 }
273
CreateCapturePre(struct IAudioAdapterVdi * vdiAdapter,struct IAudioCapture ** capture,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,uint32_t * captureId)274 static int32_t CreateCapturePre(struct IAudioAdapterVdi *vdiAdapter, struct IAudioCapture **capture,
275 const struct AudioDeviceDescriptor *desc, const struct AudioSampleAttributes *attrs, uint32_t *captureId)
276 {
277 struct IAudioCaptureVdi *vdiCapture = NULL;
278 struct AudioDeviceDescriptorVdi vdiDesc;
279 struct AudioSampleAttributesVdi vdiAttrs;
280 (void)memset_s((void *)&vdiDesc, sizeof(vdiDesc), 0, sizeof(vdiDesc));
281 (void)memset_s((void *)&vdiAttrs, sizeof(vdiAttrs), 0, sizeof(vdiAttrs));
282 if (AudioCommonDevDescToVdiDevDescVdi(desc, &vdiDesc) != HDF_SUCCESS) {
283 AUDIO_FUNC_LOGE("Desc to VdiDesc fail");
284 return HDF_FAILURE;
285 }
286 AudioCommonAttrsToVdiAttrsVdi(attrs, &vdiAttrs);
287
288 if (vdiAdapter == NULL || vdiAdapter->CreateCapture == NULL || vdiAdapter->DestroyCapture == NULL) {
289 AUDIO_FUNC_LOGE("invalid param");
290 return HDF_ERR_INVALID_PARAM;
291 }
292 int32_t id = SetTimer("Hdi:CreateCapture");
293 pthread_rwlock_wrlock(GetCaptureLock());
294 int32_t ret = vdiAdapter->CreateCapture(vdiAdapter, &vdiDesc, &vdiAttrs, &vdiCapture);
295 pthread_rwlock_unlock(GetCaptureLock());
296 CancelTimer(id);
297 OsalMemFree((void *)vdiDesc.desc);
298 if (ret != HDF_SUCCESS) {
299 AUDIO_FUNC_LOGE("audio vdiAdapter call CreateCapture fail, ret=%{public}d", ret);
300 return HDF_FAILURE;
301 }
302 vdiCapture->AddAudioEffect = NULL;
303 vdiCapture->RemoveAudioEffect = NULL;
304 vdiCapture->GetFrameBufferSize = NULL;
305 vdiCapture->IsSupportsPauseAndResume = NULL;
306 *capture = AudioCreateCaptureByIdVdi(attrs, captureId, vdiCapture, desc);
307 if (*capture == NULL) {
308 (void)vdiAdapter->DestroyCapture(vdiAdapter, vdiCapture);
309 AUDIO_FUNC_LOGE("create audio capture failed");
310 return HDF_ERR_INVALID_PARAM;
311 }
312 return HDF_SUCCESS;
313 }
314
AudioCreateCaptureVdi(struct IAudioAdapter * adapter,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,struct IAudioCapture ** capture,uint32_t * captureId)315 static int32_t AudioCreateCaptureVdi(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc,
316 const struct AudioSampleAttributes *attrs, struct IAudioCapture **capture, uint32_t *captureId)
317 {
318 pthread_rwlock_rdlock(&g_rwAdapterLock);
319 AUDIO_FUNC_LOGD("enter to %{public}s", __func__);
320 int32_t ret = HDF_SUCCESS;
321 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
322 if (vdiAdapter == NULL || desc == NULL || attrs == NULL || capture == NULL || captureId == NULL) {
323 AUDIO_FUNC_LOGE("invalid param");
324 ret = HDF_ERR_INVALID_PARAM;
325 goto EXIT;
326 }
327 ret = CreateCapturePre(vdiAdapter, capture, desc, attrs, captureId);
328 if (*capture == NULL || ret != HDF_SUCCESS) {
329 AUDIO_FUNC_LOGE("create audio capture failed");
330 goto EXIT;
331 }
332 AUDIO_FUNC_LOGI("AudioCreateCaptureVdi Success, captureId = [%{public}u]", *captureId);
333 EXIT:
334 pthread_rwlock_unlock(&g_rwAdapterLock);
335 return ret;
336 }
337
AudioDestroyCaptureVdi(struct IAudioAdapter * adapter,uint32_t captureId)338 static int32_t AudioDestroyCaptureVdi(struct IAudioAdapter *adapter, uint32_t captureId)
339 {
340 pthread_rwlock_rdlock(&g_rwAdapterLock);
341 AUDIO_FUNC_LOGD("enter to %{public}s", __func__);
342 int32_t ret = HDF_SUCCESS;
343 if (adapter == NULL) {
344 AUDIO_FUNC_LOGE("invalid param");
345 ret = HDF_ERR_INVALID_PARAM;
346 goto EXIT;
347 }
348 if (captureId < 0 || captureId > AUDIO_VDI_STREAM_NUM_MAX - 1) {
349 AUDIO_FUNC_LOGE("captureId is invalid[%{public}u] and return ret=%{public}d", captureId, ret);
350 ret = HDF_ERR_INVALID_PARAM;
351 goto EXIT;
352 }
353 if (DecreaseCaptureUsrCount(captureId) > 0) {
354 AUDIO_FUNC_LOGE("capture destroy: more than one usr");
355 ret = HDF_SUCCESS;
356 goto EXIT;
357 }
358
359 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
360 if (vdiAdapter == NULL) {
361 AUDIO_FUNC_LOGE("invalid param");
362 ret = HDF_ERR_INVALID_PARAM;
363 goto EXIT;
364 }
365
366 struct IAudioCaptureVdi *vdiCapture = AudioGetVdiCaptureByIdVdi(captureId);
367 if (vdiCapture == NULL || vdiAdapter->DestroyCapture == NULL) {
368 AUDIO_FUNC_LOGE("invalid parameter");
369 ret = HDF_ERR_INVALID_PARAM;
370 goto EXIT;
371 }
372 pthread_rwlock_wrlock(GetCaptureLock());
373 ret = vdiAdapter->DestroyCapture(vdiAdapter, vdiCapture);
374 pthread_rwlock_unlock(GetCaptureLock());
375 if (ret != HDF_SUCCESS) {
376 AUDIO_FUNC_LOGE("audio vdiAdapter call DestroyCapture fail, ret=%{public}d", ret);
377 ret = HDF_FAILURE;
378 goto EXIT;
379 }
380 AudioDestroyCaptureByIdVdi(captureId);
381 EXIT:
382 pthread_rwlock_unlock(&g_rwAdapterLock);
383 return ret;
384 }
385
AudioGetPortCapabilityVdi(struct IAudioAdapter * adapter,const struct AudioPort * port,struct AudioPortCapability * capability)386 static int32_t AudioGetPortCapabilityVdi(struct IAudioAdapter *adapter, const struct AudioPort *port,
387 struct AudioPortCapability* capability)
388 {
389 pthread_rwlock_rdlock(&g_rwAdapterLock);
390 int32_t ret = HDF_SUCCESS;
391 if (adapter == NULL || port == NULL || capability == NULL) {
392 AUDIO_FUNC_LOGE("invalid param");
393 ret = HDF_ERR_INVALID_PARAM;
394 goto EXIT;
395 }
396
397 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
398 if (vdiAdapter == NULL || vdiAdapter->GetPortCapability == NULL) {
399 AUDIO_FUNC_LOGE("invalid param");
400 ret = HDF_ERR_INVALID_PARAM;
401 goto EXIT;
402 }
403 struct AudioPortCapabilityVdi vdiCap;
404 struct AudioPortVdi vdiPort;
405 (void)memset_s(&vdiCap, sizeof(vdiCap), 0, sizeof(vdiCap));
406 (void)memset_s(&vdiPort, sizeof(vdiPort), 0, sizeof(vdiPort));
407
408 ret = AudioCommonPortToVdiPortVdi(port, &vdiPort);
409 if (ret != HDF_SUCCESS) {
410 OsalMemFree((void *)vdiPort.portName);
411 AUDIO_FUNC_LOGE("audio vdiAdapter call PortCapToVdiPortCap fail, ret=%{public}d", ret);
412 goto EXIT;
413 }
414
415 ret = vdiAdapter->GetPortCapability(vdiAdapter, &vdiPort, &vdiCap);
416 OsalMemFree((void *)vdiPort.portName);
417 if (ret != HDF_SUCCESS) {
418 AUDIO_FUNC_LOGE("audio vdiAdapter call GetPortCapability fail, ret=%{public}d", ret);
419 goto EXIT;
420 }
421
422 AudioCommonVdiPortCapToPortCapVdi(&vdiCap, capability);
423 EXIT:
424 pthread_rwlock_unlock(&g_rwAdapterLock);
425 return ret;
426 }
427
AudioSetPassthroughModeVdi(struct IAudioAdapter * adapter,const struct AudioPort * port,enum AudioPortPassthroughMode mode)428 static int32_t AudioSetPassthroughModeVdi(struct IAudioAdapter *adapter, const struct AudioPort *port,
429 enum AudioPortPassthroughMode mode)
430 {
431 pthread_rwlock_rdlock(&g_rwAdapterLock);
432 int32_t ret = HDF_SUCCESS;
433 if (adapter == NULL || port == NULL) {
434 AUDIO_FUNC_LOGE("invalid param");
435 ret = HDF_ERR_INVALID_PARAM;
436 goto EXIT;
437 }
438
439 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
440 if (vdiAdapter == NULL || vdiAdapter->SetPassthroughMode == NULL) {
441 AUDIO_FUNC_LOGE("invalid param");
442 ret = HDF_ERR_INVALID_PARAM;
443 goto EXIT;
444 }
445
446 struct AudioPortVdi vdiPort;
447 (void)memset_s((void *)&vdiPort, sizeof(vdiPort), 0, sizeof(vdiPort));
448 ret = AudioCommonPortToVdiPortVdi(port, &vdiPort);
449 if (ret != HDF_SUCCESS) {
450 OsalMemFree((void *)vdiPort.portName);
451 AUDIO_FUNC_LOGE("audio vdiAdapter call PortCapToVdiPortCap fail, ret=%{public}d", ret);
452 goto EXIT;
453 }
454
455 ret = vdiAdapter->SetPassthroughMode(vdiAdapter, &vdiPort, (enum AudioPortPassthroughModeVdi)mode);
456 OsalMemFree((void *)vdiPort.portName);
457 if (ret != HDF_SUCCESS) {
458 AUDIO_FUNC_LOGE("audio vdiAdapter call SetPassthroughMode fail, ret=%{public}d", ret);
459 ret = HDF_FAILURE;
460 goto EXIT;
461 }
462
463 EXIT:
464 pthread_rwlock_unlock(&g_rwAdapterLock);
465 return ret;
466 }
467
AudioGetPassthroughModeVdi(struct IAudioAdapter * adapter,const struct AudioPort * port,enum AudioPortPassthroughMode * mode)468 static int32_t AudioGetPassthroughModeVdi(struct IAudioAdapter *adapter, const struct AudioPort *port,
469 enum AudioPortPassthroughMode *mode)
470 {
471 pthread_rwlock_rdlock(&g_rwAdapterLock);
472 int32_t ret = HDF_SUCCESS;
473 if (adapter == NULL || port == NULL || mode == NULL) {
474 AUDIO_FUNC_LOGE("invalid param");
475 ret = HDF_ERR_INVALID_PARAM;
476 goto EXIT;
477 }
478
479 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
480 if (vdiAdapter == NULL || vdiAdapter->GetPassthroughMode == NULL) {
481 AUDIO_FUNC_LOGE("invalid param");
482 ret = HDF_ERR_INVALID_PARAM;
483 goto EXIT;
484 }
485
486 struct AudioPortVdi vdiPort;
487 (void)memset_s((void *)&vdiPort, sizeof(vdiPort), 0, sizeof(vdiPort));
488 ret = AudioCommonPortToVdiPortVdi(port, &vdiPort);
489 if (ret != HDF_SUCCESS) {
490 OsalMemFree((void *)vdiPort.portName);
491 AUDIO_FUNC_LOGE("audio vdiAdapter call PortCapToVdiPortCap fail, ret=%{public}d", ret);
492 goto EXIT;
493 }
494
495 ret = vdiAdapter->GetPassthroughMode(vdiAdapter, &vdiPort, (enum AudioPortPassthroughModeVdi *)mode);
496 OsalMemFree((void *)vdiPort.portName);
497 if (ret != HDF_SUCCESS) {
498 AUDIO_FUNC_LOGE("audio vdiAdapter call GetPassthroughMode fail, ret=%{public}d", ret);
499 ret = HDF_FAILURE;
500 goto EXIT;
501 }
502
503 EXIT:
504 pthread_rwlock_unlock(&g_rwAdapterLock);
505 return ret;
506 }
507
AudioGetDeviceStatusVdi(struct IAudioAdapter * adapter,struct AudioDeviceStatus * status)508 static int32_t AudioGetDeviceStatusVdi(struct IAudioAdapter *adapter, struct AudioDeviceStatus *status)
509 {
510 pthread_rwlock_rdlock(&g_rwAdapterLock);
511 int32_t ret = HDF_SUCCESS;
512 if (adapter == NULL || status == NULL) {
513 AUDIO_FUNC_LOGE("invalid param");
514 ret = HDF_ERR_INVALID_PARAM;
515 goto EXIT;
516 }
517
518 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
519 if (vdiAdapter == NULL || vdiAdapter->GetDeviceStatus == NULL) {
520 AUDIO_FUNC_LOGE("invalid param");
521 ret = HDF_ERR_INVALID_PARAM;
522 goto EXIT;
523 }
524
525 struct AudioDeviceStatusVdi vdiStatus;
526 (void)memset_s((void *)&vdiStatus, sizeof(vdiStatus), 0, sizeof(vdiStatus));
527 ret = vdiAdapter->GetDeviceStatus(vdiAdapter, &vdiStatus);
528 if (ret != HDF_SUCCESS) {
529 AUDIO_FUNC_LOGE("audio vdiAdapter call GetDeviceStatus fail, ret=%{public}d", ret);
530 ret = HDF_FAILURE;
531 goto EXIT;
532 }
533
534 status->pnpStatus = vdiStatus.pnpStatus;
535 EXIT:
536 pthread_rwlock_unlock(&g_rwAdapterLock);
537 return ret;
538 }
539
AudioUpdateAudioRouteVdi(struct IAudioAdapter * adapter,const struct AudioRoute * route,int32_t * routeHandle)540 static int32_t AudioUpdateAudioRouteVdi(struct IAudioAdapter *adapter,
541 const struct AudioRoute *route, int32_t *routeHandle)
542 {
543 pthread_rwlock_rdlock(&g_rwAdapterLock);
544 int32_t ret = HDF_SUCCESS;
545 if (adapter == NULL || route == NULL || routeHandle == NULL) {
546 AUDIO_FUNC_LOGE("invalid param");
547 ret = HDF_ERR_INVALID_PARAM;
548 goto EXIT;
549 }
550
551 if (route->sinksLen == 0 && route->sourcesLen == 0) {
552 AUDIO_FUNC_LOGE("invalid route value");
553 ret = HDF_FAILURE;
554 goto EXIT;
555 }
556
557 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
558 if (vdiAdapter == NULL || vdiAdapter->UpdateAudioRoute == NULL) {
559 AUDIO_FUNC_LOGE("invalid param");
560 ret = HDF_ERR_INVALID_PARAM;
561 goto EXIT;
562 }
563
564 struct AudioRouteVdi vdiRoute;
565 (void)memset_s(&vdiRoute, sizeof(vdiRoute), 0, sizeof(vdiRoute));
566
567 ret = AudioCommonRouteToVdiRouteVdi(route, &vdiRoute);
568 if (ret != HDF_SUCCESS) {
569 AUDIO_FUNC_LOGE("audio vdiAdapter route To vdiRoute fail");
570 goto EXIT;
571 }
572
573 ret = vdiAdapter->UpdateAudioRoute(vdiAdapter, &vdiRoute, routeHandle);
574 AudioCommonFreeVdiRouteVdi(&vdiRoute);
575 if (ret != HDF_SUCCESS) {
576 AUDIO_FUNC_LOGE("audio vdiAdapter call UpdateAudioRoute fail, ret=%{public}d", ret);
577 ret = HDF_FAILURE;
578 goto EXIT;
579 }
580
581 EXIT:
582 pthread_rwlock_unlock(&g_rwAdapterLock);
583 return ret;
584 }
585
AudioReleaseAudioRouteVdi(struct IAudioAdapter * adapter,int32_t routeHandle)586 static int32_t AudioReleaseAudioRouteVdi(struct IAudioAdapter *adapter, int32_t routeHandle)
587 {
588 pthread_rwlock_rdlock(&g_rwAdapterLock);
589 int32_t ret = HDF_SUCCESS;
590 if (adapter == NULL) {
591 AUDIO_FUNC_LOGE("invalid param");
592 ret = HDF_ERR_INVALID_PARAM;
593 goto EXIT;
594 }
595
596 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
597 if (vdiAdapter == NULL || vdiAdapter->ReleaseAudioRoute == NULL) {
598 AUDIO_FUNC_LOGE("invalid param");
599 ret = HDF_ERR_INVALID_PARAM;
600 goto EXIT;
601 }
602
603 ret = vdiAdapter->ReleaseAudioRoute(vdiAdapter, routeHandle);
604 if (ret != HDF_SUCCESS) {
605 AUDIO_FUNC_LOGE("audio vdiAdapter call ReleaseAudioRoute fail, ret=%{public}d", ret);
606 ret = HDF_FAILURE;
607 goto EXIT;
608 }
609
610 EXIT:
611 pthread_rwlock_unlock(&g_rwAdapterLock);
612 return ret;
613 }
614
AudioSetMicMuteVdi(struct IAudioAdapter * adapter,bool mute)615 static int32_t AudioSetMicMuteVdi(struct IAudioAdapter *adapter, bool mute)
616 {
617 pthread_rwlock_rdlock(&g_rwAdapterLock);
618 int32_t ret = HDF_SUCCESS;
619 if (adapter == NULL) {
620 AUDIO_FUNC_LOGE("invalid param");
621 ret = HDF_ERR_INVALID_PARAM;
622 goto EXIT;
623 }
624
625 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
626 if (vdiAdapter == NULL || vdiAdapter->SetMicMute == NULL) {
627 AUDIO_FUNC_LOGE("invalid param");
628 ret = HDF_ERR_INVALID_PARAM;
629 goto EXIT;
630 }
631
632 ret = vdiAdapter->SetMicMute(vdiAdapter, mute);
633 if (ret != HDF_SUCCESS) {
634 AUDIO_FUNC_LOGE("audio vdiAdapter call SetMicMute fail, ret=%{public}d", ret);
635 ret = HDF_FAILURE;
636 goto EXIT;
637 }
638
639 EXIT:
640 pthread_rwlock_unlock(&g_rwAdapterLock);
641 return ret;
642 }
643
AudioGetMicMuteVdi(struct IAudioAdapter * adapter,bool * mute)644 static int32_t AudioGetMicMuteVdi(struct IAudioAdapter *adapter, bool *mute)
645 {
646 pthread_rwlock_rdlock(&g_rwAdapterLock);
647 int32_t ret = HDF_SUCCESS;
648 if (adapter == NULL || mute == NULL) {
649 AUDIO_FUNC_LOGE("invalid param");
650 ret = HDF_ERR_INVALID_PARAM;
651 goto EXIT;
652 }
653
654 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
655 if (vdiAdapter == NULL || vdiAdapter->GetMicMute == NULL) {
656 AUDIO_FUNC_LOGE("invalid param");
657 ret = HDF_ERR_INVALID_PARAM;
658 goto EXIT;
659 }
660
661 ret = vdiAdapter->GetMicMute(vdiAdapter, mute);
662 if (ret != HDF_SUCCESS) {
663 AUDIO_FUNC_LOGE("audio vdiAdapter call GetMicMute fail, ret=%{public}d", ret);
664 ret = HDF_FAILURE;
665 goto EXIT;
666 }
667
668 EXIT:
669 pthread_rwlock_unlock(&g_rwAdapterLock);
670 return ret;
671 }
672
AudioSetVoiceVolumeVdi(struct IAudioAdapter * adapter,float volume)673 static int32_t AudioSetVoiceVolumeVdi(struct IAudioAdapter *adapter, float volume)
674 {
675 pthread_rwlock_rdlock(&g_rwAdapterLock);
676 int32_t ret = HDF_SUCCESS;
677 if (adapter == NULL) {
678 AUDIO_FUNC_LOGE("invalid param");
679 ret = HDF_ERR_INVALID_PARAM;
680 goto EXIT;
681 }
682
683 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
684 if (vdiAdapter == NULL || vdiAdapter->SetVoiceVolume == NULL) {
685 AUDIO_FUNC_LOGE("invalid param");
686 ret = HDF_ERR_INVALID_PARAM;
687 goto EXIT;
688 }
689
690 ret = vdiAdapter->SetVoiceVolume(vdiAdapter, volume);
691 if (ret != HDF_SUCCESS) {
692 AUDIO_FUNC_LOGE("audio vdiAdapter call SetVoiceVolume fail, ret=%{public}d", ret);
693 ret = HDF_FAILURE;
694 goto EXIT;
695 }
696
697 EXIT:
698 pthread_rwlock_unlock(&g_rwAdapterLock);
699 return ret;
700 }
701
AudioSetExtraParamsVdi(struct IAudioAdapter * adapter,enum AudioExtParamKey key,const char * condition,const char * value)702 static int32_t AudioSetExtraParamsVdi(struct IAudioAdapter *adapter, enum AudioExtParamKey key, const char *condition,
703 const char *value)
704 {
705 pthread_rwlock_rdlock(&g_rwAdapterLock);
706 int32_t ret = HDF_SUCCESS;
707 if (adapter == NULL || condition == NULL || value == NULL) {
708 AUDIO_FUNC_LOGE("invalid param");
709 ret = HDF_ERR_INVALID_PARAM;
710 goto EXIT;
711 }
712
713 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
714 if (vdiAdapter == NULL || vdiAdapter->SetExtraParams == NULL) {
715 AUDIO_FUNC_LOGE("invalid param");
716 ret = HDF_ERR_INVALID_PARAM;
717 goto EXIT;
718 }
719
720 ret = vdiAdapter->SetExtraParams(vdiAdapter, (enum AudioExtParamKeyVdi)key, condition, value);
721 if (ret != HDF_SUCCESS) {
722 AUDIO_FUNC_LOGE("audio vdiAdapter call SetExtraParams fail, ret=%{public}d", ret);
723 ret = HDF_FAILURE;
724 goto EXIT;
725 }
726
727 EXIT:
728 pthread_rwlock_unlock(&g_rwAdapterLock);
729 return ret;
730 }
731
AudioGetExtraParamsVdi(struct IAudioAdapter * adapter,enum AudioExtParamKey key,const char * condition,char * value,uint32_t valueLen)732 static int32_t AudioGetExtraParamsVdi(struct IAudioAdapter *adapter, enum AudioExtParamKey key, const char *condition,
733 char *value, uint32_t valueLen)
734 {
735 pthread_rwlock_rdlock(&g_rwAdapterLock);
736 int32_t ret = HDF_SUCCESS;
737 if (adapter == NULL || condition == NULL || value == NULL) {
738 AUDIO_FUNC_LOGE("invalid param");
739 ret = HDF_ERR_INVALID_PARAM;
740 goto EXIT;
741 }
742
743 struct IAudioAdapterVdi *vdiAdapter = AudioGetVdiAdapterVdi(adapter);
744 if (vdiAdapter == NULL || vdiAdapter->GetExtraParams == NULL) {
745 AUDIO_FUNC_LOGE("invalid param");
746 ret = HDF_ERR_INVALID_PARAM;
747 goto EXIT;
748 }
749
750 ret = vdiAdapter->GetExtraParams(vdiAdapter, (enum AudioExtParamKeyVdi)key, condition, value,
751 (int32_t)valueLen);
752 if (ret != HDF_SUCCESS) {
753 AUDIO_FUNC_LOGE("audio vdiAdapter call GetExtraParams fail, ret=%{public}d", ret);
754 ret = HDF_FAILURE;
755 goto EXIT;
756 }
757
758 EXIT:
759 pthread_rwlock_unlock(&g_rwAdapterLock);
760 return ret;
761 }
762
AudioInitAdapterInstanceVdi(struct IAudioAdapter * adapter)763 static void AudioInitAdapterInstanceVdi(struct IAudioAdapter *adapter)
764 {
765 adapter->InitAllPorts = AudioInitAllPortsVdi;
766 adapter->CreateRender = AudioCreateRenderVdi;
767 adapter->DestroyRender = AudioDestroyRenderVdi;
768 adapter->CreateCapture = AudioCreateCaptureVdi;
769 adapter->DestroyCapture = AudioDestroyCaptureVdi;
770
771 adapter->GetPortCapability = AudioGetPortCapabilityVdi;
772 adapter->SetPassthroughMode = AudioSetPassthroughModeVdi;
773 adapter->GetPassthroughMode = AudioGetPassthroughModeVdi;
774 adapter->GetDeviceStatus = AudioGetDeviceStatusVdi;
775 adapter->UpdateAudioRoute = AudioUpdateAudioRouteVdi;
776
777 adapter->ReleaseAudioRoute = AudioReleaseAudioRouteVdi;
778 adapter->SetMicMute = AudioSetMicMuteVdi;
779 adapter->GetMicMute = AudioGetMicMuteVdi;
780 adapter->SetVoiceVolume = AudioSetVoiceVolumeVdi;
781 adapter->SetExtraParams = AudioSetExtraParamsVdi;
782
783 adapter->GetExtraParams = AudioGetExtraParamsVdi;
784 }
785
AudioGetAdapterRefCntVdi(uint32_t descIndex)786 uint32_t AudioGetAdapterRefCntVdi(uint32_t descIndex)
787 {
788 pthread_rwlock_rdlock(&g_rwAdapterLock);
789 if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
790 AUDIO_FUNC_LOGE("get adapter ref error, descIndex=%{public}d", descIndex);
791 pthread_rwlock_unlock(&g_rwAdapterLock);
792 return UINT_MAX;
793 }
794
795 struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
796 pthread_rwlock_unlock(&g_rwAdapterLock);
797 return priv->adapterInfo[descIndex].refCnt;
798 }
799
AudioIncreaseAdapterRefVdi(uint32_t descIndex,struct IAudioAdapter ** adapter)800 int32_t AudioIncreaseAdapterRefVdi(uint32_t descIndex, struct IAudioAdapter **adapter)
801 {
802 pthread_rwlock_wrlock(&g_rwAdapterLock);
803 int32_t ret = HDF_SUCCESS;
804 if (adapter == NULL) {
805 AUDIO_FUNC_LOGE("invalid param");
806 ret = HDF_ERR_INVALID_PARAM;
807 goto EXIT;
808 }
809 if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
810 AUDIO_FUNC_LOGE("increase adapter ref error, descIndex=%{public}d", descIndex);
811 ret = HDF_ERR_INVALID_PARAM;
812 goto EXIT;
813 }
814
815 struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
816 if (priv->adapterInfo[descIndex].adapter == NULL) {
817 AUDIO_FUNC_LOGE("Invalid adapter param!");
818 ret = HDF_ERR_INVALID_PARAM;
819 goto EXIT;
820 }
821
822 priv->adapterInfo[descIndex].refCnt++;
823 *adapter = priv->adapterInfo[descIndex].adapter;
824 AUDIO_FUNC_LOGI("increase adapternameIndex[%{public}d], refCount[%{public}d]", descIndex,
825 priv->adapterInfo[descIndex].refCnt);
826
827 EXIT:
828 pthread_rwlock_unlock(&g_rwAdapterLock);
829 return ret;
830 }
831
AudioDecreaseAdapterRefVdi(uint32_t descIndex)832 void AudioDecreaseAdapterRefVdi(uint32_t descIndex)
833 {
834 pthread_rwlock_wrlock(&g_rwAdapterLock);
835 if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
836 AUDIO_FUNC_LOGE("decrease adapter ref error, descIndex=%{public}d", descIndex);
837 pthread_rwlock_unlock(&g_rwAdapterLock);
838 return;
839 }
840
841 struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
842 if (priv->adapterInfo[descIndex].refCnt == 0) {
843 AUDIO_FUNC_LOGE("Invalid adapterInfo[%{public}d] had released", descIndex);
844 pthread_rwlock_unlock(&g_rwAdapterLock);
845 return;
846 }
847 priv->adapterInfo[descIndex].refCnt--;
848 AUDIO_FUNC_LOGI("decrease adapternameIndex[%{public}d], refCount[%{public}d]", descIndex,
849 priv->adapterInfo[descIndex].refCnt);
850 pthread_rwlock_unlock(&g_rwAdapterLock);
851 return;
852 }
853
AudioEnforceClearAdapterRefCntVdi(uint32_t descIndex)854 void AudioEnforceClearAdapterRefCntVdi(uint32_t descIndex)
855 {
856 pthread_rwlock_wrlock(&g_rwAdapterLock);
857 if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
858 AUDIO_FUNC_LOGE("decrease adapter descIndex error, descIndex=%{public}d", descIndex);
859 pthread_rwlock_unlock(&g_rwAdapterLock);
860 return;
861 }
862
863 struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
864 priv->adapterInfo[descIndex].refCnt = 0;
865 AUDIO_FUNC_LOGI("clear adapter ref count zero");
866 pthread_rwlock_unlock(&g_rwAdapterLock);
867 }
868
AudioCreateAdapterVdi(uint32_t descIndex,struct IAudioAdapterVdi * vdiAdapter,char * adapterName)869 struct IAudioAdapter *AudioCreateAdapterVdi(uint32_t descIndex, struct IAudioAdapterVdi *vdiAdapter,
870 char *adapterName)
871 {
872 pthread_rwlock_wrlock(&g_rwAdapterLock);
873 if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
874 AUDIO_FUNC_LOGE("create adapter error, descIndex=%{public}d", descIndex);
875 pthread_rwlock_unlock(&g_rwAdapterLock);
876 return NULL;
877 }
878
879 if (vdiAdapter == NULL) {
880 AUDIO_FUNC_LOGE("audio vdiAdapter is null");
881 pthread_rwlock_unlock(&g_rwAdapterLock);
882 return NULL;
883 }
884
885 struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
886 struct IAudioAdapter *adapter = priv->adapterInfo[descIndex].adapter;
887 if (adapter != NULL) {
888 pthread_rwlock_unlock(&g_rwAdapterLock);
889 return adapter;
890 }
891
892 adapter = (struct IAudioAdapter *)OsalMemCalloc(sizeof(struct IAudioAdapter));
893 if (adapter == NULL) {
894 AUDIO_FUNC_LOGE("OsalMemCalloc adapter fail");
895 pthread_rwlock_unlock(&g_rwAdapterLock);
896 return NULL;
897 }
898
899 AudioInitAdapterInstanceVdi(adapter);
900 priv->adapterInfo[descIndex].vdiAdapter = vdiAdapter;
901 priv->adapterInfo[descIndex].adapter = adapter;
902 priv->adapterInfo[descIndex].refCnt = 1;
903 priv->adapterInfo[descIndex].adapterName = strdup(adapterName);
904 if (priv->adapterInfo[descIndex].adapterName == NULL) {
905 OsalMemFree((void *)priv->adapterInfo[descIndex].adapter);
906 priv->adapterInfo[descIndex].adapter = NULL;
907 pthread_rwlock_unlock(&g_rwAdapterLock);
908 return NULL;
909 }
910
911 AUDIO_FUNC_LOGI(" audio vdiAdapter create adapter success, refcount[1], adapterName=[%{public}s]", adapterName);
912 pthread_rwlock_unlock(&g_rwAdapterLock);
913 return adapter;
914 }
915
AudioReleaseAdapterVdi(uint32_t descIndex)916 void AudioReleaseAdapterVdi(uint32_t descIndex)
917 {
918 pthread_rwlock_wrlock(&g_rwAdapterLock);
919 if (descIndex >= AUDIO_VDI_ADAPTER_NUM_MAX) {
920 AUDIO_FUNC_LOGE("adapter release fail descIndex=%{public}d", descIndex);
921 pthread_rwlock_unlock(&g_rwAdapterLock);
922 return;
923 }
924
925 struct AudioAdapterPrivVdi *priv = AudioAdapterGetPrivVdi();
926 StubCollectorRemoveObject(IAUDIOADAPTER_INTERFACE_DESC, priv->adapterInfo[descIndex].adapter);
927 OsalMemFree((void *)priv->adapterInfo[descIndex].adapter);
928 priv->adapterInfo[descIndex].adapter = NULL;
929 priv->adapterInfo[descIndex].vdiAdapter = NULL;
930 priv->adapterInfo[descIndex].refCnt = UINT_MAX;
931 OsalMemFree((void *)priv->adapterInfo[descIndex].adapterName);
932 priv->adapterInfo[descIndex].adapterName = NULL;
933
934 priv->isRegCb = false;
935 priv->callback = NULL;
936
937 AUDIO_FUNC_LOGI(" audio vdiAdapter release adapter success");
938 pthread_rwlock_unlock(&g_rwAdapterLock);
939 }
940