1 /*
2 * Copyright (c) 2022 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 "alsa_lib_render.h"
17
18 #define HDF_LOG_TAG HDF_AUDIO_HAL_RENDER
19
AudioCtlRenderSetVolume(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)20 int32_t AudioCtlRenderSetVolume(
21 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
22 {
23 int32_t ret;
24 long vol;
25 struct AlsaRender *renderIns = NULL;
26 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
27
28 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
29 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
30
31 vol = (long)handleData->renderMode.ctlParam.volume;
32 ret = renderIns->SetVolume(renderIns, vol);
33 if (ret != HDF_SUCCESS) {
34 AUDIO_FUNC_LOGE("Render SetVolume fail!");
35 return HDF_FAILURE;
36 }
37
38 return HDF_SUCCESS;
39 }
40
AudioCtlRenderGetVolume(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)41 int32_t AudioCtlRenderGetVolume(
42 const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
43 {
44 int32_t ret;
45 long vol;
46 struct AlsaRender *renderIns = NULL;
47 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
48
49 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
50 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
51
52 ret = renderIns->GetVolume(renderIns, &vol);
53 if (ret != HDF_SUCCESS) {
54 AUDIO_FUNC_LOGE("Render GetVolume failed!");
55 return HDF_FAILURE;
56 }
57 handleData->renderMode.ctlParam.volume = (float)vol;
58
59 return HDF_SUCCESS;
60 }
61
AudioCtlRenderSetPauseStu(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)62 int32_t AudioCtlRenderSetPauseStu(
63 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
64 {
65 int32_t ret;
66 struct AlsaRender *renderIns = NULL;
67 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
68
69 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
70 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
71
72 ret = renderIns->SetPauseState(renderIns, handleData->renderMode.ctlParam.pause);
73 if (ret != HDF_SUCCESS) {
74 AUDIO_FUNC_LOGE("Render set pause failed!");
75 return HDF_FAILURE;
76 }
77
78 return HDF_SUCCESS;
79 }
80
AudioCtlRenderSetMuteStu(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)81 int32_t AudioCtlRenderSetMuteStu(
82 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
83 {
84 int32_t ret;
85 struct AlsaRender *renderIns = NULL;
86 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
87
88 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
89 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
90
91 ret = renderIns->SetMute(renderIns, handleData->renderMode.ctlParam.mute);
92 if (ret < 0) {
93 AUDIO_FUNC_LOGE("Render SetMute failed!");
94 return HDF_FAILURE;
95 }
96
97 return HDF_SUCCESS;
98 }
99
AudioCtlRenderGetMuteStu(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)100 int32_t AudioCtlRenderGetMuteStu(
101 const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
102 {
103 struct AlsaRender *renderIns = NULL;
104 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
105
106 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
107 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
108 handleData->renderMode.ctlParam.mute = renderIns->GetMute(renderIns);
109
110 return HDF_SUCCESS;
111 }
112
AudioCtlRenderSetGainStu(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)113 int32_t AudioCtlRenderSetGainStu(
114 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
115 {
116 int32_t ret;
117 float gainValue;
118 struct AlsaRender *renderIns = NULL;
119 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
120
121 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
122 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
123
124 gainValue = handleData->renderMode.ctlParam.audioGain.gain;
125 ret = renderIns->SetGain(renderIns, gainValue);
126 if (ret != HDF_SUCCESS) {
127 AUDIO_FUNC_LOGE("Render set gain failed!");
128 return HDF_FAILURE;
129 }
130
131 return HDF_SUCCESS;
132 }
133
AudioCtlRenderGetGainStu(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)134 int32_t AudioCtlRenderGetGainStu(
135 const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
136 {
137 int32_t ret;
138 float gainValue;
139 struct AlsaRender *renderIns = NULL;
140 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
141
142 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
143 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
144
145 ret = renderIns->GetGain(renderIns, &gainValue);
146 if (ret != HDF_SUCCESS) {
147 AUDIO_FUNC_LOGE("Render get gain failed!");
148 return HDF_FAILURE;
149 }
150 handleData->renderMode.ctlParam.audioGain.gain = gainValue;
151
152 return HDF_SUCCESS;
153 }
154
AudioCtlRenderSceneSelect(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)155 int32_t AudioCtlRenderSceneSelect(
156 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
157 {
158 int32_t ret;
159 enum AudioPortPin descPins;
160 const struct PathDeviceInfo *deviceInfo;
161 struct AlsaRender *renderIns = NULL;
162 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
163
164 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
165 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
166
167 descPins = handleData->renderMode.hwInfo.deviceDescript.pins;
168 deviceInfo = &handleData->renderMode.hwInfo.pathSelect.deviceInfo;
169 ret = renderIns->SelectScene(renderIns, descPins, deviceInfo);
170 if (ret != HDF_SUCCESS) {
171 AUDIO_FUNC_LOGE("Render select scene pin: (0x%{public}x) failed!", descPins);
172 return HDF_FAILURE;
173 }
174
175 AUDIO_FUNC_LOGD("Render scene select pin: (0x%{public}x) success", descPins);
176 return HDF_SUCCESS;
177 }
178
AudioCtlRenderSceneGetGainThreshold(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)179 int32_t AudioCtlRenderSceneGetGainThreshold(
180 const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
181 {
182 int32_t ret;
183 float gainMin = 0.0;
184 float gainMax = 1.0;
185 struct AlsaRender *renderIns = NULL;
186 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
187
188 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
189 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
190
191 ret = renderIns->GetGainThreshold(renderIns, &gainMin, &gainMax);
192 if (ret != HDF_SUCCESS) {
193 AUDIO_FUNC_LOGE("Render get gain threshold failed");
194 return HDF_FAILURE;
195 }
196 handleData->renderMode.ctlParam.audioGain.gainMin = gainMin;
197 handleData->renderMode.ctlParam.audioGain.gainMax = gainMax;
198
199 return HDF_SUCCESS;
200 }
201
AudioCtlRenderGetVolThreshold(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)202 int32_t AudioCtlRenderGetVolThreshold(
203 const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
204 {
205 int32_t ret;
206 long volMin = MIN_VOLUME;
207 long volMax = MIN_VOLUME;
208 struct AlsaRender *renderIns = NULL;
209 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
210
211 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
212 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
213
214 ret = renderIns->GetVolThreshold(renderIns, &volMin, &volMax);
215 if (ret != HDF_SUCCESS) {
216 AUDIO_FUNC_LOGE("Render get volume threshold failed!");
217 return HDF_FAILURE;
218 }
219 handleData->renderMode.ctlParam.volThreshold.volMin = (int)volMin;
220 handleData->renderMode.ctlParam.volThreshold.volMax = (int)volMax;
221
222 return HDF_SUCCESS;
223 }
224
AudioCtlRenderSetChannelMode(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)225 int32_t AudioCtlRenderSetChannelMode(
226 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
227 {
228 int32_t ret;
229 enum AudioChannelMode mode;
230 struct AlsaRender *renderIns = NULL;
231 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
232
233 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
234 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
235
236 mode = handleData->frameRenderMode.mode;
237 ret = renderIns->SetChannelMode(renderIns, mode);
238 if (ret != HDF_SUCCESS) {
239 AUDIO_FUNC_LOGE("Render set channel mode failed!");
240 return HDF_FAILURE;
241 }
242
243 return HDF_SUCCESS;
244 }
245
AudioCtlRenderGetChannelMode(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)246 int32_t AudioCtlRenderGetChannelMode(
247 const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
248 {
249 int32_t ret;
250 enum AudioChannelMode mode;
251 struct AlsaRender *renderIns = NULL;
252 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
253
254 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
255 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
256
257 ret = renderIns->GetChannelMode(renderIns, &mode);
258 if (ret != HDF_SUCCESS) {
259 AUDIO_FUNC_LOGE("Render get channel mode failed!");
260 return HDF_FAILURE;
261 }
262 handleData->frameRenderMode.mode = mode;
263
264 return HDF_SUCCESS;
265 }
266
AudioInterfaceLibCtlRender(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)267 int32_t AudioInterfaceLibCtlRender(
268 const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
269 {
270 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
271
272 switch (cmdId) {
273 case AUDIODRV_CTL_IOCTL_ELEM_READ:
274 return (AudioCtlRenderGetVolume(handle, cmdId, handleData));
275 case AUDIODRV_CTL_IOCTL_ELEM_WRITE:
276 return (AudioCtlRenderSetVolume(handle, cmdId, handleData));
277 case AUDIODRV_CTL_IOCTL_MUTE_READ:
278 return (AudioCtlRenderGetMuteStu(handle, cmdId, handleData));
279 case AUDIODRV_CTL_IOCTL_MUTE_WRITE:
280 return (AudioCtlRenderSetMuteStu(handle, cmdId, handleData));
281 case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ:
282 return (AudioCtlRenderGetChannelMode(handle, cmdId, handleData));
283 case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE:
284 return (AudioCtlRenderSetChannelMode(handle, cmdId, handleData));
285 case AUDIODRV_CTL_IOCTL_GAIN_WRITE:
286 return (AudioCtlRenderSetGainStu(handle, cmdId, handleData));
287 case AUDIODRV_CTL_IOCTL_GAIN_READ:
288 return (AudioCtlRenderGetGainStu(handle, cmdId, handleData));
289 case AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE:
290 return (AudioCtlRenderSceneSelect(handle, cmdId, handleData));
291 case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ:
292 return (AudioCtlRenderSceneGetGainThreshold(handle, cmdId, handleData));
293 case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ:
294 return (AudioCtlRenderGetVolThreshold(handle, cmdId, handleData));
295 default:
296 AUDIO_FUNC_LOGE("Output Mode not support!");
297 break;
298 }
299
300 return HDF_FAILURE;
301 }
302
AudioOutputRenderHwParams(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)303 int32_t AudioOutputRenderHwParams(
304 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
305 {
306 int32_t ret;
307 struct AlsaRender *renderIns = NULL;
308 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
309
310 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
311 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
312 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns->soundCard.pcmHandle);
313
314 if (SndGetRunState(&renderIns->soundCard) >= SND_PCM_STATE_RUNNING) {
315 AUDIO_FUNC_LOGE("Unable to set parameters during playback!");
316 return HDF_FAILURE;
317 }
318
319 ret = RenderSetParams(renderIns, handleData);
320 if (ret != HDF_SUCCESS) {
321 AUDIO_FUNC_LOGE("Render set parameters failed!");
322 return HDF_FAILURE;
323 }
324
325 AUDIO_FUNC_LOGI("Render set parameters success.");
326 return HDF_SUCCESS;
327 }
328
329 /*
330 * brief: Opens a PCM
331 * param mode Open mode (see #SND_PCM_NONBLOCK, #SND_PCM_ASYNC)
332 */
AudioOutputRenderOpen(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)333 int32_t AudioOutputRenderOpen(
334 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
335 {
336 int32_t ret;
337 struct AlsaRender *renderIns = NULL;
338 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
339
340 renderIns = RenderCreateInstance(handleData->renderMode.hwInfo.adapterName);
341 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
342
343 ret = renderIns->Open(renderIns);
344 if (ret != HDF_SUCCESS) {
345 AUDIO_FUNC_LOGE("Render open pcm failed!");
346 return HDF_FAILURE;
347 }
348
349 ret = renderIns->Init(renderIns);
350 if (ret != HDF_SUCCESS) {
351 AUDIO_FUNC_LOGE("Render init failed!");
352 return HDF_FAILURE;
353 }
354
355 AUDIO_FUNC_LOGI("Render open success.");
356 return HDF_SUCCESS;
357 }
358
AudioOutputRenderWrite(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)359 int32_t AudioOutputRenderWrite(
360 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
361 {
362 int32_t ret;
363 struct AlsaRender *renderIns = NULL;
364 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
365
366 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
367 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
368
369 ret = renderIns->Write(renderIns, handleData);
370 if (ret != HDF_SUCCESS) {
371 AUDIO_FUNC_LOGE("Render wirte frame failed!");
372 return HDF_FAILURE;
373 }
374
375 return HDF_SUCCESS;
376 }
377
AudioOutputRenderPrepare(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)378 int32_t AudioOutputRenderPrepare(
379 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
380 {
381 int32_t ret;
382 struct AlsaRender *renderIns = NULL;
383 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
384
385 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
386 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
387
388 ret = SndPcmPrepare(&renderIns->soundCard);
389 if (ret < 0) {
390 AUDIO_FUNC_LOGE("Render pcm prepare failed");
391 return HDF_FAILURE;
392 }
393
394 return HDF_SUCCESS;
395 }
396
AudioOutputRenderStart(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)397 int32_t AudioOutputRenderStart(
398 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
399 {
400 int32_t ret;
401 struct AlsaRender *renderIns = NULL;
402 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
403
404 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
405 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
406
407 ret = renderIns->Start(renderIns);
408 if (ret != HDF_SUCCESS) {
409 AUDIO_FUNC_LOGE("Render start failed!");
410 return ret;
411 }
412
413 AUDIO_FUNC_LOGI("Render start success.");
414 return HDF_SUCCESS;
415 }
416
AudioOutputRenderStop(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)417 int32_t AudioOutputRenderStop(
418 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
419 {
420 int32_t ret;
421 struct AlsaRender *renderIns = NULL;
422 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
423
424 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
425 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
426
427 ret = renderIns->Stop(renderIns);
428 if (ret != HDF_SUCCESS) {
429 AUDIO_FUNC_LOGE("Render stop failed!");
430 return ret;
431 }
432
433 AUDIO_FUNC_LOGI("Render stop success.");
434 return HDF_SUCCESS;
435 }
436
AudioOutputRenderClose(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)437 int32_t AudioOutputRenderClose(
438 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
439 {
440 struct AlsaRender *renderIns = NULL;
441 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
442
443 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
444 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
445
446 renderIns->Close(renderIns);
447
448 AUDIO_FUNC_LOGI("Render close success.");
449 return HDF_SUCCESS;
450 }
451
AudioOutputRenderReqMmapBuffer(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)452 int32_t AudioOutputRenderReqMmapBuffer(
453 const struct DevHandle *handle, int cmdId, const struct AudioHwRenderParam *handleData)
454 {
455 int32_t ret;
456 struct AlsaRender *renderIns = NULL;
457 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
458
459 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
460 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
461
462 ret = renderIns->MmapWrite(renderIns, handleData);
463 if (ret != HDF_SUCCESS) {
464 AUDIO_FUNC_LOGE("Render MmapWrite error!");
465 return HDF_FAILURE;
466 }
467
468 return HDF_SUCCESS;
469 }
470
AudioOutputRenderGetMmapPosition(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)471 int32_t AudioOutputRenderGetMmapPosition(
472 const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
473 {
474 struct AlsaRender *renderIns = NULL;
475 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
476
477 renderIns = RenderGetInstance(handleData->renderMode.hwInfo.adapterName);
478 CHECK_NULL_PTR_RETURN_DEFAULT(renderIns);
479
480 handleData->frameRenderMode.frames = renderIns->GetMmapPosition(renderIns);
481
482 return HDF_SUCCESS;
483 }
484
AudioInterfaceLibOutputRender(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)485 int32_t AudioInterfaceLibOutputRender(
486 const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
487 {
488 int32_t ret;
489 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
490
491 switch (cmdId) {
492 case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
493 ret = AudioOutputRenderHwParams(handle, cmdId, handleData);
494 break;
495 case AUDIO_DRV_PCM_IOCTL_WRITE:
496 ret = AudioOutputRenderWrite(handle, cmdId, handleData);
497 break;
498 case AUDIO_DRV_PCM_IOCTRL_STOP:
499 ret = AudioOutputRenderStop(handle, cmdId, handleData);
500 break;
501 case AUDIO_DRV_PCM_IOCTRL_START:
502 ret = AudioOutputRenderStart(handle, cmdId, handleData);
503 break;
504 case AUDIO_DRV_PCM_IOCTL_PREPARE:
505 ret = AudioOutputRenderPrepare(handle, cmdId, handleData);
506 break;
507 case AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE:
508 ret = AudioOutputRenderClose(handle, cmdId, handleData);
509 break;
510 case AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN:
511 ret = AudioOutputRenderOpen(handle, cmdId, handleData);
512 break;
513 case AUDIODRV_CTL_IOCTL_PAUSE_WRITE:
514 ret = AudioCtlRenderSetPauseStu(handle, cmdId, handleData);
515 break;
516 case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER:
517 ret = AudioOutputRenderReqMmapBuffer(handle, cmdId, handleData);
518 break;
519 case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION:
520 ret = (AudioOutputRenderGetMmapPosition(handle, cmdId, handleData));
521 break;
522 default:
523 AUDIO_FUNC_LOGE("Output Mode not support!");
524 ret = HDF_FAILURE;
525 break;
526 }
527
528 return ret;
529 }
530
AudioInterfaceLibModeRender(const struct DevHandle * handle,struct AudioHwRenderParam * handleData,int cmdId)531 int32_t AudioInterfaceLibModeRender(
532 const struct DevHandle *handle, struct AudioHwRenderParam *handleData, int cmdId)
533 {
534 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
535
536 switch (cmdId) {
537 case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
538 case AUDIO_DRV_PCM_IOCTL_WRITE:
539 case AUDIO_DRV_PCM_IOCTRL_STOP:
540 case AUDIO_DRV_PCM_IOCTRL_START:
541 case AUDIO_DRV_PCM_IOCTL_PREPARE:
542 case AUDIODRV_CTL_IOCTL_PAUSE_WRITE:
543 case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER:
544 case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION:
545 case AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN:
546 case AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE:
547 return (AudioInterfaceLibOutputRender(handle, cmdId, handleData));
548 case AUDIODRV_CTL_IOCTL_ELEM_WRITE:
549 case AUDIODRV_CTL_IOCTL_ELEM_READ:
550 case AUDIODRV_CTL_IOCTL_MUTE_WRITE:
551 case AUDIODRV_CTL_IOCTL_MUTE_READ:
552 case AUDIODRV_CTL_IOCTL_GAIN_WRITE:
553 case AUDIODRV_CTL_IOCTL_GAIN_READ:
554 case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE:
555 case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ:
556 case AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE:
557 case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ:
558 case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ:
559 return (AudioInterfaceLibCtlRender(handle, cmdId, handleData));
560 default:
561 AUDIO_FUNC_LOGE("Mode Error!");
562 break;
563 }
564 return HDF_ERR_NOT_SUPPORT;
565 }
566