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
745 if (handle == NULL || swparams == NULL) {
746 AUDIO_FUNC_LOGE("SetHWParams parameter is null!");
747 return HDF_FAILURE;
748 }
749
750 /* get the current swparams */
751 ret = snd_pcm_sw_params_current(handle, swparams);
752 if (ret < 0) {
753 AUDIO_FUNC_LOGE("Unable to determine current swparams for capture: %{public}s.", snd_strerror(ret));
754 return HDF_FAILURE;
755 }
756
757 if (g_periodSize == 0) {
758 AUDIO_FUNC_LOGE("error: g_periodSize cannot be zero!");
759 return HDF_FAILURE;
760 }
761 /* start the transfer when the buffer is almost full: */
762 /* (buffer_size / avail_min) * avail_min */
763 ret = snd_pcm_sw_params_set_start_threshold(handle, swparams, (g_bufferSize / g_periodSize) * g_periodSize);
764 if (ret < 0) {
765 AUDIO_FUNC_LOGE("Unable to set start threshold mode for capture: %{public}s.", snd_strerror(ret));
766 return HDF_FAILURE;
767 }
768
769 /* allow the transfer when at least period_size samples can be processed */
770 /* or disable this mechanism when period event is enabled (aka interrupt like style processing) */
771 ret = snd_pcm_sw_params_set_avail_min(handle, swparams, g_periodEvent ? g_bufferSize : g_periodSize);
772 if (ret < 0) {
773 AUDIO_FUNC_LOGE("Unable to set avail min for capture: %{public}s", snd_strerror(ret));
774 return HDF_FAILURE;
775 }
776
777 /* enable period events when requested */
778 if (g_periodEvent) {
779 ret = snd_pcm_sw_params_set_period_event(handle, swparams, 1);
780 if (ret < 0) {
781 AUDIO_FUNC_LOGE("Unable to set period event: %{public}s", snd_strerror(ret));
782 return HDF_FAILURE;
783 }
784 }
785
786 /* write the parameters to the capture device */
787 ret = snd_pcm_sw_params(handle, swparams);
788 if (ret < 0) {
789 AUDIO_FUNC_LOGE("Unable to set sw params for capture: %{public}s", snd_strerror(ret));
790 return HDF_FAILURE;
791 }
792
793 return HDF_SUCCESS;
794 }
795
AudioOutputCaptureHwParams(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)796 int32_t AudioOutputCaptureHwParams(
797 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
798 {
799 int32_t ret;
800 struct AudioCardInfo *cardIns;
801 snd_pcm_hw_params_t *hwParams = NULL;
802 snd_pcm_sw_params_t *swParams = NULL;
803
804 (void)cmdId;
805 if (handle == NULL || handleData == NULL) {
806 AUDIO_FUNC_LOGE("The parameter is empty");
807 return HDF_FAILURE;
808 }
809
810 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
811 cardIns = GetCardIns(adapterName);
812 if (cardIns == NULL) {
813 AUDIO_FUNC_LOGE("cardIns is NULL!");
814 return HDF_FAILURE;
815 }
816
817 ret = (int32_t)snd_pcm_state(cardIns->capturePcmHandle);
818 if (ret >= SND_PCM_STATE_RUNNING) {
819 AUDIO_FUNC_LOGE("Unable to set parameters during capture!");
820 return HDF_FAILURE;
821 }
822
823 ret = GetCapHwParams(cardIns, handleData);
824 if (ret != HDF_SUCCESS) {
825 AUDIO_FUNC_LOGE("GetCapHwParams error.");
826 return ret;
827 }
828
829 snd_pcm_hw_params_alloca(&hwParams);
830 snd_pcm_sw_params_alloca(&swParams);
831 ret = SetHWParams(cardIns->capturePcmHandle, hwParams, cardIns->hwCaptureParams, SND_PCM_ACCESS_RW_INTERLEAVED);
832 if (ret != HDF_SUCCESS) {
833 AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}d.", ret);
834 return ret;
835 }
836 ret = SetSWParams(cardIns->capturePcmHandle, swParams);
837 if (ret != HDF_SUCCESS) {
838 AUDIO_FUNC_LOGE("Setting of swparams failed: %{public}d.", ret);
839 return ret;
840 }
841
842 return HDF_SUCCESS;
843 }
844
845 /*
846 * brief: Opens a capture PCM
847 * param mode Open mode (see #SND_PCM_NONBLOCK, #SND_PCM_ASYNC)
848 */
AudioOutputCaptureOpen(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)849 int32_t AudioOutputCaptureOpen(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
850 {
851 int32_t ret;
852 struct AudioCardInfo *cardIns;
853
854 (void)cmdId;
855 if (handle == NULL || handleData == NULL) {
856 AUDIO_FUNC_LOGE("Function parameter is NULL!");
857 return HDF_FAILURE;
858 }
859
860 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
861 cardIns = AudioGetCardInstance(adapterName);
862 if (cardIns == NULL) {
863 AUDIO_FUNC_LOGE("AudioCaptureGetCardIns failed.");
864 (void)DestroyCardList();
865 return HDF_FAILURE;
866 }
867 ret = AudioGetCardInfo(cardIns, adapterName, SND_PCM_STREAM_CAPTURE);
868 if (ret != HDF_SUCCESS) {
869 CheckCardStatus(cardIns);
870 (void)DestroyCardList();
871 return HDF_FAILURE;
872 }
873 if (cardIns->capturePcmHandle != NULL) {
874 AUDIO_FUNC_LOGE("Resource busy!!");
875 CheckCardStatus(cardIns);
876 (void)DestroyCardList();
877 return HDF_ERR_DEVICE_BUSY;
878 }
879 ret = snd_pcm_open(&cardIns->capturePcmHandle, cardIns->devName, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
880 if (ret < 0) {
881 AUDIO_FUNC_LOGE("Capture open device error: %{public}s.", snd_strerror(ret));
882 CheckCardStatus(cardIns);
883 (void)DestroyCardList();
884 return HDF_FAILURE;
885 }
886 InitSound(&cardIns->mixer, cardIns->ctrlName);
887 ret = InitMixerCtlElement(adapterName, cardIns, cardIns->mixer, SND_PCM_STREAM_CAPTURE);
888 if (ret != HDF_SUCCESS) {
889 AUDIO_FUNC_LOGE("capture InitMixerCtlElement failed!");
890 (void)CloseMixerHandle(cardIns->mixer);
891 CheckCardStatus(cardIns);
892 (void)DestroyCardList();
893 return ret;
894 }
895
896 return HDF_SUCCESS;
897 }
898
AudioCaptureResetParams(snd_pcm_t * handle,struct AudioPcmHwParams audioHwParams,snd_pcm_access_t access)899 int32_t AudioCaptureResetParams(snd_pcm_t *handle, struct AudioPcmHwParams audioHwParams, snd_pcm_access_t access)
900 {
901 int32_t ret;
902 snd_pcm_hw_params_t *hwParams = NULL;
903 snd_pcm_sw_params_t *swParams = NULL;
904
905 if (handle == NULL) {
906 AUDIO_FUNC_LOGE("handle is NULL!");
907 return HDF_FAILURE;
908 }
909
910 snd_pcm_hw_params_alloca(&hwParams);
911 snd_pcm_sw_params_alloca(&swParams);
912 ret = SetHWParams(handle, hwParams, audioHwParams, access);
913 if (ret != HDF_SUCCESS) {
914 AUDIO_FUNC_LOGE("Setting of hwparams failed: %{public}d.", ret);
915 return ret;
916 }
917
918 ret = SetSWParams(handle, swParams);
919 if (ret != HDF_SUCCESS) {
920 AUDIO_FUNC_LOGE("Setting of swparams failed: %{public}d.", ret);
921 return ret;
922 }
923
924 return HDF_SUCCESS;
925 }
926
CaptureDataCopy(struct AudioHwCaptureParam * handleData,char * buffer,uint64_t frames)927 static int32_t CaptureDataCopy(struct AudioHwCaptureParam *handleData, char *buffer, uint64_t frames)
928 {
929 int32_t ret;
930 uint32_t channels;
931 uint32_t format;
932 uint64_t recvDataSize;
933
934 if (handleData == NULL || buffer == NULL || frames == 0) {
935 AUDIO_FUNC_LOGE("Param is NULL!");
936 return HDF_FAILURE;
937 }
938
939 if (handleData->frameCaptureMode.buffer == NULL) {
940 AUDIO_FUNC_LOGE("frameCaptureMode.buffer is NULL!");
941 return HDF_FAILURE;
942 }
943 channels = handleData->frameCaptureMode.attrs.channelCount;
944 format = (uint32_t)handleData->frameCaptureMode.attrs.format;
945 recvDataSize = (uint64_t)(frames * channels * format);
946 ret = memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, buffer, recvDataSize);
947 if (ret != EOK) {
948 AUDIO_FUNC_LOGE("memcpy frame data failed!");
949 return HDF_FAILURE;
950 }
951 handleData->frameCaptureMode.bufferSize = recvDataSize;
952 handleData->frameCaptureMode.bufferFrameSize = frames;
953
954 return HDF_SUCCESS;
955 }
956
CheckCapFrameBufferSize(struct AudioHwCaptureParam * handleData,snd_pcm_uframes_t * periodSize)957 static int32_t CheckCapFrameBufferSize(struct AudioHwCaptureParam *handleData, snd_pcm_uframes_t *periodSize)
958 {
959 uint32_t capFrameSize;
960 uint64_t capReqBufferSize;
961
962 if (handleData == NULL || periodSize == NULL) {
963 AUDIO_FUNC_LOGE("Param is NULL!");
964 return HDF_FAILURE;
965 }
966
967 capFrameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format;
968 if (capFrameSize == 0) {
969 AUDIO_FUNC_LOGE("capFrameSize is zero.");
970 return HDF_FAILURE;
971 }
972 capReqBufferSize = capFrameSize * (*periodSize);
973 if (capReqBufferSize > FRAME_DATA) {
974 *periodSize = FRAME_DATA / capFrameSize;
975 }
976
977 return HDF_SUCCESS;
978 }
979
CheckPcmStatus(snd_pcm_t * capturePcmHandle)980 static int32_t CheckPcmStatus(snd_pcm_t *capturePcmHandle)
981 {
982 int32_t ret;
983
984 if (capturePcmHandle == NULL) {
985 AUDIO_FUNC_LOGE("Param is NULL.");
986 return HDF_FAILURE;
987 }
988
989 ret = snd_pcm_wait(capturePcmHandle, -1); /* -1 for timeout, Waiting forever */
990 if (ret < 0) {
991 AUDIO_FUNC_LOGE("snd_pcm_wait failed: %{public}s.", snd_strerror(ret));
992 return HDF_FAILURE;
993 }
994
995 if (snd_pcm_state(capturePcmHandle) == SND_PCM_STATE_SETUP) {
996 ret = snd_pcm_prepare(capturePcmHandle);
997 if (ret < 0) {
998 AUDIO_FUNC_LOGE("snd_pcm_prepare fail: %{public}s", snd_strerror(ret));
999 return HDF_FAILURE;
1000 }
1001 }
1002
1003 return HDF_SUCCESS;
1004 }
1005
AudioCaptureReadFrameSub(snd_pcm_t * pcm,uint64_t * frameCnt,char * dataBuf,snd_pcm_uframes_t bufSize)1006 static int32_t AudioCaptureReadFrameSub(snd_pcm_t *pcm, uint64_t *frameCnt, char *dataBuf, snd_pcm_uframes_t bufSize)
1007 {
1008 int32_t ret;
1009 long frames;
1010 int32_t tryNum = AUDIO_ALSALIB_RETYR;
1011
1012 if (pcm == NULL || frameCnt == NULL || dataBuf == NULL || bufSize == 0) {
1013 AUDIO_FUNC_LOGE("The parameter is error.");
1014 return HDF_FAILURE;
1015 }
1016
1017 do {
1018 /* Read interleaved frames to a PCM. */
1019 frames = snd_pcm_readi(pcm, dataBuf, bufSize);
1020 if (frames > 0) {
1021 *frameCnt = (uint64_t)frames;
1022 return HDF_SUCCESS;
1023 }
1024
1025 if (frames == -EBADFD) {
1026 AUDIO_FUNC_LOGE("capture PCM is not in the right state: %{public}s", snd_strerror(frames));
1027 ret = snd_pcm_prepare(pcm);
1028 if (ret < 0) {
1029 AUDIO_FUNC_LOGE("capture snd_pcm_prepare fail: %{public}s", snd_strerror(ret));
1030 return HDF_FAILURE;
1031 }
1032 } else {
1033 /* -ESTRPIPE: a suspend event occurred,
1034 * stream is suspended and waiting for an application recovery.
1035 * -EPIPE: an underrun occurred.
1036 */
1037 ret = snd_pcm_recover(pcm, frames, 0); // 0 for open capture recover log.
1038 if (ret < 0) {
1039 AUDIO_FUNC_LOGE("snd_pcm_readi failed: %{public}s", snd_strerror(ret));
1040 return HDF_FAILURE;
1041 }
1042 }
1043 ret = snd_pcm_start(pcm);
1044 if (ret < 0) {
1045 AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret));
1046 return HDF_FAILURE;
1047 }
1048 tryNum--;
1049 } while (tryNum > 0);
1050
1051 return HDF_SUCCESS;
1052 }
1053
AudioCaptureReadFrame(struct AudioHwCaptureParam * handleData,struct AudioCardInfo * cardIns,snd_pcm_uframes_t periodSize)1054 static int32_t AudioCaptureReadFrame(
1055 struct AudioHwCaptureParam *handleData, struct AudioCardInfo *cardIns, snd_pcm_uframes_t periodSize)
1056 {
1057 int32_t ret;
1058 uint64_t frames = 0;
1059 char *buffer = NULL;
1060
1061 if (handleData == NULL || cardIns == NULL) {
1062 AUDIO_FUNC_LOGE("Param is NULL!");
1063 return HDF_FAILURE;
1064 }
1065
1066 buffer = OsalMemCalloc(ALSA_CAP_BUFFER_SIZE);
1067 if (buffer == NULL) {
1068 AUDIO_FUNC_LOGE("Failed to Calloc buffer");
1069 return HDF_FAILURE;
1070 }
1071
1072 ret = CheckCapFrameBufferSize(handleData, &periodSize);
1073 if (ret != HDF_SUCCESS) {
1074 AUDIO_FUNC_LOGE("CheckCapFrameBufferSize failed.");
1075 AudioMemFree((void **)&buffer);
1076 return ret;
1077 }
1078
1079 ret = CheckPcmStatus(cardIns->capturePcmHandle);
1080 if (ret != HDF_SUCCESS) {
1081 AUDIO_FUNC_LOGE("CheckPcmStatus failed.");
1082 AudioMemFree((void **)&buffer);
1083 return ret;
1084 }
1085
1086 ret = AudioCaptureReadFrameSub(cardIns->capturePcmHandle, &frames, buffer, periodSize);
1087 if (ret != HDF_SUCCESS) {
1088 AUDIO_FUNC_LOGE("AudioCaptureReadFrameSub is error!");
1089 AudioMemFree((void **)&buffer);
1090 return ret;
1091 }
1092
1093 ret = CaptureDataCopy(handleData, buffer, frames);
1094 if (ret != HDF_SUCCESS) {
1095 AUDIO_FUNC_LOGE("Failed to copy data. It may be paused. Check the status!");
1096 AudioMemFree((void **)&buffer);
1097 return ret;
1098 }
1099 AudioMemFree((void **)&buffer);
1100
1101 return HDF_SUCCESS;
1102 }
1103
AudioOutputCaptureRead(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)1104 int32_t AudioOutputCaptureRead(const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
1105 {
1106 int32_t ret;
1107 snd_pcm_uframes_t bufferSize = 0;
1108 snd_pcm_uframes_t periodSize = 0;
1109
1110 (void)cmdId;
1111 if (handle == NULL || handleData == NULL) {
1112 AUDIO_FUNC_LOGE("Param is NULL!");
1113 return HDF_FAILURE;
1114 }
1115
1116 const char *sndCardName = handleData->captureMode.hwInfo.adapterName;
1117 struct AudioCardInfo *cardIns = GetCardIns(sndCardName);
1118 if (cardIns == NULL) {
1119 AUDIO_FUNC_LOGE("cardIns is NULL!");
1120 return HDF_FAILURE;
1121 }
1122
1123 ret = snd_pcm_get_params(cardIns->capturePcmHandle, &bufferSize, &periodSize);
1124 if (ret < 0) {
1125 AUDIO_FUNC_LOGE("Get capture params error: %{public}s.", snd_strerror(ret));
1126 return HDF_FAILURE;
1127 }
1128
1129 if (!cardIns->captureMmapFlag) {
1130 ret =
1131 AudioCaptureResetParams(cardIns->capturePcmHandle, cardIns->hwCaptureParams, SND_PCM_ACCESS_RW_INTERLEAVED);
1132 if (ret != HDF_SUCCESS) {
1133 AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!");
1134 return ret;
1135 }
1136 ret = snd_pcm_start(cardIns->capturePcmHandle);
1137 if (ret < 0) {
1138 AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s", snd_strerror(ret));
1139 return HDF_FAILURE;
1140 }
1141 cardIns->captureMmapFlag = true;
1142 }
1143
1144 ret = AudioCaptureReadFrame(handleData, cardIns, periodSize);
1145 if (ret != HDF_SUCCESS) {
1146 AUDIO_FUNC_LOGE("AudioOutputCaptureRead failed");
1147 return ret;
1148 }
1149
1150 return HDF_SUCCESS;
1151 }
1152
AudioOutputCaptureStart(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1153 int32_t AudioOutputCaptureStart(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
1154 {
1155 (void)cmdId;
1156 if (handle == NULL || handleData == NULL) {
1157 AUDIO_FUNC_LOGE("Param is NULL!");
1158 return HDF_FAILURE;
1159 }
1160
1161 return HDF_SUCCESS;
1162 }
1163
AudioOutputCapturePrepare(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1164 int32_t AudioOutputCapturePrepare(
1165 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
1166 {
1167 int32_t ret;
1168 struct AudioCardInfo *cardIns;
1169
1170 (void)cmdId;
1171 if (handle == NULL || handleData == NULL) {
1172 AUDIO_FUNC_LOGE("Invalid parameters!!!");
1173 return HDF_FAILURE;
1174 }
1175
1176 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
1177 cardIns = GetCardIns(adapterName);
1178 if (cardIns == NULL) {
1179 AUDIO_FUNC_LOGE("Get cardIns is failed!!!");
1180 return HDF_FAILURE;
1181 }
1182
1183 ret = snd_pcm_prepare(cardIns->capturePcmHandle);
1184 if (ret < 0) {
1185 AUDIO_FUNC_LOGE("snd_pcm_prepare fail! %{public}s.", snd_strerror(ret));
1186 return HDF_FAILURE;
1187 }
1188
1189 return HDF_SUCCESS;
1190 }
1191
AudioOutputCaptureClose(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1192 int32_t AudioOutputCaptureClose(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
1193 {
1194 int32_t ret;
1195 struct AudioCardInfo *cardIns;
1196
1197 (void)cmdId;
1198 if (handle == NULL || handleData == NULL) {
1199 AUDIO_FUNC_LOGE("Parameter is NULL!");
1200 return HDF_FAILURE;
1201 }
1202
1203 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
1204 cardIns = GetCardIns(adapterName);
1205 if (cardIns == NULL) {
1206 AUDIO_FUNC_LOGE("cardIns is NULL!");
1207 return HDF_FAILURE;
1208 }
1209
1210 AudioMemFree((void **)&cardIns->volElemList);
1211 if (cardIns->capturePcmHandle != NULL) {
1212 (void)snd_pcm_close(cardIns->capturePcmHandle);
1213 cardIns->capturePcmHandle = NULL;
1214 }
1215
1216 if (cardIns->cardStatus > 0) {
1217 cardIns->cardStatus -= 1;
1218 }
1219 if (cardIns->cardStatus == 0) {
1220 if (cardIns->mixer != NULL) {
1221 (void)snd_mixer_close(cardIns->mixer);
1222 cardIns->mixer = NULL;
1223 }
1224 (void)memset_s(cardIns->cardName, MAX_CARD_NAME_LEN + 1, 0, MAX_CARD_NAME_LEN + 1);
1225 ret = DestroyCardList();
1226 if (ret != HDF_SUCCESS) {
1227 AUDIO_FUNC_LOGE("DestroyCardList failed: %{public}d.", ret);
1228 return ret;
1229 }
1230 }
1231
1232 return HDF_SUCCESS;
1233 }
1234
AudioOutputCaptureStop(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1235 int32_t AudioOutputCaptureStop(const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
1236 {
1237 int32_t ret;
1238 struct AudioCardInfo *cardIns;
1239
1240 (void)cmdId;
1241 if (handle == NULL || handleData == NULL) {
1242 AUDIO_FUNC_LOGE("Param is NULL!");
1243 return HDF_FAILURE;
1244 }
1245
1246 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
1247 cardIns = GetCardIns(adapterName);
1248 if (cardIns == NULL) {
1249 AUDIO_FUNC_LOGE("Can't find sound card instance!!!");
1250 return HDF_FAILURE;
1251 }
1252
1253 /* pass the remaining samples, otherwise they're dropped in close */
1254 ret = snd_pcm_drop(cardIns->capturePcmHandle);
1255 if (ret < 0) {
1256 AUDIO_FUNC_LOGE("snd_pcm_drain failed: %{public}s.", snd_strerror(ret));
1257 return HDF_FAILURE;
1258 }
1259
1260 return HDF_SUCCESS;
1261 }
1262
UpdateSetParams(struct AudioCardInfo * cardIns)1263 static int32_t UpdateSetParams(struct AudioCardInfo *cardIns)
1264 {
1265 int32_t ret;
1266
1267 if (cardIns == NULL) {
1268 AUDIO_FUNC_LOGE("param is NULL!");
1269 return HDF_FAILURE;
1270 }
1271
1272 cardIns->captureMmapFlag = false;
1273 ret = AudioCaptureResetParams(cardIns->capturePcmHandle, cardIns->hwCaptureParams, SND_PCM_ACCESS_MMAP_INTERLEAVED);
1274 if (ret != HDF_SUCCESS) {
1275 AUDIO_FUNC_LOGE("AudioSetParamsMmap failed!");
1276 return ret;
1277 }
1278
1279 ret = snd_pcm_start(cardIns->capturePcmHandle);
1280 if (ret < 0) {
1281 AUDIO_FUNC_LOGE("snd_pcm_start fail. %{public}s.", snd_strerror(ret));
1282 return HDF_FAILURE;
1283 }
1284
1285 return HDF_SUCCESS;
1286 }
1287
MmapDescWriteBufferCapture(const struct AudioHwCaptureParam * handleData)1288 static int32_t MmapDescWriteBufferCapture(const struct AudioHwCaptureParam *handleData)
1289 {
1290 int32_t ret;
1291 char *mmapAddr;
1292 uint32_t frameSize;
1293 snd_pcm_sframes_t xfer;
1294 snd_pcm_uframes_t size;
1295 struct AudioCardInfo *cardIns;
1296
1297 if (handleData == NULL) {
1298 AUDIO_FUNC_LOGE("param is NULL!");
1299 return HDF_FAILURE;
1300 }
1301
1302 const char *adapterName = handleData->captureMode.hwInfo.adapterName;
1303 cardIns = GetCardIns(adapterName);
1304 if (cardIns == NULL) {
1305 AUDIO_FUNC_LOGE("cardIns is NULL!");
1306 return HDF_FAILURE;
1307 }
1308
1309 ret = UpdateSetParams(cardIns);
1310 if (ret != HDF_SUCCESS) {
1311 AUDIO_FUNC_LOGE("Update set params failed!");
1312 return ret;
1313 }
1314
1315 mmapAddr = (char *)handleData->frameCaptureMode.mmapBufDesc.memoryAddress;
1316 if (mmapAddr == NULL) {
1317 AUDIO_FUNC_LOGE("mmapAddr is NULL!");
1318 return HDF_FAILURE;
1319 }
1320 size = (snd_pcm_sframes_t)handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames;
1321 frameSize = handleData->frameCaptureMode.attrs.channelCount * handleData->frameCaptureMode.attrs.format;
1322 while (size > 0) {
1323 xfer = snd_pcm_mmap_readi(cardIns->capturePcmHandle, mmapAddr, size);
1324 if (xfer < 0) {
1325 if (xfer == -EAGAIN) {
1326 snd_pcm_wait(cardIns->capturePcmHandle, AUDIO_PCM_WAIT);
1327 continue;
1328 }
1329 AUDIO_FUNC_LOGE("snd_pcm_mmap_readi: %{public}s", snd_strerror(xfer));
1330 return HDF_FAILURE;
1331 }
1332
1333 if (xfer > 0) {
1334 mmapAddr += xfer * frameSize;
1335 size -= xfer;
1336 cardIns->capMmapFrames += xfer;
1337 }
1338 }
1339
1340 return HDF_SUCCESS;
1341 }
1342
AudioOutputCaptureReqMmapBuffer(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1343 int32_t AudioOutputCaptureReqMmapBuffer(
1344 const struct DevHandle *handle, int cmdId, const struct AudioHwCaptureParam *handleData)
1345 {
1346 int32_t ret;
1347
1348 (void)cmdId;
1349 if (handle == NULL || handleData == NULL) {
1350 AUDIO_FUNC_LOGE("param is NULL!");
1351 return HDF_FAILURE;
1352 }
1353
1354 ret = MmapDescWriteBufferCapture(handleData);
1355 if (ret != HDF_SUCCESS) {
1356 AUDIO_FUNC_LOGE("Capture mmap write buffer failed!");
1357 return ret;
1358 }
1359
1360 return HDF_SUCCESS;
1361 }
1362
AudioOutputCaptureGetMmapPosition(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)1363 int32_t AudioOutputCaptureGetMmapPosition(
1364 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
1365 {
1366 struct AudioCardInfo *cardIns;
1367
1368 (void)cmdId;
1369 if (handle == NULL || handleData == NULL) {
1370 AUDIO_FUNC_LOGE("param is NULL!");
1371 return HDF_FAILURE;
1372 }
1373
1374 const char *cardName = handleData->captureMode.hwInfo.adapterName;
1375 cardIns = GetCardIns(cardName);
1376 if (cardIns == NULL) {
1377 AUDIO_FUNC_LOGE("Get cardIns is NULL!");
1378 return HDF_FAILURE;
1379 }
1380 handleData->frameCaptureMode.frames = cardIns->capMmapFrames;
1381
1382 return HDF_SUCCESS;
1383 }
1384
AudioInterfaceLibOutputCapture(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)1385 int32_t AudioInterfaceLibOutputCapture(
1386 const struct DevHandle *handle, int cmdId, struct AudioHwCaptureParam *handleData)
1387 {
1388 int32_t ret;
1389
1390 if (handle == NULL || handleData == NULL) {
1391 AUDIO_FUNC_LOGE("Parameter is NULL!");
1392 return HDF_FAILURE;
1393 }
1394
1395 switch (cmdId) {
1396 case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
1397 ret = AudioOutputCaptureHwParams(handle, cmdId, handleData);
1398 break;
1399 case AUDIO_DRV_PCM_IOCTL_READ:
1400 ret = AudioOutputCaptureRead(handle, cmdId, handleData);
1401 break;
1402 case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE:
1403 ret = AudioOutputCaptureStart(handle, cmdId, handleData);
1404 break;
1405 case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE:
1406 ret = AudioOutputCapturePrepare(handle, cmdId, handleData);
1407 break;
1408 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE:
1409 ret = AudioOutputCaptureClose(handle, cmdId, handleData);
1410 break;
1411 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN:
1412 ret = AudioOutputCaptureOpen(handle, cmdId, handleData);
1413 break;
1414 case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE:
1415 ret = AudioOutputCaptureStop(handle, cmdId, handleData);
1416 break;
1417 case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE:
1418 ret = AudioCtlCaptureSetPauseStu(handle, cmdId, handleData);
1419 break;
1420 case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE:
1421 ret = AudioOutputCaptureReqMmapBuffer(handle, cmdId, handleData);
1422 break;
1423 case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE:
1424 ret = AudioOutputCaptureGetMmapPosition(handle, cmdId, handleData);
1425 break;
1426 default:
1427 AUDIO_FUNC_LOGE("Output Mode not support!");
1428 ret = HDF_FAILURE;
1429 break;
1430 }
1431
1432 return ret;
1433 }
1434
AudioInterfaceLibModeCapture(const struct DevHandle * handle,struct AudioHwCaptureParam * handleData,int cmdId)1435 int32_t AudioInterfaceLibModeCapture(const struct DevHandle *handle, struct AudioHwCaptureParam *handleData, int cmdId)
1436 {
1437 AUDIO_FUNC_LOGI();
1438 if (handle == NULL || handleData == NULL) {
1439 AUDIO_FUNC_LOGE("paras is NULL!");
1440 return HDF_FAILURE;
1441 }
1442
1443 switch (cmdId) {
1444 case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
1445 case AUDIO_DRV_PCM_IOCTL_READ:
1446 case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE:
1447 case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE:
1448 case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE:
1449 case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE:
1450 case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE:
1451 case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE:
1452 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN:
1453 case AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE:
1454 return (AudioInterfaceLibOutputCapture(handle, cmdId, handleData));
1455 case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE:
1456 case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE:
1457 case AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE:
1458 case AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE:
1459 case AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE:
1460 case AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE:
1461 case AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE:
1462 case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE:
1463 case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE:
1464 return (AudioInterfaceLibCtlCapture(handle, cmdId, handleData));
1465 default:
1466 AUDIO_FUNC_LOGE("Mode Error!");
1467 break;
1468 }
1469
1470 return HDF_ERR_NOT_SUPPORT;
1471 }
1472