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