1 /*
2 * Copyright (c) 2022-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 "alsa_lib_capture.h"
17 #include "audio_common.h"
18 #include "osal_mem.h"
19 #include "securec.h"
20
21 #define HDF_LOG_TAG HDF_AUDIO_HAL_LIB
22
23 #define AUDIO_TIMESTAMP_FREQ 8 /* Hz */
24 #define AUDIO_SAMPLE_FREQ 48000
25 #define AUDIO_PERIOD ((AUDIO_SAMPLE_FREQ) / (AUDIO_TIMESTAMP_FREQ))
26 #define AUDIO_PCM_WAIT 100
27 #define AUDIO_RESUME_POLL (10 * (AUDIO_PCM_WAIT)) // 1s
28 #define ALSA_CAP_BUFFER_SIZE (2 * 2 * 6000) // format(S16LE) * channels(2) * period.
29
30 static unsigned int g_bufferTime = 500000; /* (0.5s): ring buffer length in us */
31 static unsigned int g_periodTime = 100000; /* (0.1s): period time in us */
32 static snd_pcm_sframes_t g_bufferSize = 0;
33 static snd_pcm_sframes_t g_periodSize = 0;
34 static int g_resample = 1; /* enable alsa-lib resampling */
35 static bool g_periodEvent = false; /* produce poll event after each period */
36 static int g_canPause = 0; /* 0 Hardware doesn't support pause, 1 Hardware supports pause */
37
AudioCaptureSetPauseState(snd_pcm_t * pcm,int32_t pause)38 static int32_t AudioCaptureSetPauseState(snd_pcm_t *pcm, int32_t pause)
39 {
40 int32_t ret;
41
42 if (pcm == NULL) {
43 AUDIO_FUNC_LOGE("Param is NULL!");
44 return HDF_FAILURE;
45 }
46
47 if (pause == AUDIO_ALSALIB_IOCTRL_RESUME) {
48 ret = snd_pcm_prepare(pcm);
49 if (ret < 0) {
50 AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret));
51 return HDF_FAILURE;
52 }
53 ret = snd_pcm_start(pcm);
54 if (ret < 0) {
55 AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret));
56 return HDF_FAILURE;
57 }
58 }
59
60 if (pause == AUDIO_ALSALIB_IOCTRL_PAUSE) {
61 ret = snd_pcm_drop(pcm);
62 if (ret < 0) {
63 AUDIO_FUNC_LOGE("Pause fail: %{public}s", snd_strerror(ret));
64 return HDF_FAILURE;
65 }
66 }
67
68 return HDF_SUCCESS;
69 }
70
AudioCtlCaptureSetPauseStu(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)71 int32_t AudioCtlCaptureSetPauseStu(
72 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
73 {
74 int32_t ret;
75 int32_t pause;
76 struct AudioCardInfo *cardIns;
77
78 (void)cmdId;
79 if (handle == NULL || handleData == NULL) {
80 AUDIO_FUNC_LOGE("Param is NULL!");
81 return HDF_FAILURE;
82 }
83
84 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
85 cardIns = GetCardIns(adapterName);
86 if (cardIns == NULL) {
87 AUDIO_FUNC_LOGE("cardIns or capturePcmHandle is NULL!");
88 return HDF_FAILURE;
89 }
90
91 pause = handleData->captureMode.ctlParam.pause ? AUDIO_ALSALIB_IOCTRL_PAUSE : AUDIO_ALSALIB_IOCTRL_RESUME;
92 ret = AudioCaptureSetPauseState(cardIns->capturePcmHandle, pause);
93 if (ret != HDF_SUCCESS) {
94 AUDIO_FUNC_LOGE("set pause error!");
95 return HDF_FAILURE;
96 }
97
98 return HDF_SUCCESS;
99 }
100
AudioCaptureMixerGetVolume(snd_mixer_t * mixer,snd_mixer_elem_t * pcmElemen,long * vol)101 static int32_t AudioCaptureMixerGetVolume(snd_mixer_t *mixer, snd_mixer_elem_t *pcmElemen, long *vol)
102 {
103 long volLeft = MIN_VOLUME;
104 long volRight = MIN_VOLUME;
105
106 if (mixer == NULL || pcmElemen == NULL || vol == NULL) {
107 AUDIO_FUNC_LOGE("Parameter error!");
108 return HDF_FAILURE;
109 }
110 /* Handling events */
111 int32_t ret = snd_mixer_handle_events(mixer);
112 if (ret < 0) {
113 AUDIO_FUNC_LOGE("snd_mixer_handle_events fail!");
114 return HDF_FAILURE;
115 }
116
117 /* Left channel */
118 ret = snd_mixer_selem_get_capture_volume(pcmElemen, SND_MIXER_SCHN_FRONT_LEFT, &volLeft);
119 if (ret < 0) {
120 AUDIO_FUNC_LOGE("Get left channel fail!");
121 return HDF_FAILURE;
122 }
123 /* right channel */
124 ret = snd_mixer_selem_get_capture_volume(pcmElemen, SND_MIXER_SCHN_FRONT_RIGHT, &volRight);
125 if (ret < 0) {
126 AUDIO_FUNC_LOGE("Get right channel fail!");
127 return HDF_FAILURE;
128 }
129 *vol = (volLeft + volRight) >> 1;
130
131 return HDF_SUCCESS;
132 }
133
AudioCtlCaptureGetVolume(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)134 int32_t AudioCtlCaptureGetVolume(const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
135 {
136 int32_t ret;
137 long vol = 0;
138 struct AudioCardInfo *cardIns;
139
140 (void)cmdId;
141 if (handle == NULL || handleData == NULL) {
142 AUDIO_FUNC_LOGE("AudioCtlCaptureSetVolume parameter is NULL!");
143 return HDF_FAILURE;
144 }
145
146 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
147 cardIns = GetCardIns(adapterName);
148 if (cardIns == NULL) {
149 AUDIO_FUNC_LOGE("Unable to obtain correct sound card information!");
150 return HDF_FAILURE;
151 }
152
153 if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) {
154 if (cardIns->volElemList == NULL || cardIns->volElemList[0].elem == NULL) {
155 AUDIO_FUNC_LOGE("ctrlVolumeList is NULL!");
156 return HDF_FAILURE;
157 }
158 ret = AudioCaptureMixerGetVolume(cardIns->mixer, cardIns->volElemList[0].elem, &vol);
159 if (ret < 0) {
160 AUDIO_FUNC_LOGE("Get primary volume failed!");
161 return ret;
162 }
163 handleData->captureMode.ctlParam.volume = (float)(vol);
164 return HDF_SUCCESS;
165 }
166
167 if (strncmp(adapterName, USB, strlen(USB)) == 0) {
168 if (cardIns->usbCtlVolume == NULL) {
169 AUDIO_FUNC_LOGE("usbCtlVolume is NULL, the volume setting may not be supported!");
170 return HDF_FAILURE;
171 }
172 ret = AudioCaptureMixerGetVolume(cardIns->mixer, cardIns->usbCtlVolume, &vol);
173 if (ret < 0) {
174 AUDIO_FUNC_LOGE("Get usb volume failed!");
175 return ret;
176 }
177 handleData->captureMode.ctlParam.volume = (float)(vol);
178 return HDF_SUCCESS;
179 }
180 /* Special external sound recording card, no volume control, return not supported */
181 return HDF_ERR_NOT_SUPPORT;
182 }
183
AudioCaptureSetMixerVolume(snd_mixer_elem_t * pcmElemen,long vol)184 static int32_t AudioCaptureSetMixerVolume(snd_mixer_elem_t *pcmElemen, long vol)
185 {
186 int32_t ret;
187
188 if (pcmElemen == NULL) {
189 AUDIO_FUNC_LOGE("parameter is NULL!");
190 return HDF_FAILURE;
191 }
192
193 /* Judge whether it is mono or stereo */
194 ret = snd_mixer_selem_is_capture_mono(pcmElemen);
195 if (ret == 1) { // mono
196 ret = snd_mixer_selem_set_capture_volume(pcmElemen, SND_MIXER_SCHN_MONO, vol);
197 if (ret < 0) {
198 AUDIO_FUNC_LOGE("Failed to set volume: %{public}s.", snd_strerror(ret));
199 return HDF_FAILURE;
200 }
201 } else { // ret == 0: is not mono. (stereo)
202 ret = snd_mixer_selem_set_capture_volume_all(pcmElemen, vol);
203 if (ret < 0) {
204 AUDIO_FUNC_LOGE("Failed to set all channel volume: %{public}s.", snd_strerror(ret));
205 return HDF_FAILURE;
206 }
207 }
208
209 return HDF_SUCCESS;
210 }
211
AudioCtlCaptureSetVolume(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)212 int32_t AudioCtlCaptureSetVolume(
213 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
214 {
215 int32_t ret;
216 int32_t vol;
217 struct AudioCardInfo *cardIns;
218
219 (void)cmdId;
220 if (handle == NULL || handleData == NULL) {
221 AUDIO_FUNC_LOGE("parameter is NULL!");
222 return HDF_FAILURE;
223 }
224
225 vol = (int32_t)handleData->captureMode.ctlParam.volume;
226 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
227 cardIns = GetCardIns(adapterName);
228 if (cardIns == NULL) {
229 AUDIO_FUNC_LOGE("cardIns is NULL!");
230 return HDF_FAILURE;
231 }
232
233 if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) {
234 if (cardIns->volElemList == NULL) {
235 AUDIO_FUNC_LOGE("Get capture ctrlVolumeList is NULL!");
236 return HDF_FAILURE;
237 }
238 for (int32_t index = 0; index < (int32_t)cardIns->volElemCount; index++) {
239 if (cardIns->volElemList[index].elem == NULL) {
240 AUDIO_FUNC_LOGE("Get capture ctrlVolume is NULL!");
241 return HDF_FAILURE;
242 }
243 ret = AudioCaptureSetMixerVolume(cardIns->volElemList[index].elem, vol);
244 if (ret < 0) {
245 AUDIO_FUNC_LOGE("primary set volume failed!");
246 return ret;
247 }
248 }
249 return HDF_SUCCESS;
250 }
251
252 if (strncmp(adapterName, USB, strlen(USB)) == 0) {
253 if (cardIns->usbCtlVolume != NULL) {
254 ret = AudioCaptureSetMixerVolume(cardIns->usbCtlVolume, vol);
255 if (ret < 0) {
256 AUDIO_FUNC_LOGE("usb set volume failed!");
257 return ret;
258 }
259 return HDF_SUCCESS;
260 }
261 }
262
263 /* Special external sound recording card, no volume control, return not supported */
264 return HDF_ERR_NOT_SUPPORT;
265 }
266
AudioCaptureSetMuteState(struct AudioCardInfo * cardIns,int32_t muteState,const char * adapterName,float volume)267 static int32_t AudioCaptureSetMuteState(
268 struct AudioCardInfo *cardIns, int32_t muteState, const char *adapterName, float volume)
269 {
270 long vol;
271 long setVol;
272 float volRangeMin = 0.0;
273 float volRangeMax = 100.0;
274 if (cardIns == NULL || cardIns->volElemList == NULL) {
275 AUDIO_FUNC_LOGE("Parameter error!");
276 return HDF_FAILURE;
277 }
278 int32_t ret = AudioCaptureMixerGetVolume(cardIns->mixer, cardIns->volElemList[0].elem, &vol);
279 if (ret < 0) {
280 AUDIO_FUNC_LOGE("AudioCaptureMixerGetVolume fail!");
281 return ret;
282 }
283
284 if (muteState == false) {
285 setVol = 0; // 0 for mute
286 cardIns->tempVolume = (float)vol;
287 } else {
288 if (volume > volRangeMin && volume <= volRangeMax) {
289 setVol = (long)volume;
290 } else {
291 setVol = (long)cardIns->tempVolume;
292 }
293 }
294
295 for (int i = 0; i < (int32_t)cardIns->volElemCount; i++) {
296 if (cardIns->volElemList[i].elem == NULL) {
297 AUDIO_FUNC_LOGE("AudioCapture get volElemList fail!");
298 return HDF_FAILURE;
299 }
300 ret = AudioCaptureSetMixerVolume(cardIns->volElemList[i].elem, setVol);
301 if (ret < 0) {
302 AUDIO_FUNC_LOGE("AudioCaptureSetMixerVolume fail!");
303 return HDF_FAILURE;
304 }
305 }
306 return HDF_SUCCESS;
307 }
308
AudioUsbSetMute(snd_mixer_elem_t * pcmElemen,int32_t muteState)309 static int32_t AudioUsbSetMute(snd_mixer_elem_t *pcmElemen, int32_t muteState)
310 {
311 int32_t ret;
312
313 if (pcmElemen == NULL) {
314 AUDIO_FUNC_LOGE("cardIns is NULL!");
315 return HDF_FAILURE;
316 }
317 ret = snd_mixer_selem_has_capture_switch(pcmElemen);
318 if (ret == 1) { // 1: Controlled switch
319 ret = snd_mixer_selem_set_capture_switch_all(pcmElemen, muteState);
320 if (ret < 0) {
321 AUDIO_FUNC_LOGE("Unable to set mute: %{public}s.", snd_strerror(ret));
322 return HDF_FAILURE;
323 }
324 } else { // 0: no control
325 AUDIO_FUNC_LOGE("it's no control is present");
326 return HDF_FAILURE;
327 }
328
329 return HDF_SUCCESS;
330 }
331
AudioCtlCaptureSetMuteStu(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)332 int32_t AudioCtlCaptureSetMuteStu(
333 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
334 {
335 int32_t ret;
336 bool muteState;
337
338 (void)cmdId;
339 if (handle == NULL || handleData == NULL) {
340 AUDIO_FUNC_LOGE("param is NULL!");
341 return HDF_FAILURE;
342 }
343
344 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
345 struct AudioCardInfo *cardIns = GetCardIns(adapterName);
346 if (cardIns == NULL) {
347 AUDIO_FUNC_LOGE("cardIns is empty pointer!!!");
348 return HDF_FAILURE;
349 }
350 muteState = (bool)cardIns->captureMuteValue;
351 if (strncmp(adapterName, USB, strlen(USB)) == 0) {
352 if (AudioUsbSetMute(cardIns->usbCtlVolume, muteState) != HDF_SUCCESS) {
353 AUDIO_FUNC_LOGE("AudioUsbSetMute failed!");
354 return HDF_FAILURE;
355 }
356 }
357 if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) {
358 ret = AudioCaptureSetMuteState(cardIns, muteState, adapterName, handleData->captureMode.ctlParam.volume);
359 if (ret < 0) {
360 AUDIO_FUNC_LOGE("Render primary sound card SetMute failed!");
361 return HDF_FAILURE;
362 }
363 }
364
365 cardIns->captureMuteValue = (int32_t)handleData->captureMode.ctlParam.mute;
366 return HDF_SUCCESS;
367 }
368
AudioCtlCaptureGetMuteStu(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)369 int32_t AudioCtlCaptureGetMuteStu(const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
370 {
371 struct AudioCardInfo *cardInstance;
372
373 (void)cmdId;
374 if (handle == NULL || handleData == NULL) {
375 AUDIO_FUNC_LOGE("param is NULL!");
376 return HDF_FAILURE;
377 }
378
379 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
380 cardInstance = GetCardIns(adapterName);
381 if (cardInstance == NULL) {
382 AUDIO_FUNC_LOGE("cardInsance is null pointer!!");
383 return HDF_FAILURE;
384 }
385
386 handleData->captureMode.ctlParam.mute = (bool)cardInstance->captureMuteValue;
387 return HDF_SUCCESS;
388 }
389
AudioCtlCaptureSetGainStu(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)390 int32_t AudioCtlCaptureSetGainStu(
391 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
392 {
393 (void)cmdId;
394 if (handle == NULL || handleData == NULL) {
395 AUDIO_FUNC_LOGE("param is NULL!");
396 return HDF_FAILURE;
397 }
398
399 return HDF_SUCCESS;
400 }
401
AudioCtlCaptureGetGainStu(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)402 int32_t AudioCtlCaptureGetGainStu(const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
403 {
404 (void)cmdId;
405 if (handle == NULL || handleData == NULL) {
406 AUDIO_FUNC_LOGE("param is NULL!");
407 return HDF_FAILURE;
408 }
409
410 return HDF_SUCCESS;
411 }
412
AudioCtlCaptureSceneSelect(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)413 int32_t AudioCtlCaptureSceneSelect(
414 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
415 {
416 (void)cmdId;
417 if (handle == NULL || handleData == NULL) {
418 AUDIO_FUNC_LOGE("param is NULL!");
419 return HDF_FAILURE;
420 }
421 if (strcmp(handleData->captureMode.hwInfo.adapterName, USB) == 0 ||
422 strcmp(handleData->captureMode.hwInfo.adapterName, HDMI) == 0) {
423 return HDF_SUCCESS;
424 }
425 int32_t ret = EnableAudioCaptureRoute(handleData);
426 if (ret < 0) {
427 AUDIO_FUNC_LOGE("EnableAudioRoute failed!");
428 return ret;
429 }
430 return HDF_SUCCESS;
431 }
432
AudioCtlCaptureGetGainThreshold(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)433 int32_t AudioCtlCaptureGetGainThreshold(
434 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
435 {
436 (void)cmdId;
437 if (handle == NULL || handleData == NULL) {
438 AUDIO_FUNC_LOGE("param is NULL!");
439 return HDF_FAILURE;
440 }
441
442 return HDF_SUCCESS;
443 }
444
AudioCtlCaptureGetVolThreshold(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)445 int32_t AudioCtlCaptureGetVolThreshold(
446 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
447 {
448 int32_t ret;
449 long volMax = MIN_VOLUME;
450 long volMin = MIN_VOLUME;
451
452 (void)cmdId;
453 if (handle == NULL || handleData == NULL) {
454 AUDIO_FUNC_LOGE("Param is NULL!");
455 return HDF_FAILURE;
456 }
457
458 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
459 struct AudioCardInfo *cardIns = GetCardIns(adapterName);
460 if (cardIns == NULL) {
461 AUDIO_FUNC_LOGE("cardIns is NULL!!!");
462 return HDF_FAILURE;
463 }
464
465 if (strncmp(adapterName, USB, strlen(USB)) == 0 || strncmp(adapterName, HDMI, strlen(HDMI)) == 0) {
466 handleData->captureMode.ctlParam.volThreshold.volMax = MAX_VOLUME;
467 handleData->captureMode.ctlParam.volThreshold.volMin = MIN_VOLUME;
468 return HDF_SUCCESS;
469 }
470
471 ret = snd_mixer_selem_get_capture_volume_range(cardIns->volElemList[0].elem, &volMin, &volMax);
472 if (ret < 0) {
473 AUDIO_FUNC_LOGE("Get capture volume range fail: %{public}s.", snd_strerror(ret));
474 return HDF_FAILURE;
475 }
476 handleData->captureMode.ctlParam.volThreshold.volMax = (int)volMax;
477 handleData->captureMode.ctlParam.volThreshold.volMin = (int)volMin;
478
479 return HDF_SUCCESS;
480 }
481
AudioInterfaceLibCtlCapture(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)482 int32_t AudioInterfaceLibCtlCapture(const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
483 {
484 int32_t ret;
485
486 if (handle == NULL || handleData == NULL) {
487 AUDIO_FUNC_LOGE("param is NULL!");
488 return HDF_FAILURE;
489 }
490
491 switch (cmdId) {
492 /* setPara: */
493 case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE:
494 ret = AudioCtlCaptureSetVolume(handle, cmdId, handleData);
495 break;
496 case AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE:
497 ret = AudioCtlCaptureSetMuteStu(handle, cmdId, handleData);
498 break;
499 case AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE:
500 ret = AudioCtlCaptureGetMuteStu(handle, cmdId, handleData);
501 break;
502 /* getPara: */
503 case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE:
504 ret = AudioCtlCaptureGetVolume(handle, cmdId, handleData);
505 break;
506 case AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE:
507 ret = AudioCtlCaptureSetGainStu(handle, cmdId, handleData);
508 break;
509 case AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE:
510 ret = AudioCtlCaptureGetGainStu(handle, cmdId, handleData);
511 break;
512 case AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE:
513 ret = AudioCtlCaptureSceneSelect(handle, cmdId, handleData);
514 break;
515 case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE:
516 ret = AudioCtlCaptureGetGainThreshold(handle, cmdId, handleData);
517 break;
518 case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE:
519 ret = AudioCtlCaptureGetVolThreshold(handle, cmdId, handleData);
520 break;
521 default:
522 AUDIO_FUNC_LOGE("Ctl Mode not support!");
523 ret = HDF_FAILURE;
524 break;
525 }
526
527 return ret;
528 }
529
GetCapHwParams(struct AudioCardInfo * cardIns,const struct AudioHwCaptureParam * handleData)530 static int32_t GetCapHwParams(struct AudioCardInfo *cardIns, const struct AudioHwCaptureParam *handleData)
531 {
532 if (cardIns == NULL || handleData == NULL) {
533 AUDIO_FUNC_LOGE("Parameter is NULL!");
534 return HDF_FAILURE;
535 }
536
537 cardIns->hwCaptureParams.streamType = AUDIO_CAPTURE_STREAM;
538 cardIns->hwCaptureParams.channels = handleData->frameCaptureMode.attrs.channelCount;
539 cardIns->hwCaptureParams.rate = handleData->frameCaptureMode.attrs.sampleRate;
540 cardIns->hwCaptureParams.periodSize = handleData->frameCaptureMode.periodSize;
541 cardIns->hwCaptureParams.periodCount = handleData->frameCaptureMode.periodCount;
542 cardIns->hwCaptureParams.format = handleData->frameCaptureMode.attrs.format;
543 cardIns->hwCaptureParams.period = handleData->frameCaptureMode.attrs.period;
544 cardIns->hwCaptureParams.frameSize = handleData->frameCaptureMode.attrs.frameSize;
545 cardIns->hwCaptureParams.isBigEndian = handleData->frameCaptureMode.attrs.isBigEndian;
546 cardIns->hwCaptureParams.isSignedData = handleData->frameCaptureMode.attrs.isSignedData;
547 cardIns->hwCaptureParams.startThreshold = handleData->frameCaptureMode.attrs.startThreshold;
548 cardIns->hwCaptureParams.stopThreshold = handleData->frameCaptureMode.attrs.stopThreshold;
549 cardIns->hwCaptureParams.silenceThreshold = handleData->frameCaptureMode.attrs.silenceThreshold;
550
551 return HDF_SUCCESS;
552 }
553
SetHWParamsSub(snd_pcm_t * handle,snd_pcm_hw_params_t * params,struct AudioPcmHwParams hwCapParams,snd_pcm_access_t access)554 static int32_t SetHWParamsSub(
555 snd_pcm_t *handle, snd_pcm_hw_params_t *params, struct AudioPcmHwParams hwCapParams, snd_pcm_access_t access)
556 {
557 int32_t ret;
558 snd_pcm_format_t pcmFormat;
559
560 if (handle == NULL || params == NULL) {
561 AUDIO_FUNC_LOGE("SetHWParamsSub parameter is null!");
562 return HDF_FAILURE;
563 }
564
565 ret = snd_pcm_hw_params_set_rate_resample(handle, params, g_resample);
566 if (ret < 0) {
567 AUDIO_FUNC_LOGE("Resampling setup failed for capture: %{public}s", snd_strerror(ret));
568 return HDF_FAILURE;
569 }
570
571 /* set the interleaved read/write format */
572 ret = snd_pcm_hw_params_set_access(handle, params, access);
573 if (ret < 0) {
574 AUDIO_FUNC_LOGE("Access type not available for capture: %{public}s", snd_strerror(ret));
575 return HDF_FAILURE;
576 }
577 ret = CheckParaFormat(hwCapParams, &pcmFormat);
578 if (ret != HDF_SUCCESS) {
579 AUDIO_FUNC_LOGE("CheckParaFormat error.");
580 return ret;
581 }
582 /* set the sample format */
583 ret = snd_pcm_hw_params_set_format(handle, params, pcmFormat);
584 if (ret < 0) {
585 AUDIO_FUNC_LOGE("Sample format not available for capture: %{public}s", snd_strerror(ret));
586 return HDF_FAILURE;
587 }
588
589 /* set the count of channels */
590 ret = snd_pcm_hw_params_set_channels(handle, params, hwCapParams.channels);
591 if (ret < 0) {
592 AUDIO_FUNC_LOGE("Channels count (%{public}u) not available for capture: %{public}s", hwCapParams.channels,
593 snd_strerror(ret));
594 return HDF_FAILURE;
595 }
596
597 return HDF_SUCCESS;
598 }
599
SetHWRate(snd_pcm_t * handle,snd_pcm_hw_params_t * params,uint32_t * rate)600 static int32_t SetHWRate(snd_pcm_t *handle, snd_pcm_hw_params_t *params, uint32_t *rate)
601 {
602 int32_t ret;
603 uint32_t rRate;
604 int32_t dir = 0; /* dir Value range (-1,0,1) */
605
606 if (handle == NULL || params == NULL || rate == NULL) {
607 AUDIO_FUNC_LOGE("SetHWParams parameter is null!");
608 return HDF_FAILURE;
609 }
610
611 /* set the stream rate */
612 rRate = *rate;
613 ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir);
614 if (ret < 0) {
615 AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", *rate, snd_strerror(ret));
616 return HDF_FAILURE;
617 }
618
619 if (rRate != *rate) {
620 ret = snd_pcm_hw_params_set_rate_near(handle, params, &rRate, &dir);
621 if (ret < 0) {
622 AUDIO_FUNC_LOGE("Rate %{public}uHz not available for capture: %{public}s", *rate, snd_strerror(ret));
623 return HDF_FAILURE;
624 }
625 }
626 /* Update to hardware supported rate */
627 *rate = rRate;
628
629 g_canPause = snd_pcm_hw_params_can_pause(params);
630
631 return HDF_SUCCESS;
632 }
633
SetHWBuffer(snd_pcm_t * handle,snd_pcm_hw_params_t * params)634 static int32_t SetHWBuffer(snd_pcm_t *handle, snd_pcm_hw_params_t *params)
635 {
636 int32_t ret;
637 int32_t dir = 0; /* dir Value range (-1,0,1) */
638 snd_pcm_uframes_t size = 0;
639
640 if (handle == NULL || params == NULL) {
641 AUDIO_FUNC_LOGE("SetHWParams parameter is null!");
642 return HDF_FAILURE;
643 }
644
645 ret = snd_pcm_hw_params_set_buffer_time_near(handle, params, &g_bufferTime, &dir);
646 if (ret < 0) {
647 AUDIO_FUNC_LOGE(
648 "Unable to set buffer time %{public}u for capture: %{public}s", g_bufferTime, snd_strerror(ret));
649 return HDF_FAILURE;
650 }
651
652 ret = snd_pcm_hw_params_get_buffer_size(params, &size);
653 if (ret < 0) {
654 AUDIO_FUNC_LOGE("Unable to get buffer size for capture: %{public}s", snd_strerror(ret));
655 return HDF_FAILURE;
656 }
657 g_bufferSize = size;
658
659 return HDF_SUCCESS;
660 }
661
SetHWPeriod(snd_pcm_t * handle,snd_pcm_hw_params_t * params)662 static int32_t SetHWPeriod(snd_pcm_t *handle, snd_pcm_hw_params_t *params)
663 {
664 int32_t ret;
665 int32_t dir = 0; /* dir Value range (-1,0,1) */
666 snd_pcm_uframes_t size = 0;
667
668 if (handle == NULL || params == NULL) {
669 AUDIO_FUNC_LOGE("SetHWParams parameter is null!");
670 return HDF_FAILURE;
671 }
672
673 ret = snd_pcm_hw_params_set_period_time_near(handle, params, &g_periodTime, &dir);
674 if (ret < 0) {
675 AUDIO_FUNC_LOGE(
676 "Unable to set period time %{public}u for capture: %{public}s", g_periodTime, snd_strerror(ret));
677 return HDF_FAILURE;
678 }
679
680 ret = snd_pcm_hw_params_get_period_size(params, &size, &dir);
681 if (ret < 0) {
682 AUDIO_FUNC_LOGE("Unable to get period size for capture: %{public}s", snd_strerror(ret));
683 return HDF_FAILURE;
684 }
685 g_periodSize = size;
686
687 return HDF_SUCCESS;
688 }
689
SetHWParams(snd_pcm_t * handle,snd_pcm_hw_params_t * params,struct AudioPcmHwParams hwCapParams,snd_pcm_access_t access)690 static int32_t SetHWParams(
691 snd_pcm_t *handle, snd_pcm_hw_params_t *params, struct AudioPcmHwParams hwCapParams, snd_pcm_access_t access)
692 {
693 int32_t ret;
694
695 if (handle == NULL || params == NULL) {
696 AUDIO_FUNC_LOGE("SetHWParams parameter is null!");
697 return HDF_FAILURE;
698 }
699
700 ret = snd_pcm_hw_params_any(handle, params); // choose all parameters
701 if (ret < 0) {
702 AUDIO_FUNC_LOGE(
703 "Broken configuration for capture: no configurations available: %{public}s.", snd_strerror(ret));
704 return HDF_FAILURE;
705 }
706
707 ret = SetHWParamsSub(handle, params, hwCapParams, access);
708 if (ret != HDF_SUCCESS) {
709 AUDIO_FUNC_LOGE("SetHWParamsSub failed!");
710 return ret;
711 }
712
713 ret = SetHWRate(handle, params, &(hwCapParams.rate));
714 if (ret != HDF_SUCCESS) {
715 AUDIO_FUNC_LOGE("SetHWRate failed!");
716 return ret;
717 }
718
719 ret = SetHWBuffer(handle, params);
720 if (ret != HDF_SUCCESS) {
721 AUDIO_FUNC_LOGE("SetHWBuffer failed!");
722 return ret;
723 }
724
725 ret = SetHWPeriod(handle, params);
726 if (ret != HDF_SUCCESS) {
727 AUDIO_FUNC_LOGE("SetHWPeriod failed!");
728 return ret;
729 }
730
731 /* write the parameters to device. */
732 ret = snd_pcm_hw_params(handle, params);
733 if (ret < 0) {
734 AUDIO_FUNC_LOGE("Unable to set hw params for capture: %{public}s", snd_strerror(ret));
735 return HDF_FAILURE;
736 }
737
738 return HDF_SUCCESS;
739 }
740
SetSWParams(snd_pcm_t * handle,snd_pcm_sw_params_t * swparams)741 static int32_t SetSWParams(snd_pcm_t *handle, snd_pcm_sw_params_t *swparams)
742 {
743 int32_t ret;
744 /* The time when the application starts reading data */
745 snd_pcm_sframes_t startThresholdSize = 1;
746
747 if (handle == NULL || swparams == NULL) {
748 AUDIO_FUNC_LOGE("SetHWParams parameter is null!");
749 return HDF_FAILURE;
750 }
751
752 /* get the current swparams */
753 ret = snd_pcm_sw_params_current(handle, swparams);
754 if (ret < 0) {
755 AUDIO_FUNC_LOGE("Unable to determine current swparams for capture: %{public}s.", snd_strerror(ret));
756 return HDF_FAILURE;
757 }
758
759 if (g_periodSize == 0) {
760 AUDIO_FUNC_LOGE("error: g_periodSize cannot be zero!");
761 return HDF_FAILURE;
762 }
763 /* start the transfer when the buffer is 1 frames: */
764 ret = snd_pcm_sw_params_set_start_threshold(handle, swparams, startThresholdSize);
765 if (ret < 0) {
766 AUDIO_FUNC_LOGE("Unable to set start threshold mode for capture: %{public}s.", snd_strerror(ret));
767 return HDF_FAILURE;
768 }
769
770 /* allow the transfer when at least period_size samples can be processed */
771 /* or disable this mechanism when period event is enabled (aka interrupt like style processing) */
772 ret = snd_pcm_sw_params_set_avail_min(handle, swparams, g_periodEvent ? g_bufferSize : g_periodSize);
773 if (ret < 0) {
774 AUDIO_FUNC_LOGE("Unable to set avail min for capture: %{public}s", snd_strerror(ret));
775 return HDF_FAILURE;
776 }
777
778 /* enable period events when requested */
779 if (g_periodEvent) {
780 ret = snd_pcm_sw_params_set_period_event(handle, swparams, 1);
781 if (ret < 0) {
782 AUDIO_FUNC_LOGE("Unable to set period event: %{public}s", snd_strerror(ret));
783 return HDF_FAILURE;
784 }
785 }
786
787 /* write the parameters to the capture device */
788 ret = snd_pcm_sw_params(handle, swparams);
789 if (ret < 0) {
790 AUDIO_FUNC_LOGE("Unable to set sw params for capture: %{public}s", snd_strerror(ret));
791 return HDF_FAILURE;
792 }
793
794 return HDF_SUCCESS;
795 }
796
AudioOutputCaptureHwParams(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)797 int32_t AudioOutputCaptureHwParams(
798 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
799 {
800 int32_t ret;
801 struct AudioCardInfo *cardIns;
802 snd_pcm_hw_params_t *hwParams = NULL;
803 snd_pcm_sw_params_t *swParams = NULL;
804
805 (void)cmdId;
806 if (handle == NULL || handleData == NULL) {
807 AUDIO_FUNC_LOGE("The parameter is empty");
808 return HDF_FAILURE;
809 }
810
811 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
812 cardIns = GetCardIns(adapterName);
813 if (cardIns == NULL) {
814 AUDIO_FUNC_LOGE("cardIns is NULL!");
815 return HDF_FAILURE;
816 }
817
818 ret = (int32_t)snd_pcm_state(cardIns->capturePcmHandle);
819 if (ret >= SND_PCM_STATE_RUNNING) {
820 AUDIO_FUNC_LOGE("Unable to set parameters during capture!");
821 return HDF_FAILURE;
822 }
823
824 ret = GetCapHwParams(cardIns, handleData);
825 if (ret != HDF_SUCCESS) {
826 AUDIO_FUNC_LOGE("GetCapHwParams error.");
827 return ret;
828 }
829
830 snd_pcm_hw_params_alloca(&hwParams);
831 snd_pcm_sw_params_alloca(&swParams);
832 ret = SetHWParams(cardIns->capturePcmHandle, hwParams, cardIns->hwCaptureParams, SND_PCM_ACCESS_RW_INTERLEAVED);
833 if (ret != HDF_SUCCESS) {
834 AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}d.", ret);
835 return ret;
836 }
837 ret = SetSWParams(cardIns->capturePcmHandle, swParams);
838 if (ret != HDF_SUCCESS) {
839 AUDIO_FUNC_LOGE("Setting of swparams failed: %{public}d.", ret);
840 return ret;
841 }
842
843 return HDF_SUCCESS;
844 }
845
846 /*
847 * brief: Opens a capture PCM
848 * param mode Open mode (see #SND_PCM_NONBLOCK, #SND_PCM_ASYNC)
849 */
AudioOutputCaptureOpen(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)850 int32_t AudioOutputCaptureOpen(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
851 {
852 int32_t ret;
853 struct AudioCardInfo *cardIns;
854
855 (void)cmdId;
856 if (handle == NULL || handleData == NULL) {
857 AUDIO_FUNC_LOGE("Function parameter is NULL!");
858 return HDF_FAILURE;
859 }
860
861 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
862 cardIns = AudioGetCardInstance(adapterName);
863 if (cardIns == NULL) {
864 AUDIO_FUNC_LOGE("AudioCaptureGetCardIns failed.");
865 (void)DestroyCardList();
866 return HDF_FAILURE;
867 }
868 ret = AudioGetCardInfo(cardIns, adapterName, SND_PCM_STREAM_CAPTURE);
869 if (ret != HDF_SUCCESS) {
870 CheckCardStatus(cardIns);
871 (void)DestroyCardList();
872 return HDF_FAILURE;
873 }
874 if (cardIns->capturePcmHandle != NULL) {
875 AUDIO_FUNC_LOGE("Resource busy!!");
876 CheckCardStatus(cardIns);
877 (void)DestroyCardList();
878 return HDF_ERR_DEVICE_BUSY;
879 }
880 ret = snd_pcm_open(&cardIns->capturePcmHandle, cardIns->devName, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
881 if (ret < 0) {
882 AUDIO_FUNC_LOGE("Capture open device error: %{public}s.", snd_strerror(ret));
883 CheckCardStatus(cardIns);
884 (void)DestroyCardList();
885 return HDF_FAILURE;
886 }
887 InitSound(&cardIns->mixer, cardIns->ctrlName);
888 ret = InitMixerCtlElement(adapterName, cardIns, cardIns->mixer, SND_PCM_STREAM_CAPTURE);
889 if (ret != HDF_SUCCESS) {
890 AUDIO_FUNC_LOGE("capture InitMixerCtlElement failed!");
891 (void)CloseMixerHandle(cardIns->mixer);
892 CheckCardStatus(cardIns);
893 (void)DestroyCardList();
894 return ret;
895 }
896
897 return HDF_SUCCESS;
898 }
899
AudioCaptureResetParams(snd_pcm_t * handle,struct AudioPcmHwParams audioHwParams,snd_pcm_access_t access)900 int32_t AudioCaptureResetParams(snd_pcm_t *handle, struct AudioPcmHwParams audioHwParams, snd_pcm_access_t access)
901 {
902 int32_t ret;
903 snd_pcm_hw_params_t *hwParams = NULL;
904 snd_pcm_sw_params_t *swParams = NULL;
905
906 if (handle == NULL) {
907 AUDIO_FUNC_LOGE("handle is NULL!");
908 return HDF_FAILURE;
909 }
910
911 snd_pcm_hw_params_alloca(&hwParams);
912 snd_pcm_sw_params_alloca(&swParams);
913 ret = SetHWParams(handle, hwParams, audioHwParams, access);
914 if (ret != HDF_SUCCESS) {
915 AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}d.", ret);
916 return ret;
917 }
918
919 ret = SetSWParams(handle, swParams);
920 if (ret != HDF_SUCCESS) {
921 AUDIO_FUNC_LOGE("Setting of swparams failed: %{public}d.", ret);
922 return ret;
923 }
924
925 return HDF_SUCCESS;
926 }
927
CaptureDataCopy(struct AudioHwCaptureParam * handleData,char * buffer,uint64_t frames)928 static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, char *buffer, uint64_t frames)
929 {
930 int32_t ret;
931 uint32_t channels;
932 uint32_t format;
933 uint64_t recvDataSize;
934
935 if (handleData == NULL || buffer == NULL || frames == 0) {
936 AUDIO_FUNC_LOGE("Param is NULL!");
937 return HDF_FAILURE;
938 }
939
940 if (handleData->frameCaptureMode.buffer == NULL) {
941 AUDIO_FUNC_LOGE("frameCaptureMode.buffer is NULL!");
942 return HDF_FAILURE;
943 }
944 channels = handleData->frameCaptureMode.attrs.channelCount;
945 format = (uint32_t)handleData->frameCaptureMode.attrs.format;
946 recvDataSize = (uint64_t)(frames * channels * format);
947 ret = memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, buffer, recvDataSize);
948 if (ret != EOK) {
949 AUDIO_FUNC_LOGE("memcpy frame data failed!");
950 return HDF_FAILURE;
951 }
952 handleData->frameCaptureMode.bufferSize = recvDataSize;
953 handleData->frameCaptureMode.bufferFrameSize = frames;
954
955 return HDF_SUCCESS;
956 }
957
CheckCapFrameBufferSize(struct AudioHwCaptureParam * handleData,snd_pcm_uframes_t * periodSize)958 static int32_t CheckCapFrameBufferSize(struct AudioHwCaptureParam *handleData, snd_pcm_uframes_t *periodSize)
959 {
960 uint32_t capFrameSize;
961 uint64_t capReqBufferSize;
962
963 if (handleData == NULL || periodSize == NULL) {
964 AUDIO_FUNC_LOGE("Param is NULL!");
965 return HDF_FAILURE;
966 }
967
968 capFrameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format;
969 if (capFrameSize == 0) {
970 AUDIO_FUNC_LOGE("capFrameSize is zero.");
971 return HDF_FAILURE;
972 }
973 capReqBufferSize = capFrameSize * (*periodSize);
974 if (capReqBufferSize > FRAME_DATA) {
975 *periodSize = FRAME_DATA / capFrameSize;
976 }
977
978 return HDF_SUCCESS;
979 }
980
CheckPcmStatus(snd_pcm_t * capturePcmHandle)981 static int32_t CheckPcmStatus(snd_pcm_t *capturePcmHandle)
982 {
983 int32_t ret;
984
985 if (capturePcmHandle == NULL) {
986 AUDIO_FUNC_LOGE("Param is NULL.");
987 return HDF_FAILURE;
988 }
989
990 ret = snd_pcm_wait(capturePcmHandle, -1); /* -1 for timeout, Waiting forever */
991 if (ret < 0) {
992 AUDIO_FUNC_LOGE("snd_pcm_wait failed: %{public}s.", snd_strerror(ret));
993 return HDF_FAILURE;
994 }
995
996 if (snd_pcm_state(capturePcmHandle) == SND_PCM_STATE_SETUP) {
997 ret = snd_pcm_prepare(capturePcmHandle);
998 if (ret < 0) {
999 AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret));
1000 return HDF_FAILURE;
1001 }
1002 }
1003
1004 return HDF_SUCCESS;
1005 }
1006
AudioCaptureReadFrameSub(snd_pcm_t * pcm,uint64_t * frameCnt,char * dataBuf,snd_pcm_uframes_t bufSize)1007 static int32_t AudioCaptureReadFrameSub(snd_pcm_t *pcm, uint64_t *frameCnt, char *dataBuf, snd_pcm_uframes_t bufSize)
1008 {
1009 int32_t ret;
1010 long frames;
1011 int32_t tryNum = AUDIO_ALSALIB_RETYR;
1012
1013 if (pcm == NULL || frameCnt == NULL || dataBuf == NULL || bufSize == 0) {
1014 AUDIO_FUNC_LOGE("The parameter is error.");
1015 return HDF_FAILURE;
1016 }
1017
1018 do {
1019 /* Read interleaved frames to a PCM. */
1020 frames = snd_pcm_readi(pcm, dataBuf, bufSize);
1021 if (frames > 0) {
1022 *frameCnt = (uint64_t)frames;
1023 return HDF_SUCCESS;
1024 }
1025
1026 if (frames == -EBADFD) {
1027 AUDIO_FUNC_LOGE("capture PCM is not in the right state: %{public}s", snd_strerror(frames));
1028 ret = snd_pcm_prepare(pcm);
1029 if (ret < 0) {
1030 AUDIO_FUNC_LOGE("capture snd_pcm_prepare fail: %{public}s", snd_strerror(ret));
1031 return HDF_FAILURE;
1032 }
1033 } else {
1034 /* -ESTRPIPE: a suspend event occurred,
1035 * stream is suspended and waiting for an application recovery.
1036 * -EPIPE: an underrun occurred.
1037 */
1038 ret = snd_pcm_recover(pcm, frames, 0); // 0 for open capture recover log.
1039 if (ret < 0) {
1040 AUDIO_FUNC_LOGE("snd_pcm_readi failed: %{public}s", snd_strerror(ret));
1041 return HDF_FAILURE;
1042 }
1043 }
1044 ret = snd_pcm_start(pcm);
1045 if (ret < 0) {
1046 AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret));
1047 return HDF_FAILURE;
1048 }
1049 tryNum--;
1050 } while (tryNum > 0);
1051
1052 return HDF_SUCCESS;
1053 }
1054
AudioCaptureReadFrame(struct AudioHwCaptureParam * handleData,struct AudioCardInfo * cardIns,snd_pcm_uframes_t periodSize)1055 static int32_t AudioCaptureReadFrame(
1056 struct AudioHwCaptureParam *handleData, struct AudioCardInfo *cardIns, snd_pcm_uframes_t periodSize)
1057 {
1058 int32_t ret;
1059 uint64_t frames = 0;
1060 char *buffer = NULL;
1061
1062 if (handleData == NULL || cardIns == NULL) {
1063 AUDIO_FUNC_LOGE("Param is NULL!");
1064 return HDF_FAILURE;
1065 }
1066
1067 buffer = OsalMemCalloc(ALSA_CAP_BUFFER_SIZE);
1068 if (buffer == NULL) {
1069 AUDIO_FUNC_LOGE("Failed to Calloc buffer");
1070 return HDF_FAILURE;
1071 }
1072
1073 ret = CheckCapFrameBufferSize(handleData, &periodSize);
1074 if (ret != HDF_SUCCESS) {
1075 AUDIO_FUNC_LOGE("CheckCapFrameBufferSize failed.");
1076 AudioMemFree((void **)&buffer);
1077 return ret;
1078 }
1079
1080 ret = CheckPcmStatus(cardIns->capturePcmHandle);
1081 if (ret != HDF_SUCCESS) {
1082 AUDIO_FUNC_LOGE("CheckPcmStatus failed.");
1083 AudioMemFree((void **)&buffer);
1084 return ret;
1085 }
1086
1087 ret = AudioCaptureReadFrameSub(cardIns->capturePcmHandle, &frames, buffer, periodSize);
1088 if (ret != HDF_SUCCESS) {
1089 AUDIO_FUNC_LOGE("AudioCaptureReadFrameSub is error!");
1090 AudioMemFree((void **)&buffer);
1091 return ret;
1092 }
1093
1094 ret = CaptureDataCopy(handleData, buffer, frames);
1095 if (ret != HDF_SUCCESS) {
1096 AUDIO_FUNC_LOGE("Failed to copy data. It may be paused. Check the status!");
1097 AudioMemFree((void **)&buffer);
1098 return ret;
1099 }
1100 AudioMemFree((void **)&buffer);
1101
1102 return HDF_SUCCESS;
1103 }
1104
AudioOutputCaptureRead(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)1105 int32_t AudioOutputCaptureRead(const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
1106 {
1107 int32_t ret;
1108 snd_pcm_uframes_t bufferSize = 0;
1109 snd_pcm_uframes_t periodSize = 0;
1110
1111 (void)cmdId;
1112 if (handle == NULL || handleData == NULL) {
1113 AUDIO_FUNC_LOGE("Param is NULL!");
1114 return HDF_FAILURE;
1115 }
1116
1117 const char *sndCardName = handleData->captureMode.hwInfo.adapterName;
1118 struct AudioCardInfo *cardIns = GetCardIns(sndCardName);
1119 if (cardIns == NULL) {
1120 AUDIO_FUNC_LOGE("cardIns is NULL!");
1121 return HDF_FAILURE;
1122 }
1123
1124 ret = snd_pcm_get_params(cardIns->capturePcmHandle, &bufferSize, &periodSize);
1125 if (ret < 0) {
1126 AUDIO_FUNC_LOGE("Get capture params error: %{public}s.", snd_strerror(ret));
1127 return HDF_FAILURE;
1128 }
1129
1130 if (!cardIns->captureMmapFlag) {
1131 ret =
1132 AudioCaptureResetParams(cardIns->capturePcmHandle, cardIns->hwCaptureParams, SND_PCM_ACCESS_RW_INTERLEAVED);
1133 if (ret != HDF_SUCCESS) {
1134 AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!");
1135 return ret;
1136 }
1137 ret = snd_pcm_start(cardIns->capturePcmHandle);
1138 if (ret < 0) {
1139 AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret));
1140 return HDF_FAILURE;
1141 }
1142 cardIns->captureMmapFlag = true;
1143 }
1144
1145 ret = AudioCaptureReadFrame(handleData, cardIns, periodSize);
1146 if (ret != HDF_SUCCESS) {
1147 AUDIO_FUNC_LOGE("AudioOutputCaptureRead failed");
1148 return ret;
1149 }
1150
1151 return HDF_SUCCESS;
1152 }
1153
AudioOutputCaptureStart(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1154 int32_t AudioOutputCaptureStart(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
1155 {
1156 (void)cmdId;
1157 if (handle == NULL || handleData == NULL) {
1158 AUDIO_FUNC_LOGE("Param is NULL!");
1159 return HDF_FAILURE;
1160 }
1161
1162 return HDF_SUCCESS;
1163 }
1164
AudioOutputCapturePrepare(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1165 int32_t AudioOutputCapturePrepare(
1166 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
1167 {
1168 int32_t ret;
1169 struct AudioCardInfo *cardIns;
1170
1171 (void)cmdId;
1172 if (handle == NULL || handleData == NULL) {
1173 AUDIO_FUNC_LOGE("Invalid parameters!!!");
1174 return HDF_FAILURE;
1175 }
1176
1177 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
1178 cardIns = GetCardIns(adapterName);
1179 if (cardIns == NULL) {
1180 AUDIO_FUNC_LOGE("Get cardIns is failed!!!");
1181 return HDF_FAILURE;
1182 }
1183
1184 ret = snd_pcm_prepare(cardIns->capturePcmHandle);
1185 if (ret < 0) {
1186 AUDIO_FUNC_LOGE("snd_pcm_prepare fail! %{public}s.", snd_strerror(ret));
1187 return HDF_FAILURE;
1188 }
1189
1190 return HDF_SUCCESS;
1191 }
1192
AudioOutputCaptureClose(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1193 int32_t AudioOutputCaptureClose(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
1194 {
1195 int32_t ret;
1196 struct AudioCardInfo *cardIns;
1197
1198 (void)cmdId;
1199 if (handle == NULL || handleData == NULL) {
1200 AUDIO_FUNC_LOGE("Parameter is NULL!");
1201 return HDF_FAILURE;
1202 }
1203
1204 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
1205 cardIns = GetCardIns(adapterName);
1206 if (cardIns == NULL) {
1207 AUDIO_FUNC_LOGE("cardIns is NULL!");
1208 return HDF_FAILURE;
1209 }
1210
1211 AudioMemFree((void **)&cardIns->volElemList);
1212 if (cardIns->capturePcmHandle != NULL) {
1213 (void)snd_pcm_close(cardIns->capturePcmHandle);
1214 cardIns->capturePcmHandle = NULL;
1215 }
1216
1217 if (cardIns->cardStatus > 0) {
1218 cardIns->cardStatus -= 1;
1219 }
1220 if (cardIns->cardStatus == 0) {
1221 if (cardIns->mixer != NULL) {
1222 (void)snd_mixer_close(cardIns->mixer);
1223 cardIns->mixer = NULL;
1224 }
1225 (void)memset_s(cardIns->cardName, MAX_CARD_NAME_LEN + 1, 0, MAX_CARD_NAME_LEN + 1);
1226 ret = DestroyCardList();
1227 if (ret != HDF_SUCCESS) {
1228 AUDIO_FUNC_LOGE("DestroyCardList failed: %{public}d.", ret);
1229 return ret;
1230 }
1231 }
1232
1233 return HDF_SUCCESS;
1234 }
1235
AudioOutputCaptureStop(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1236 int32_t AudioOutputCaptureStop(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
1237 {
1238 int32_t ret;
1239 struct AudioCardInfo *cardIns;
1240
1241 (void)cmdId;
1242 if (handle == NULL || handleData == NULL) {
1243 AUDIO_FUNC_LOGE("Param is NULL!");
1244 return HDF_FAILURE;
1245 }
1246
1247 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
1248 cardIns = GetCardIns(adapterName);
1249 if (cardIns == NULL) {
1250 AUDIO_FUNC_LOGE("Can't find sound card instance!!!");
1251 return HDF_FAILURE;
1252 }
1253
1254 /* pass the remaining samples, otherwise they're dropped in close */
1255 ret = snd_pcm_drop(cardIns->capturePcmHandle);
1256 if (ret < 0) {
1257 AUDIO_FUNC_LOGE("snd_pcm_drain failed: %{public}s.", snd_strerror(ret));
1258 return HDF_FAILURE;
1259 }
1260
1261 return HDF_SUCCESS;
1262 }
1263
UpdateSetParams(struct AudioCardInfo * cardIns)1264 static int32_t UpdateSetParams(struct AudioCardInfo *cardIns)
1265 {
1266 int32_t ret;
1267
1268 if (cardIns == NULL) {
1269 AUDIO_FUNC_LOGE("param is NULL!");
1270 return HDF_FAILURE;
1271 }
1272
1273 cardIns->captureMmapFlag = false;
1274 ret = AudioCaptureResetParams(cardIns->capturePcmHandle, cardIns->hwCaptureParams, SND_PCM_ACCESS_MMAP_INTERLEAVED);
1275 if (ret != HDF_SUCCESS) {
1276 AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!");
1277 return ret;
1278 }
1279
1280 ret = snd_pcm_start(cardIns->capturePcmHandle);
1281 if (ret < 0) {
1282 AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s.", snd_strerror(ret));
1283 return HDF_FAILURE;
1284 }
1285
1286 return HDF_SUCCESS;
1287 }
1288
MmapDescWriteBufferCapture(const struct AudioHwCaptureParam * handleData)1289 static int32_t MmapDescWriteBufferCapture(const struct AudioHwCaptureParam *handleData)
1290 {
1291 int32_t ret;
1292 char *mmapAddr;
1293 uint32_t frameSize;
1294 snd_pcm_sframes_t xfer;
1295 snd_pcm_uframes_t size;
1296 struct AudioCardInfo *cardIns;
1297
1298 if (handleData == NULL) {
1299 AUDIO_FUNC_LOGE("param is NULL!");
1300 return HDF_FAILURE;
1301 }
1302
1303 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
1304 cardIns = GetCardIns(adapterName);
1305 if (cardIns == NULL) {
1306 AUDIO_FUNC_LOGE("cardIns is NULL!");
1307 return HDF_FAILURE;
1308 }
1309
1310 ret = UpdateSetParams(cardIns);
1311 if (ret != HDF_SUCCESS) {
1312 AUDIO_FUNC_LOGE("Update set params failed!");
1313 return ret;
1314 }
1315
1316 mmapAddr = (char *)handleData->frameCaptureMode.mmapBufDesc.memoryAddress;
1317 if (mmapAddr == NULL) {
1318 AUDIO_FUNC_LOGE("mmapAddr is NULL!");
1319 return HDF_FAILURE;
1320 }
1321 size = (snd_pcm_sframes_t)handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames;
1322 frameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format;
1323 while (size > 0) {
1324 xfer = snd_pcm_mmap_readi(cardIns->capturePcmHandle, mmapAddr, size);
1325 if (xfer < 0) {
1326 if (xfer == -EAGAIN) {
1327 snd_pcm_wait(cardIns->capturePcmHandle, AUDIO_PCM_WAIT);
1328 continue;
1329 }
1330 AUDIO_FUNC_LOGE("snd_pcm_mmap_readi: %{public}s", snd_strerror(xfer));
1331 return HDF_FAILURE;
1332 }
1333
1334 if (xfer > 0) {
1335 mmapAddr += xfer * frameSize;
1336 size -= xfer;
1337 cardIns->capMmapFrames += xfer;
1338 }
1339 }
1340
1341 return HDF_SUCCESS;
1342 }
1343
AudioOutputCaptureReqMmapBuffer(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1344 int32_t AudioOutputCaptureReqMmapBuffer(
1345 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
1346 {
1347 int32_t ret;
1348
1349 (void)cmdId;
1350 if (handle == NULL || handleData == NULL) {
1351 AUDIO_FUNC_LOGE("param is NULL!");
1352 return HDF_FAILURE;
1353 }
1354
1355 ret = MmapDescWriteBufferCapture(handleData);
1356 if (ret != HDF_SUCCESS) {
1357 AUDIO_FUNC_LOGE("Capture mmap write buffer failed!");
1358 return ret;
1359 }
1360
1361 return HDF_SUCCESS;
1362 }
1363
AudioOutputCaptureGetMmapPosition(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)1364 int32_t AudioOutputCaptureGetMmapPosition(
1365 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
1366 {
1367 struct AudioCardInfo *cardIns;
1368
1369 (void)cmdId;
1370 if (handle == NULL || handleData == NULL) {
1371 AUDIO_FUNC_LOGE("param is NULL!");
1372 return HDF_FAILURE;
1373 }
1374
1375 const char *cardName = handleData->captureMode.hwInfo.adapterName;
1376 cardIns = GetCardIns(cardName);
1377 if (cardIns == NULL) {
1378 AUDIO_FUNC_LOGE("Get cardIns is NULL!");
1379 return HDF_FAILURE;
1380 }
1381 handleData->frameCaptureMode.frames = cardIns->capMmapFrames;
1382
1383 return HDF_SUCCESS;
1384 }
1385
AudioInterfaceLibOutputCapture(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)1386 int32_t AudioInterfaceLibOutputCapture(
1387 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
1388 {
1389 int32_t ret;
1390
1391 if (handle == NULL || handleData == NULL) {
1392 AUDIO_FUNC_LOGE("Parameter is NULL!");
1393 return HDF_FAILURE;
1394 }
1395
1396 switch (cmdId) {
1397 case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
1398 ret = AudioOutputCaptureHwParams(handle, cmdId, handleData);
1399 break;
1400 case AUDIO_DRV_PCM_IOCTL_READ:
1401 ret = AudioOutputCaptureRead(handle, cmdId, handleData);
1402 break;
1403 case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE:
1404 ret = AudioOutputCaptureStart(handle, cmdId, handleData);
1405 break;
1406 case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE:
1407 ret = AudioOutputCapturePrepare(handle, cmdId, handleData);
1408 break;
1409 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE:
1410 ret = AudioOutputCaptureClose(handle, cmdId, handleData);
1411 break;
1412 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN:
1413 ret = AudioOutputCaptureOpen(handle, cmdId, handleData);
1414 break;
1415 case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE:
1416 ret = AudioOutputCaptureStop(handle, cmdId, handleData);
1417 break;
1418 case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE:
1419 ret = AudioCtlCaptureSetPauseStu(handle, cmdId, handleData);
1420 break;
1421 case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE:
1422 ret = AudioOutputCaptureReqMmapBuffer(handle, cmdId, handleData);
1423 break;
1424 case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE:
1425 ret = AudioOutputCaptureGetMmapPosition(handle, cmdId, handleData);
1426 break;
1427 default:
1428 AUDIO_FUNC_LOGE("Output Mode not support!");
1429 ret = HDF_FAILURE;
1430 break;
1431 }
1432
1433 return ret;
1434 }
1435
AudioInterfaceLibModeCapture(const struct DevHandle * handle,struct AudioHwCaptureParam * handleData,int cmdId)1436 int32_t AudioInterfaceLibModeCapture(const struct DevHandle *handle, struct AudioHwCaptureParam *handleData, int cmdId)
1437 {
1438 AUDIO_FUNC_LOGI();
1439 if (handle == NULL || handleData == NULL) {
1440 AUDIO_FUNC_LOGE("paras is NULL!");
1441 return HDF_FAILURE;
1442 }
1443
1444 switch (cmdId) {
1445 case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
1446 case AUDIO_DRV_PCM_IOCTL_READ:
1447 case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE:
1448 case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE:
1449 case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE:
1450 case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE:
1451 case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE:
1452 case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE:
1453 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN:
1454 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE:
1455 return (AudioInterfaceLibOutputCapture(handle, cmdId, handleData));
1456 case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE:
1457 case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE:
1458 case AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE:
1459 case AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE:
1460 case AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE:
1461 case AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE:
1462 case AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE:
1463 case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE:
1464 case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE:
1465 return (AudioInterfaceLibCtlCapture(handle, cmdId, handleData));
1466 default:
1467 AUDIO_FUNC_LOGE("Mode Error!");
1468 break;
1469 }
1470
1471 return HDF_ERR_NOT_SUPPORT;
1472 }
1473