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_vendor.h"
17
18 #include <hdf_base.h>
19 #include <limits.h>
20 #include "audio_capture_vendor.h"
21 #include "audio_common_vendor.h"
22 #include "audio_render_vendor.h"
23 #include "audio_uhdf_log.h"
24 #include "osal_mem.h"
25 #include "securec.h"
26 #include "v1_0/iaudio_callback.h"
27
28 #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL
29
30 struct AudioAdapterInfo {
31 struct AudioHwiAdapter *hwiAdapter;
32 struct IAudioAdapter *adapter;
33 uint32_t refCnt;
34 };
35
36 struct AudioHwiAdapterPriv {
37 struct AudioAdapterInfo adapterInfo[AUDIO_HW_ADAPTER_NUM_MAX];
38 struct IAudioCallback *callback;
39 bool isRegCb;
40 };
41
42 static struct AudioHwiAdapterPriv g_audioHwiAdapter;
43
AudioHwiAdapterGetPriv(void)44 static struct AudioHwiAdapterPriv *AudioHwiAdapterGetPriv(void)
45 {
46 return &g_audioHwiAdapter;
47 }
48
AudioHwiGetHwiAdapterByDescIndex(uint32_t descIndex)49 struct AudioHwiAdapter *AudioHwiGetHwiAdapterByDescIndex(uint32_t descIndex)
50 {
51 struct AudioHwiAdapterPriv *priv = AudioHwiAdapterGetPriv();
52
53 if (descIndex >= AUDIO_HW_ADAPTER_NUM_MAX) {
54 AUDIO_FUNC_LOGE("get hwiAdapter error, descIndex=%{public}d", descIndex);
55 return NULL;
56 }
57
58 return priv->adapterInfo[descIndex].hwiAdapter;
59 }
60
AudioHwiGetHwiAdapter(const struct IAudioAdapter * adapter)61 struct AudioHwiAdapter *AudioHwiGetHwiAdapter(const struct IAudioAdapter *adapter)
62 {
63 struct AudioHwiAdapterPriv *priv = AudioHwiAdapterGetPriv();
64
65 if (adapter == NULL) {
66 AUDIO_FUNC_LOGE("get hwiAdapter error");
67 return NULL;
68 }
69
70 for (uint32_t i = 0; i < AUDIO_HW_ADAPTER_NUM_MAX; i++) {
71 if (adapter == priv->adapterInfo[i].adapter) {
72 return priv->adapterInfo[i].hwiAdapter;
73 }
74 }
75
76 AUDIO_FUNC_LOGE("audio get hwiadapter fail");
77 return NULL;
78 }
79
AudioHwiInitAllPorts(struct IAudioAdapter * adapter)80 int32_t AudioHwiInitAllPorts(struct IAudioAdapter *adapter)
81 {
82 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
83
84 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
85 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
86
87 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->InitAllPorts, HDF_ERR_INVALID_PARAM);
88 int32_t ret = hwiAdapter->InitAllPorts(hwiAdapter);
89 if (ret != HDF_SUCCESS) {
90 AUDIO_FUNC_LOGE("audio hwiAdapter InitAllPorts fail, ret=%{public}d", ret);
91 return HDF_FAILURE;
92 }
93
94 return HDF_SUCCESS;
95 }
96
AudioHwiCreateRender(struct IAudioAdapter * adapter,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,struct IAudioRender ** render,uint32_t * renderId)97 int32_t AudioHwiCreateRender(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc,
98 const struct AudioSampleAttributes *attrs, struct IAudioRender **render, uint32_t *renderId)
99 {
100 struct AudioHwiDeviceDescriptor hwiDesc;
101 struct AudioHwiSampleAttributes hwiAttrs;
102 struct AudioHwiRender *hwiRender = NULL;
103
104 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
105 CHECK_NULL_PTR_RETURN_VALUE(desc, HDF_ERR_INVALID_PARAM);
106 CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
107 CHECK_NULL_PTR_RETURN_VALUE(render, HDF_ERR_INVALID_PARAM);
108 CHECK_NULL_PTR_RETURN_VALUE(renderId, HDF_ERR_INVALID_PARAM);
109 CHECK_VALID_RANGE_RETURN(*renderId, 0, AUDIO_HW_STREAM_NUM_MAX - 1, HDF_ERR_INVALID_PARAM);
110
111 *render = FindRenderCreated(desc->pins, attrs, renderId);
112 if (*render != NULL) {
113 AUDIO_FUNC_LOGE("already created");
114 return HDF_SUCCESS;
115 }
116
117 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
118 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
119 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->CreateRender, HDF_ERR_INVALID_PARAM);
120 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->DestroyRender, HDF_ERR_INVALID_PARAM);
121
122 AudioHwiCommonDevDescToHwiDevDesc(desc, &hwiDesc);
123 AudioHwiCommonAttrsToHwiAttrs(attrs, &hwiAttrs);
124
125 int32_t ret = hwiAdapter->CreateRender(hwiAdapter, &hwiDesc, &hwiAttrs, &hwiRender);
126 OsalMemFree((void *)hwiDesc.desc);
127 if (ret != HDF_SUCCESS) {
128 AUDIO_FUNC_LOGE("audio hwiAdapter call CreateRender fail, ret=%{public}d", ret);
129 return HDF_FAILURE;
130 }
131
132 *render = AudioHwiCreateRenderById(attrs, renderId, hwiRender, desc);
133 if (*render == NULL) {
134 (void)hwiAdapter->DestroyRender(hwiAdapter, hwiRender);
135 AUDIO_FUNC_LOGE("Create audio render failed");
136 return HDF_ERR_INVALID_PARAM;
137 }
138
139 return HDF_SUCCESS;
140 }
141
AudioHwiDestroyRender(struct IAudioAdapter * adapter,uint32_t renderId)142 int32_t AudioHwiDestroyRender(struct IAudioAdapter *adapter, uint32_t renderId)
143 {
144 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
145 CHECK_VALID_RANGE_RETURN(renderId, 0, AUDIO_HW_STREAM_NUM_MAX - 1, HDF_ERR_INVALID_PARAM);
146 if (DecreaseRenderUsrCount(renderId) > 0) {
147 AUDIO_FUNC_LOGE("render destroy: more than one usr");
148 return HDF_SUCCESS;
149 }
150
151 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
152 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
153
154 struct AudioHwiRender *hwiRender = AudioHwiGetHwiRenderById(renderId);
155 CHECK_NULL_PTR_RETURN_VALUE(hwiRender, HDF_ERR_INVALID_PARAM);
156
157 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->DestroyRender, HDF_ERR_INVALID_PARAM);
158 int32_t ret = hwiAdapter->DestroyRender(hwiAdapter, hwiRender);
159 if (ret != HDF_SUCCESS) {
160 AUDIO_FUNC_LOGE("audio hwiAdapter call DestroyRender fail, ret=%{public}d", ret);
161 return HDF_FAILURE;
162 }
163
164 AudioHwiDestroyRenderById(renderId);
165
166 return HDF_SUCCESS;
167 }
168
AudioHwiCreateCapture(struct IAudioAdapter * adapter,const struct AudioDeviceDescriptor * desc,const struct AudioSampleAttributes * attrs,struct IAudioCapture ** capture,uint32_t * captureId)169 int32_t AudioHwiCreateCapture(struct IAudioAdapter *adapter, const struct AudioDeviceDescriptor *desc,
170 const struct AudioSampleAttributes *attrs, struct IAudioCapture **capture, uint32_t *captureId)
171 {
172 struct AudioHwiCapture *hwiCapture = NULL;
173
174 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
175 CHECK_NULL_PTR_RETURN_VALUE(desc, HDF_ERR_INVALID_PARAM);
176 CHECK_NULL_PTR_RETURN_VALUE(attrs, HDF_ERR_INVALID_PARAM);
177 CHECK_NULL_PTR_RETURN_VALUE(capture, HDF_ERR_INVALID_PARAM);
178 CHECK_NULL_PTR_RETURN_VALUE(captureId, HDF_ERR_INVALID_PARAM);
179 CHECK_VALID_RANGE_RETURN(*captureId, 0, AUDIO_HW_STREAM_NUM_MAX - 1, HDF_ERR_INVALID_PARAM);
180
181 *capture = FindCaptureCreated(desc->pins, attrs, captureId);
182 if (*capture != NULL) {
183 AUDIO_FUNC_LOGE("already created");
184 return HDF_SUCCESS;
185 }
186
187 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
188 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
189
190 struct AudioHwiDeviceDescriptor hwiDesc;
191 struct AudioHwiSampleAttributes hwiAttrs;
192 (void)memset_s((void *)&hwiDesc, sizeof(hwiDesc), 0, sizeof(hwiDesc));
193 (void)memset_s((void *)&hwiAttrs, sizeof(hwiAttrs), 0, sizeof(hwiAttrs));
194 AudioHwiCommonDevDescToHwiDevDesc(desc, &hwiDesc);
195 AudioHwiCommonAttrsToHwiAttrs(attrs, &hwiAttrs);
196
197 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->CreateCapture, HDF_ERR_INVALID_PARAM);
198 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->DestroyCapture, HDF_ERR_INVALID_PARAM);
199 int32_t ret = hwiAdapter->CreateCapture(hwiAdapter, &hwiDesc, &hwiAttrs, &hwiCapture);
200 OsalMemFree((void *)hwiDesc.desc);
201 if (ret != HDF_SUCCESS) {
202 AUDIO_FUNC_LOGE("audio hwiAdapter call CreateCapture fail, ret=%{public}d", ret);
203 return HDF_FAILURE;
204 }
205
206 *capture = AudioHwiCreateCaptureById(attrs, captureId, hwiCapture, desc);
207 if (*capture == NULL) {
208 (void)hwiAdapter->DestroyCapture(hwiAdapter, hwiCapture);
209 AUDIO_FUNC_LOGE("create audio capture failed");
210 return HDF_ERR_INVALID_PARAM;
211 }
212
213 return HDF_SUCCESS;
214 }
215
AudioHwiDestroyCapture(struct IAudioAdapter * adapter,uint32_t captureId)216 int32_t AudioHwiDestroyCapture(struct IAudioAdapter *adapter, uint32_t captureId)
217 {
218 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
219 CHECK_VALID_RANGE_RETURN(captureId, 0, AUDIO_HW_STREAM_NUM_MAX - 1, HDF_ERR_INVALID_PARAM);
220 if (DecreaseCaptureUsrCount(captureId) > 0) {
221 AUDIO_FUNC_LOGE("capture destroy: more than one usr");
222 return HDF_SUCCESS;
223 }
224
225 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
226 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
227
228 struct AudioHwiCapture *hwiCapture = AudioHwiGetHwiCaptureById(captureId);
229 CHECK_NULL_PTR_RETURN_VALUE(hwiCapture, HDF_ERR_INVALID_PARAM);
230 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->DestroyCapture, HDF_ERR_INVALID_PARAM);
231 int32_t ret = hwiAdapter->DestroyCapture(hwiAdapter, hwiCapture);
232 if (ret != HDF_SUCCESS) {
233 AUDIO_FUNC_LOGE("audio hwiAdapter call DestroyCapture fail, ret=%{public}d", ret);
234 return HDF_FAILURE;
235 }
236
237 AudioHwiDestroyCaptureById(captureId);
238
239 return HDF_SUCCESS;
240 }
241
AudioHwiGetPortCapability(struct IAudioAdapter * adapter,const struct AudioPort * port,struct AudioPortCapability * capability)242 int32_t AudioHwiGetPortCapability(struct IAudioAdapter *adapter, const struct AudioPort *port,
243 struct AudioPortCapability* capability)
244 {
245 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
246 CHECK_NULL_PTR_RETURN_VALUE(port, HDF_ERR_INVALID_PARAM);
247 CHECK_NULL_PTR_RETURN_VALUE(capability, HDF_ERR_INVALID_PARAM);
248
249 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
250 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
251
252 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->GetPortCapability, HDF_ERR_INVALID_PARAM);
253 struct AudioHwiPortCapability hwiCap;
254 struct AudioHwiPort hwiPort;
255 (void)memset_s(&hwiCap, sizeof(hwiCap), 0, sizeof(hwiCap));
256 (void)memset_s(&hwiPort, sizeof(hwiPort), 0, sizeof(hwiPort));
257
258 int32_t ret = AudioHwiCommonPortToHwiPort(port, &hwiPort);
259 if (ret != HDF_SUCCESS) {
260 OsalMemFree((void *)hwiPort.portName);
261 AUDIO_FUNC_LOGE("audio hwiAdapter call PortCapToHwiPortCap fail, ret=%{public}d", ret);
262 return ret;
263 }
264
265 ret = hwiAdapter->GetPortCapability(hwiAdapter, &hwiPort, &hwiCap);
266 OsalMemFree((void *)hwiPort.portName);
267 if (ret != HDF_SUCCESS) {
268 AUDIO_FUNC_LOGE("audio hwiAdapter call GetPortCapability fail, ret=%{public}d", ret);
269 return ret;
270 }
271
272 AudioHwiCommonHwiPortCapToPortCap(&hwiCap, capability);
273 return HDF_SUCCESS;
274 }
275
AudioHwiSetPassthroughMode(struct IAudioAdapter * adapter,const struct AudioPort * port,enum AudioPortPassthroughMode mode)276 int32_t AudioHwiSetPassthroughMode(struct IAudioAdapter *adapter, const struct AudioPort *port,
277 enum AudioPortPassthroughMode mode)
278 {
279 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
280 CHECK_NULL_PTR_RETURN_VALUE(port, HDF_ERR_INVALID_PARAM);
281
282 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
283 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
284 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->SetPassthroughMode, HDF_ERR_INVALID_PARAM);
285
286 struct AudioHwiPort hwiPort;
287 (void)memset_s((void *)&hwiPort, sizeof(hwiPort), 0, sizeof(hwiPort));
288 int32_t ret = AudioHwiCommonPortToHwiPort(port, &hwiPort);
289 if (ret != HDF_SUCCESS) {
290 OsalMemFree((void *)hwiPort.portName);
291 AUDIO_FUNC_LOGE("audio hwiAdapter call PortCapToHwiPortCap fail, ret=%{public}d", ret);
292 return ret;
293 }
294
295 ret = hwiAdapter->SetPassthroughMode(hwiAdapter, &hwiPort, (enum AudioHwiPortPassthroughMode)mode);
296 OsalMemFree((void *)hwiPort.portName);
297 if (ret != HDF_SUCCESS) {
298 AUDIO_FUNC_LOGE("audio hwiAdapter call SetPassthroughMode fail, ret=%{public}d", ret);
299 return HDF_FAILURE;
300 }
301
302 return HDF_SUCCESS;
303 }
304
AudioHwiGetPassthroughMode(struct IAudioAdapter * adapter,const struct AudioPort * port,enum AudioPortPassthroughMode * mode)305 int32_t AudioHwiGetPassthroughMode(struct IAudioAdapter *adapter, const struct AudioPort *port,
306 enum AudioPortPassthroughMode *mode)
307 {
308 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
309 CHECK_NULL_PTR_RETURN_VALUE(port, HDF_ERR_INVALID_PARAM);
310 CHECK_NULL_PTR_RETURN_VALUE(mode, HDF_ERR_INVALID_PARAM);
311
312 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
313 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
314 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->GetPassthroughMode, HDF_ERR_INVALID_PARAM);
315
316 struct AudioHwiPort hwiPort;
317 (void)memset_s((void *)&hwiPort, sizeof(hwiPort), 0, sizeof(hwiPort));
318 int32_t ret = AudioHwiCommonPortToHwiPort(port, &hwiPort);
319 if (ret != HDF_SUCCESS) {
320 OsalMemFree((void *)hwiPort.portName);
321 AUDIO_FUNC_LOGE("audio hwiAdapter call PortCapToHwiPortCap fail, ret=%{public}d", ret);
322 return ret;
323 }
324
325 ret = hwiAdapter->GetPassthroughMode(hwiAdapter, &hwiPort, (enum AudioHwiPortPassthroughMode *)mode);
326 OsalMemFree((void *)hwiPort.portName);
327 if (ret != HDF_SUCCESS) {
328 AUDIO_FUNC_LOGE("audio hwiAdapter call GetPassthroughMode fail, ret=%{public}d", ret);
329 return HDF_FAILURE;
330 }
331
332 return HDF_SUCCESS;
333 }
334
AudioHwiGetDeviceStatus(struct IAudioAdapter * adapter,struct AudioDeviceStatus * status)335 int32_t AudioHwiGetDeviceStatus(struct IAudioAdapter *adapter, struct AudioDeviceStatus *status)
336 {
337 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
338 CHECK_NULL_PTR_RETURN_VALUE(status, HDF_ERR_INVALID_PARAM);
339
340 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
341 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
342 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->GetDeviceStatus, HDF_ERR_INVALID_PARAM);
343
344 struct AudioHwiDeviceStatus hwiStatus;
345 (void)memset_s((void *)&hwiStatus, sizeof(hwiStatus), 0, sizeof(hwiStatus));
346 int32_t ret = hwiAdapter->GetDeviceStatus(hwiAdapter, &hwiStatus);
347 if (ret != HDF_SUCCESS) {
348 AUDIO_FUNC_LOGE("audio hwiAdapter call GetDeviceStatus fail, ret=%{public}d", ret);
349 return HDF_FAILURE;
350 }
351
352 status->pnpStatus = hwiStatus.pnpStatus;
353 return HDF_SUCCESS;
354 }
355
AudioHwiUpdateAudioRoute(struct IAudioAdapter * adapter,const struct AudioRoute * route,int32_t * routeHandle)356 int32_t AudioHwiUpdateAudioRoute(struct IAudioAdapter *adapter, const struct AudioRoute *route, int32_t *routeHandle)
357 {
358 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
359 CHECK_NULL_PTR_RETURN_VALUE(route, HDF_ERR_INVALID_PARAM);
360 CHECK_NULL_PTR_RETURN_VALUE(routeHandle, HDF_ERR_INVALID_PARAM);
361
362 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
363 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
364 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->UpdateAudioRoute, HDF_ERR_INVALID_PARAM);
365
366 struct AudioHwiRoute hwiRoute;
367 (void)memset_s(&hwiRoute, sizeof(hwiRoute), 0, sizeof(hwiRoute));
368
369 int32_t ret = AudioHwiCommonRouteToHwiRoute(route, &hwiRoute);
370 if (ret != HDF_SUCCESS) {
371 AUDIO_FUNC_LOGE("audio hwiAdapter route To hwiRoute fail");
372 return HDF_FAILURE;
373 }
374
375 ret = hwiAdapter->UpdateAudioRoute(hwiAdapter, &hwiRoute, routeHandle);
376 AudioHwiCommonFreeHwiRoute(&hwiRoute);
377 if (ret != HDF_SUCCESS) {
378 AUDIO_FUNC_LOGE("audio hwiAdapter call UpdateAudioRoute fail, ret=%{public}d", ret);
379 return HDF_FAILURE;
380 }
381
382 return HDF_SUCCESS;
383 }
384
AudioHwiReleaseAudioRoute(struct IAudioAdapter * adapter,int32_t routeHandle)385 int32_t AudioHwiReleaseAudioRoute(struct IAudioAdapter *adapter, int32_t routeHandle)
386 {
387 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
388
389 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
390 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
391 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->ReleaseAudioRoute, HDF_ERR_INVALID_PARAM);
392
393 int32_t ret = hwiAdapter->ReleaseAudioRoute(hwiAdapter, routeHandle);
394 if (ret != HDF_SUCCESS) {
395 AUDIO_FUNC_LOGE("audio hwiAdapter call ReleaseAudioRoute fail, ret=%{public}d", ret);
396 return HDF_FAILURE;
397 }
398
399 return HDF_SUCCESS;
400 }
401
AudioHwiSetMicMute(struct IAudioAdapter * adapter,bool mute)402 int32_t AudioHwiSetMicMute(struct IAudioAdapter *adapter, bool mute)
403 {
404 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
405
406 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
407 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
408 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->SetMicMute, HDF_ERR_INVALID_PARAM);
409
410 int32_t ret = hwiAdapter->SetMicMute(hwiAdapter, mute);
411 if (ret != HDF_SUCCESS) {
412 AUDIO_FUNC_LOGE("audio hwiAdapter call SetMicMute fail, ret=%{public}d", ret);
413 return HDF_FAILURE;
414 }
415
416 return HDF_SUCCESS;
417 }
418
AudioHwiGetMicMute(struct IAudioAdapter * adapter,bool * mute)419 int32_t AudioHwiGetMicMute(struct IAudioAdapter *adapter, bool *mute)
420 {
421 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
422 CHECK_NULL_PTR_RETURN_VALUE(mute, HDF_ERR_INVALID_PARAM);
423
424 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
425 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
426 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->GetMicMute, HDF_ERR_INVALID_PARAM);
427
428 int32_t ret = hwiAdapter->GetMicMute(hwiAdapter, mute);
429 if (ret != HDF_SUCCESS) {
430 AUDIO_FUNC_LOGE("audio hwiAdapter call GetMicMute fail, ret=%{public}d", ret);
431 return HDF_FAILURE;
432 }
433
434 return HDF_SUCCESS;
435 }
436
AudioHwiSetVoiceVolume(struct IAudioAdapter * adapter,float volume)437 int32_t AudioHwiSetVoiceVolume(struct IAudioAdapter *adapter, float volume)
438 {
439 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
440
441 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
442 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
443 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->SetVoiceVolume, HDF_ERR_INVALID_PARAM);
444
445 int32_t ret = hwiAdapter->SetVoiceVolume(hwiAdapter, volume);
446 if (ret != HDF_SUCCESS) {
447 AUDIO_FUNC_LOGE("audio hwiAdapter call SetVoiceVolume fail, ret=%{public}d", ret);
448 return HDF_FAILURE;
449 }
450
451 return HDF_SUCCESS;
452 }
453
AudioHwiSetExtraParams(struct IAudioAdapter * adapter,enum AudioExtParamKey key,const char * condition,const char * value)454 int32_t AudioHwiSetExtraParams(struct IAudioAdapter *adapter, enum AudioExtParamKey key, const char *condition,
455 const char *value)
456 {
457 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
458 CHECK_NULL_PTR_RETURN_VALUE(condition, HDF_ERR_INVALID_PARAM);
459 CHECK_NULL_PTR_RETURN_VALUE(value, HDF_ERR_INVALID_PARAM);
460
461 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
462 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
463 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->SetExtraParams, HDF_ERR_INVALID_PARAM);
464
465 int32_t ret = hwiAdapter->SetExtraParams(hwiAdapter, (enum AudioHwiExtParamKey)key, condition, value);
466 if (ret != HDF_SUCCESS) {
467 AUDIO_FUNC_LOGE("audio hwiAdapter call SetExtraParams fail, ret=%{public}d", ret);
468 return HDF_FAILURE;
469 }
470
471 return HDF_SUCCESS;
472 }
473
AudioHwiGetExtraParams(struct IAudioAdapter * adapter,enum AudioExtParamKey key,const char * condition,char * value,uint32_t valueLen)474 int32_t AudioHwiGetExtraParams(struct IAudioAdapter *adapter, enum AudioExtParamKey key, const char *condition,
475 char *value, uint32_t valueLen)
476 {
477 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
478 CHECK_NULL_PTR_RETURN_VALUE(condition, HDF_ERR_INVALID_PARAM);
479 CHECK_NULL_PTR_RETURN_VALUE(value, HDF_ERR_INVALID_PARAM);
480
481 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
482 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
483 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->GetExtraParams, HDF_ERR_INVALID_PARAM);
484
485 int32_t ret = hwiAdapter->GetExtraParams(hwiAdapter, (enum AudioHwiExtParamKey)key, condition, value,
486 (int32_t)valueLen);
487 if (ret != HDF_SUCCESS) {
488 AUDIO_FUNC_LOGE("audio hwiAdapter call GetExtraParams fail, ret=%{public}d", ret);
489 return HDF_FAILURE;
490 }
491
492 return HDF_SUCCESS;
493 }
494
AudioHwiParamHwiCallback(enum AudioHwiExtParamKey key,const char * condition,const char * value,void * reserved,void * cookie)495 static int32_t AudioHwiParamHwiCallback(enum AudioHwiExtParamKey key, const char *condition, const char *value,
496 void *reserved, void *cookie)
497 {
498 CHECK_NULL_PTR_RETURN_VALUE(condition, HDF_ERR_INVALID_PARAM);
499 CHECK_NULL_PTR_RETURN_VALUE(value, HDF_ERR_INVALID_PARAM);
500 CHECK_NULL_PTR_RETURN_VALUE(reserved, HDF_ERR_INVALID_PARAM);
501 CHECK_NULL_PTR_RETURN_VALUE(cookie, HDF_ERR_INVALID_PARAM);
502
503 struct AudioHwiAdapterPriv *priv = AudioHwiAdapterGetPriv();
504 struct IAudioCallback *cb = priv->callback;
505 int32_t ret = cb->ParamCallback(cb, (enum AudioExtParamKey)key, condition, value, reserved, *(int8_t *)cookie);
506 if (ret != HDF_SUCCESS) {
507 AUDIO_FUNC_LOGE("audio hwiAdapter call GetExtraParams fail, ret=%{public}d", ret);
508 return HDF_FAILURE;
509 }
510
511 return HDF_SUCCESS;
512 }
513
AudioHwiRegExtraParamObserver(struct IAudioAdapter * adapter,struct IAudioCallback * audioCallback,int8_t cookie)514 int32_t AudioHwiRegExtraParamObserver(struct IAudioAdapter *adapter, struct IAudioCallback *audioCallback,
515 int8_t cookie)
516 {
517 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
518 CHECK_NULL_PTR_RETURN_VALUE(audioCallback, HDF_ERR_INVALID_PARAM);
519
520 struct AudioHwiAdapterPriv *priv = AudioHwiAdapterGetPriv();
521 if (priv->isRegCb) {
522 AUDIO_FUNC_LOGI("audio hwiAdapter call AudioHwiRegExtraParamObserver have registered");
523 return HDF_SUCCESS;
524 }
525
526 struct AudioHwiAdapter *hwiAdapter = AudioHwiGetHwiAdapter(adapter);
527 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter, HDF_ERR_INVALID_PARAM);
528 CHECK_NULL_PTR_RETURN_VALUE(hwiAdapter->RegExtraParamObserver, HDF_ERR_INVALID_PARAM);
529
530 int32_t ret = hwiAdapter->RegExtraParamObserver(hwiAdapter, AudioHwiParamHwiCallback, &cookie);
531 if (ret != HDF_SUCCESS) {
532 AUDIO_FUNC_LOGE("audio hwiAdapter call RegExtraParamObserver fail, ret=%{public}d", ret);
533 return HDF_FAILURE;
534 }
535
536 priv->callback = audioCallback;
537 priv->isRegCb = true;
538
539 return HDF_SUCCESS;
540 }
541
AudioHwiInitAdapterInstance(struct IAudioAdapter * adapter)542 static void AudioHwiInitAdapterInstance(struct IAudioAdapter *adapter)
543 {
544 adapter->InitAllPorts = AudioHwiInitAllPorts;
545 adapter->CreateRender = AudioHwiCreateRender;
546 adapter->DestroyRender = AudioHwiDestroyRender;
547 adapter->CreateCapture = AudioHwiCreateCapture;
548 adapter->DestroyCapture = AudioHwiDestroyCapture;
549
550 adapter->GetPortCapability = AudioHwiGetPortCapability;
551 adapter->SetPassthroughMode = AudioHwiSetPassthroughMode;
552 adapter->GetPassthroughMode = AudioHwiGetPassthroughMode;
553 adapter->GetDeviceStatus = AudioHwiGetDeviceStatus;
554 adapter->UpdateAudioRoute = AudioHwiUpdateAudioRoute;
555
556 adapter->ReleaseAudioRoute = AudioHwiReleaseAudioRoute;
557 adapter->SetMicMute = AudioHwiSetMicMute;
558 adapter->GetMicMute = AudioHwiGetMicMute;
559 adapter->SetVoiceVolume = AudioHwiSetVoiceVolume;
560 adapter->SetExtraParams = AudioHwiSetExtraParams;
561
562 adapter->GetExtraParams = AudioHwiGetExtraParams;
563 adapter->RegExtraParamObserver = AudioHwiRegExtraParamObserver;
564 }
565
AudioHwiGetAdapterRefCnt(uint32_t descIndex)566 uint32_t AudioHwiGetAdapterRefCnt(uint32_t descIndex)
567 {
568 if (descIndex >= AUDIO_HW_ADAPTER_NUM_MAX) {
569 AUDIO_FUNC_LOGE("get adapter ref error, descIndex=%{public}d", descIndex);
570 return UINT_MAX;
571 }
572
573 struct AudioHwiAdapterPriv *priv = AudioHwiAdapterGetPriv();
574 return priv->adapterInfo[descIndex].refCnt;
575 }
576
AudioHwiIncreaseAdapterRef(uint32_t descIndex,struct IAudioAdapter ** adapter)577 int32_t AudioHwiIncreaseAdapterRef(uint32_t descIndex, struct IAudioAdapter **adapter)
578 {
579 CHECK_NULL_PTR_RETURN_VALUE(adapter, HDF_ERR_INVALID_PARAM);
580 if (descIndex >= AUDIO_HW_ADAPTER_NUM_MAX) {
581 AUDIO_FUNC_LOGE("increase adapter ref error, descIndex=%{public}d", descIndex);
582 return HDF_ERR_INVALID_PARAM;
583 }
584
585 struct AudioHwiAdapterPriv *priv = AudioHwiAdapterGetPriv();
586 if (priv->adapterInfo[descIndex].adapter == NULL) {
587 AUDIO_FUNC_LOGE("Invalid adapter param!");
588 return HDF_ERR_INVALID_PARAM;
589 }
590
591 priv->adapterInfo[descIndex].refCnt++;
592 *adapter = priv->adapterInfo[descIndex].adapter;
593 AUDIO_FUNC_LOGI("increase adapternameIndex[%{public}d], refCount[%{public}d]", descIndex,
594 priv->adapterInfo[descIndex].refCnt);
595
596 return HDF_SUCCESS;
597 }
598
AudioHwiDecreaseAdapterRef(uint32_t descIndex)599 void AudioHwiDecreaseAdapterRef(uint32_t descIndex)
600 {
601 if (descIndex >= AUDIO_HW_ADAPTER_NUM_MAX) {
602 AUDIO_FUNC_LOGE("decrease adapter ref error, descIndex=%{public}d", descIndex);
603 }
604
605 struct AudioHwiAdapterPriv *priv = AudioHwiAdapterGetPriv();
606 if (priv->adapterInfo[descIndex].refCnt == 0) {
607 AUDIO_FUNC_LOGE("Invalid adapterInfo[%{public}d] had released", descIndex);
608 return;
609 }
610 priv->adapterInfo[descIndex].refCnt--;
611 AUDIO_FUNC_LOGI("decrease adapternameIndex[%{public}d], refCount[%{public}d]", descIndex,
612 priv->adapterInfo[descIndex].refCnt);
613 }
614
AudioHwiEnforceClearAdapterRefCnt(uint32_t descIndex)615 void AudioHwiEnforceClearAdapterRefCnt(uint32_t descIndex)
616 {
617 if (descIndex >= AUDIO_HW_ADAPTER_NUM_MAX) {
618 AUDIO_FUNC_LOGE("decrease adapter descIndex error, descIndex=%{public}d", descIndex);
619 }
620
621 struct AudioHwiAdapterPriv *priv = AudioHwiAdapterGetPriv();
622 priv->adapterInfo[descIndex].refCnt = 0;
623 AUDIO_FUNC_LOGI("clear adapter ref count zero");
624 }
625
AudioHwiCreateAdapter(uint32_t descIndex,struct AudioHwiAdapter * hwiAdapter)626 struct IAudioAdapter *AudioHwiCreateAdapter(uint32_t descIndex, struct AudioHwiAdapter *hwiAdapter)
627 {
628 if (descIndex >= AUDIO_HW_ADAPTER_NUM_MAX) {
629 AUDIO_FUNC_LOGE("create adapter error, descIndex=%{public}d", descIndex);
630 return NULL;
631 }
632
633 if (hwiAdapter == NULL) {
634 AUDIO_FUNC_LOGE("audio hwiAdapter is null");
635 return NULL;
636 }
637
638 struct AudioHwiAdapterPriv *priv = AudioHwiAdapterGetPriv();
639 struct IAudioAdapter *adapter = priv->adapterInfo[descIndex].adapter;
640 if (adapter != NULL) {
641 return adapter;
642 }
643
644 adapter = (struct IAudioAdapter *)OsalMemCalloc(sizeof(struct IAudioAdapter));
645 if (adapter == NULL) {
646 AUDIO_FUNC_LOGE("OsalMemCalloc adapter fail");
647 return NULL;
648 }
649
650 AudioHwiInitAdapterInstance(adapter);
651 priv->adapterInfo[descIndex].hwiAdapter = hwiAdapter;
652 priv->adapterInfo[descIndex].adapter = adapter;
653 priv->adapterInfo[descIndex].refCnt = 1;
654
655 AUDIO_FUNC_LOGI(" audio hwiAdapter create adapter success, refcount[1]");
656 return adapter;
657 }
658
AudioHwiReleaseAdapter(uint32_t descIndex)659 void AudioHwiReleaseAdapter(uint32_t descIndex)
660 {
661 if (descIndex >= AUDIO_HW_ADAPTER_NUM_MAX) {
662 AUDIO_FUNC_LOGE("adapter release fail descIndex=%{public}d", descIndex);
663 return;
664 }
665
666 struct AudioHwiAdapterPriv *priv = AudioHwiAdapterGetPriv();
667
668 OsalMemFree((void *)priv->adapterInfo[descIndex].adapter);
669 priv->adapterInfo[descIndex].adapter = NULL;
670 priv->adapterInfo[descIndex].hwiAdapter = NULL;
671 priv->adapterInfo[descIndex].refCnt = UINT_MAX;
672
673 priv->isRegCb = false;
674 priv->callback = NULL;
675
676 AUDIO_FUNC_LOGI(" audio hwiAdapter release adapter success");
677 }
678