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_capture.h"
17
18 #define HDF_LOG_TAG HDF_AUDIO_HAL_CAPTURE
19
AudioCtlCaptureSetPauseStu(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)20 int32_t AudioCtlCaptureSetPauseStu(
21 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
22 {
23 int32_t ret;
24 struct AlsaCapture *captureIns = NULL;
25 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
26
27 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
28 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
29
30 ret = captureIns->SetPauseState(captureIns, handleData->captureMode.ctlParam.pause);
31 if (ret != HDF_SUCCESS) {
32 AUDIO_FUNC_LOGE("Capture set pause failed!");
33 return HDF_FAILURE;
34 }
35
36 return HDF_SUCCESS;
37 }
38
AudioCtlCaptureGetVolume(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)39 int32_t AudioCtlCaptureGetVolume(
40 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
41 {
42 int32_t ret;
43 long vol;
44 struct AlsaCapture *captureIns = NULL;
45 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
46
47 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
48 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
49
50 ret = captureIns->GetVolume(captureIns, &vol);
51 if (ret != HDF_SUCCESS) {
52 AUDIO_FUNC_LOGE("Capture GetVolume failed!");
53 return HDF_FAILURE;
54 }
55 handleData->captureMode.ctlParam.volume = (float)vol;
56
57 return HDF_SUCCESS;
58 }
59
AudioCtlCaptureSetVolume(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)60 int32_t AudioCtlCaptureSetVolume(
61 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
62 {
63 int32_t ret;
64 long vol;
65 struct AlsaCapture *captureIns = NULL;
66 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
67
68 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
69 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
70
71 vol = (long)handleData->captureMode.ctlParam.volume;
72 ret = captureIns->SetVolume(captureIns, vol);
73 if (ret != HDF_SUCCESS) {
74 AUDIO_FUNC_LOGE("Capture SetVolume fail!");
75 return HDF_FAILURE;
76 }
77
78 return HDF_SUCCESS;
79 }
80
AudioCtlCaptureSetMuteStu(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)81 int32_t AudioCtlCaptureSetMuteStu(
82 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
83 {
84 int32_t ret;
85 struct AlsaCapture *captureIns = NULL;
86 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
87
88 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
89 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
90
91 ret = captureIns->SetMute(captureIns, handleData->captureMode.ctlParam.mute);
92 if (ret != HDF_SUCCESS) {
93 AUDIO_FUNC_LOGE("Capture set mute failed!");
94 return HDF_FAILURE;
95 }
96
97 return HDF_SUCCESS;
98 }
99
AudioCtlCaptureGetMuteStu(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)100 int32_t AudioCtlCaptureGetMuteStu(
101 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
102 {
103 struct AlsaCapture *captureIns = NULL;
104 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
105
106 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
107 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
108 handleData->captureMode.ctlParam.mute = captureIns->GetMute(captureIns);
109
110 return HDF_SUCCESS;
111 }
112
AudioCtlCaptureSetGainStu(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)113 int32_t AudioCtlCaptureSetGainStu(
114 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
115 {
116 int32_t ret;
117 float gainValue;
118 struct AlsaCapture *captureIns = NULL;
119 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
120
121 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
122 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
123
124 gainValue = handleData->captureMode.ctlParam.audioGain.gain;
125 ret = captureIns->SetGain(captureIns, gainValue);
126 if (ret != HDF_SUCCESS) {
127 AUDIO_FUNC_LOGE("Capture can not set gain!");
128 return HDF_FAILURE;
129 }
130
131 return HDF_SUCCESS;
132 }
133
AudioCtlCaptureGetGainStu(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)134 int32_t AudioCtlCaptureGetGainStu(
135 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
136 {
137 int32_t ret;
138 float gainValue;
139 struct AlsaCapture *captureIns = NULL;
140 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
141
142 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
143 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
144
145 ret = captureIns->GetGain(captureIns, &gainValue);
146 if (ret != HDF_SUCCESS) {
147 AUDIO_FUNC_LOGE("Capture get gain failed!");
148 return HDF_FAILURE;
149 }
150 handleData->captureMode.ctlParam.audioGain.gain = gainValue;
151
152 return HDF_SUCCESS;
153 }
154
AudioCtlCaptureSceneSelect(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)155 int32_t AudioCtlCaptureSceneSelect(
156 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
157 {
158 int32_t ret;
159 enum AudioPortPin descPins;
160 const struct PathDeviceInfo *deviceInfo;
161 struct AlsaCapture *captureIns = NULL;
162 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
163
164 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
165 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
166
167 descPins = handleData->captureMode.hwInfo.deviceDescript.pins;
168 deviceInfo = &handleData->captureMode.hwInfo.pathSelect.deviceInfo;
169 ret = captureIns->SelectScene(captureIns, descPins, deviceInfo);
170 if (ret != HDF_SUCCESS) {
171 AUDIO_FUNC_LOGE("Capture select scene pin: (0x%{public}x) failed", descPins);
172 return HDF_FAILURE;
173 }
174
175 AUDIO_FUNC_LOGD("Capture scene select pin: (0x%{public}x) success", descPins);
176 return HDF_SUCCESS;
177 }
178
AudioCtlCaptureGetGainThreshold(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)179 int32_t AudioCtlCaptureGetGainThreshold(
180 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
181 {
182 int32_t ret;
183 float gainMin = 0.0;
184 float gainMax = 1.0;
185 struct AlsaCapture *captureIns = NULL;
186 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
187
188 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
189 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
190
191 ret = captureIns->GetGainThreshold(captureIns, &gainMin, &gainMax);
192 if (ret != HDF_SUCCESS) {
193 AUDIO_FUNC_LOGE("Capture get gain threshold failed");
194 return HDF_FAILURE;
195 }
196 handleData->captureMode.ctlParam.audioGain.gainMin = gainMin;
197 handleData->captureMode.ctlParam.audioGain.gainMax = gainMax;
198
199 return HDF_SUCCESS;
200 }
201
AudioCtlCaptureGetVolThreshold(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)202 int32_t AudioCtlCaptureGetVolThreshold(
203 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
204 {
205 int32_t ret;
206 long volMax = MIN_VOLUME;
207 long volMin = MIN_VOLUME;
208 struct AlsaCapture *captureIns = NULL;
209 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
210
211 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
212 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
213
214 ret = captureIns->GetVolThreshold(captureIns, &volMin, &volMax);
215 if (ret != HDF_SUCCESS) {
216 AUDIO_FUNC_LOGE("Capture get volume threshold failed!");
217 }
218 handleData->captureMode.ctlParam.volThreshold.volMax = (int)volMax;
219 handleData->captureMode.ctlParam.volThreshold.volMin = (int)volMin;
220
221 return HDF_SUCCESS;
222 }
223
AudioInterfaceLibCtlCapture(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)224 int32_t AudioInterfaceLibCtlCapture(
225 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
226 {
227 int32_t ret;
228 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
229
230 switch (cmdId) {
231 /* setPara: */
232 case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE:
233 ret = AudioCtlCaptureSetVolume(handle, cmdId, handleData);
234 break;
235 case AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE:
236 ret = AudioCtlCaptureSetMuteStu(handle, cmdId, handleData);
237 break;
238 case AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE:
239 ret = AudioCtlCaptureGetMuteStu(handle, cmdId, handleData);
240 break;
241 /* getPara: */
242 case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE:
243 ret = AudioCtlCaptureGetVolume(handle, cmdId, handleData);
244 break;
245 case AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE:
246 ret = AudioCtlCaptureSetGainStu(handle, cmdId, handleData);
247 break;
248 case AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE:
249 ret = AudioCtlCaptureGetGainStu(handle, cmdId, handleData);
250 break;
251 case AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE:
252 ret = AudioCtlCaptureSceneSelect(handle, cmdId, handleData);
253 break;
254 case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE:
255 ret = AudioCtlCaptureGetGainThreshold(handle, cmdId, handleData);
256 break;
257 case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE:
258 ret = AudioCtlCaptureGetVolThreshold(handle, cmdId, handleData);
259 break;
260 default:
261 AUDIO_FUNC_LOGE("Ctl Mode not support!");
262 ret = HDF_FAILURE;
263 break;
264 }
265
266 return ret;
267 }
268
AudioOutputCaptureHwParams(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)269 int32_t AudioOutputCaptureHwParams(
270 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
271 {
272 int32_t ret;
273 struct AlsaCapture *captureIns = NULL;
274 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
275
276 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
277 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
278
279 if (SndGetRunState(&captureIns->soundCard) >= SND_PCM_STATE_RUNNING) {
280 AUDIO_FUNC_LOGE("Unable to set parameters during playback!");
281 return HDF_FAILURE;
282 }
283
284 ret = CaptureSetParams(captureIns, handleData);
285 if (ret != HDF_SUCCESS) {
286 AUDIO_FUNC_LOGE("Capture set parameters failed!");
287 return HDF_FAILURE;
288 }
289
290 AUDIO_FUNC_LOGI("Capture set hwparams success.");
291 return HDF_SUCCESS;
292 }
293
294 /*
295 * brief: Opens a capture PCM
296 * param mode Open mode (see #SND_PCM_NONBLOCK, #SND_PCM_ASYNC)
297 */
AudioOutputCaptureOpen(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)298 int32_t AudioOutputCaptureOpen(
299 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
300 {
301 int32_t ret;
302 struct AlsaCapture *captureIns = NULL;
303 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
304
305 captureIns = CaptureCreateInstance(handleData->captureMode.hwInfo.adapterName);
306 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
307
308 ret = captureIns->Open(captureIns);
309 if (ret != HDF_SUCCESS) {
310 AUDIO_FUNC_LOGE("Capture open pcm failed.");
311 return HDF_FAILURE;
312 }
313
314 ret = captureIns->Init(captureIns);
315 if (ret != HDF_SUCCESS) {
316 AUDIO_FUNC_LOGE("Capture init failed.");
317 return HDF_FAILURE;
318 }
319
320 AUDIO_FUNC_LOGI("Capture open success.");
321 return HDF_SUCCESS;
322 }
323
324
AudioOutputCaptureRead(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)325 int32_t AudioOutputCaptureRead(
326 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
327 {
328 int32_t ret;
329 struct AlsaCapture *captureIns = NULL;
330 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
331
332 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
333 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
334
335 ret = captureIns->Read(captureIns, handleData);
336 if (ret != HDF_SUCCESS) {
337 AUDIO_FUNC_LOGE("CaptureReadFrame failed");
338 return ret;
339 }
340
341 return HDF_SUCCESS;
342 }
343
AudioOutputCapturePrepare(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)344 int32_t AudioOutputCapturePrepare(
345 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
346 {
347 int32_t ret;
348 struct AlsaCapture *captureIns = NULL;
349 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
350
351 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
352 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
353
354 ret = SndPcmPrepare(&captureIns->soundCard);
355 if (ret < 0) {
356 AUDIO_FUNC_LOGE("pcm prepare fail");
357 return HDF_FAILURE;
358 }
359
360 return HDF_SUCCESS;
361 }
362
AudioOutputCaptureStart(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)363 int32_t AudioOutputCaptureStart(
364 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
365 {
366 int32_t ret;
367 struct AlsaCapture *captureIns = NULL;
368 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
369
370 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
371 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
372
373 ret = captureIns->Start(captureIns);
374 if (ret != HDF_SUCCESS) {
375 AUDIO_FUNC_LOGE("Capture start failed!");
376 return ret;
377 }
378
379 AUDIO_FUNC_LOGI("Capture start success.");
380 return HDF_SUCCESS;
381 }
382
AudioOutputCaptureStop(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)383 int32_t AudioOutputCaptureStop(
384 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
385 {
386 int32_t ret;
387 struct AlsaCapture *captureIns = NULL;
388 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
389
390 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
391 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
392
393 ret = captureIns->Stop(captureIns);
394 if (ret != HDF_SUCCESS) {
395 AUDIO_FUNC_LOGE("Capture stop route failed!");
396 return ret;
397 }
398
399 AUDIO_FUNC_LOGI("Capture stop success.");
400 return HDF_SUCCESS;
401 }
402
AudioOutputCaptureClose(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)403 int32_t AudioOutputCaptureClose(
404 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
405 {
406 struct AlsaCapture *captureIns = NULL;
407 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
408
409 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
410 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
411
412 captureIns->Close(captureIns);
413
414 AUDIO_FUNC_LOGI("Capture close success.");
415 return HDF_SUCCESS;
416 }
417
AudioOutputCaptureReqMmapBuffer(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)418 int32_t AudioOutputCaptureReqMmapBuffer(
419 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
420 {
421 int32_t ret;
422 struct AlsaCapture *captureIns = NULL;
423 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
424
425 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
426 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
427
428 ret = captureIns->MmapRead(captureIns, handleData);
429 if (ret != HDF_SUCCESS) {
430 AUDIO_FUNC_LOGE("Capture mmap write buffer failed!");
431 return ret;
432 }
433
434 return HDF_SUCCESS;
435 }
436
AudioOutputCaptureGetMmapPosition(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)437 int32_t AudioOutputCaptureGetMmapPosition(
438 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
439 {
440 struct AlsaCapture *captureIns = NULL;
441 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
442
443 captureIns = CaptureGetInstance(handleData->captureMode.hwInfo.adapterName);
444 CHECK_NULL_PTR_RETURN_DEFAULT(captureIns);
445 handleData->frameCaptureMode.frames = captureIns->GetMmapPosition(captureIns);
446
447 return HDF_SUCCESS;
448 }
449
AudioInterfaceLibOutputCapture(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)450 int32_t AudioInterfaceLibOutputCapture(
451 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
452 {
453 int32_t ret;
454 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
455
456 switch (cmdId) {
457 case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
458 ret = AudioOutputCaptureHwParams(handle, cmdId, handleData);
459 break;
460 case AUDIO_DRV_PCM_IOCTL_READ:
461 ret = AudioOutputCaptureRead(handle, cmdId, handleData);
462 break;
463 case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE:
464 ret = AudioOutputCaptureStart(handle, cmdId, handleData);
465 break;
466 case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE:
467 ret = AudioOutputCapturePrepare(handle, cmdId, handleData);
468 break;
469 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE:
470 ret = AudioOutputCaptureClose(handle, cmdId, handleData);
471 break;
472 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN:
473 ret = AudioOutputCaptureOpen(handle, cmdId, handleData);
474 break;
475 case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE:
476 ret = AudioOutputCaptureStop(handle, cmdId, handleData);
477 break;
478 case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE:
479 ret = AudioCtlCaptureSetPauseStu(handle, cmdId, handleData);
480 break;
481 case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE:
482 ret = AudioOutputCaptureReqMmapBuffer(handle, cmdId, handleData);
483 break;
484 case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE:
485 ret = AudioOutputCaptureGetMmapPosition(handle, cmdId, handleData);
486 break;
487 default:
488 AUDIO_FUNC_LOGE("Output Mode not support!");
489 ret = HDF_FAILURE;
490 break;
491 }
492
493 return ret;
494 }
495
AudioInterfaceLibModeCapture(const struct DevHandle * handle,struct AudioHwCaptureParam * handleData,int cmdId)496 int32_t AudioInterfaceLibModeCapture(
497 const struct DevHandle *handle, struct AudioHwCaptureParam *handleData, int cmdId)
498 {
499 CHECK_NULL_PTR_RETURN_DEFAULT(handleData);
500
501 switch (cmdId) {
502 case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
503 case AUDIO_DRV_PCM_IOCTL_READ:
504 case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE:
505 case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE:
506 case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE:
507 case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE:
508 case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE:
509 case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE:
510 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN:
511 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE:
512 return (AudioInterfaceLibOutputCapture(handle, cmdId, handleData));
513 case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE:
514 case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE:
515 case AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE:
516 case AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE:
517 case AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE:
518 case AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE:
519 case AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE:
520 case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE:
521 case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE:
522 return (AudioInterfaceLibCtlCapture(handle, cmdId, handleData));
523 default:
524 AUDIO_FUNC_LOGE("Mode Error!");
525 break;
526 }
527
528 return HDF_ERR_NOT_SUPPORT;
529 }
530