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 <math.h>
17 #include <sys/mman.h>
18 #include "hdf_types.h"
19 #include "osal_mem.h"
20 #include "audio_adapter_info_common.h"
21 #include "audio_common.h"
22 #include "audio_interface_lib_capture.h"
23 #include "audio_internal.h"
24 #include "audio_uhdf_log.h"
25 #include "v4_0/iaudio_capture.h"
26 #include "securec.h"
27 
28 #define HDF_LOG_TAG HDF_AUDIO_PRIMARY_IMPL
29 
30 #define FRAME_SIZE        1024
31 #define CONFIG_FRAME_SIZE ((FRAME_SIZE) * 2)
32 
33 #define CONFIG_FRAME_COUNT ((8000 * 2 + ((CONFIG_FRAME_SIZE) - 1)) / (CONFIG_FRAME_SIZE))
34 #define BITS_TO_FROMAT    3
35 #define VOLUME_AVERAGE    2
36 #define INTEGER_TO_DEC    10
37 #define DECIMAL_PART      5
38 
39 /* add For Capture Bytes To Frames */
AudioCaptureStart(struct IAudioCapture * handle)40 int32_t AudioCaptureStart(struct IAudioCapture *handle)
41 {
42     AUDIO_FUNC_LOGD("Enter.");
43     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
44     if (hwCapture == NULL) {
45         AUDIO_FUNC_LOGE("The hwCapture is NULL");
46         return AUDIO_ERR_INVALID_PARAM;
47     }
48 
49     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
50     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
51         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
52         return AUDIO_ERR_INTERNAL;
53     }
54     if (hwCapture->captureParam.frameCaptureMode.buffer != NULL) {
55         AUDIO_FUNC_LOGE("IAudioCapture already start!");
56         return AUDIO_SUCCESS; // capture is busy now
57     }
58     if (hwCapture->devDataHandle == NULL) {
59         AUDIO_FUNC_LOGE("CaptureStart Bind Fail!");
60         return AUDIO_ERR_INTERNAL;
61     }
62 
63     int32_t ret = (*pInterfaceLibModeCapture)(
64         hwCapture->devDataHandle, &hwCapture->captureParam, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE);
65     if (ret < 0) {
66         AUDIO_FUNC_LOGE("AudioCaptureStart SetParams FAIL");
67         return AUDIO_ERR_INTERNAL;
68     }
69 
70     char *tbuffer = (char *)OsalMemCalloc(FRAME_DATA);
71     if (tbuffer == NULL) {
72         AUDIO_FUNC_LOGE("Calloc Capture tbuffer Fail!");
73         return AUDIO_ERR_MALLOC_FAIL;
74     }
75 
76     hwCapture->captureParam.frameCaptureMode.buffer = tbuffer;
77 
78     AudioLogRecord(AUDIO_INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Capture Start");
79     return AUDIO_SUCCESS;
80 }
81 
AudioCaptureStop(struct IAudioCapture * handle)82 int32_t AudioCaptureStop(struct IAudioCapture *handle)
83 {
84     AUDIO_FUNC_LOGD("Enter.");
85     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
86     if (hwCapture == NULL) {
87         AUDIO_FUNC_LOGE("hwCapture is null");
88         return AUDIO_ERR_INVALID_PARAM;
89     }
90     if (hwCapture->devDataHandle == NULL) {
91         AUDIO_FUNC_LOGE("CaptureStart Bind Fail!");
92         return AUDIO_ERR_INTERNAL;
93     }
94     if (hwCapture->captureParam.frameCaptureMode.buffer != NULL) {
95         AudioMemFree((void **)&hwCapture->captureParam.frameCaptureMode.buffer);
96     } else {
97         AUDIO_FUNC_LOGE("Repeat invalid stop operation!");
98         return AUDIO_SUCCESS;
99     }
100 
101     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
102     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
103         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
104         return AUDIO_ERR_INTERNAL;
105     }
106 
107     int32_t ret = (*pInterfaceLibModeCapture)(
108         hwCapture->devDataHandle, &hwCapture->captureParam, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE);
109     if (ret < 0) {
110         AUDIO_FUNC_LOGE("AudioCaptureStop SetParams FAIL");
111         return AUDIO_ERR_INTERNAL;
112     }
113 
114     AudioLogRecord(AUDIO_INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Capture Stop");
115     return AUDIO_SUCCESS;
116 }
117 
AudioCapturePause(struct IAudioCapture * handle)118 int32_t AudioCapturePause(struct IAudioCapture *handle)
119 {
120     AUDIO_FUNC_LOGD("Enter.");
121     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
122     if (hwCapture == NULL) {
123         AUDIO_FUNC_LOGE("hwCapture is empty");
124         return AUDIO_ERR_INVALID_PARAM;
125     }
126     if (hwCapture->captureParam.frameCaptureMode.buffer == NULL) {
127         AUDIO_FUNC_LOGE("IAudioCapture already stop!");
128         return AUDIO_ERR_INTERNAL;
129     }
130     if (hwCapture->captureParam.captureMode.ctlParam.pause) {
131         AUDIO_FUNC_LOGE("Audio capture is already pause!");
132         return AUDIO_ERR_NOT_SUPPORT;
133     }
134     if (hwCapture->devDataHandle == NULL) {
135         AUDIO_FUNC_LOGE("CaptureStart Bind Fail!");
136         return AUDIO_ERR_INTERNAL;
137     }
138 
139     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
140     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
141         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
142         return AUDIO_ERR_INTERNAL;
143     }
144 
145     bool pauseStatus = hwCapture->captureParam.captureMode.ctlParam.pause;
146     hwCapture->captureParam.captureMode.ctlParam.pause = true;
147 
148     int32_t ret = (*pInterfaceLibModeCapture)(
149         hwCapture->devDataHandle, &hwCapture->captureParam, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE);
150     if (ret < 0) {
151         AUDIO_FUNC_LOGE("Audio Capture Pause FAIL!");
152         hwCapture->captureParam.captureMode.ctlParam.pause = pauseStatus;
153         return AUDIO_ERR_INTERNAL;
154     }
155 
156     AudioLogRecord(AUDIO_INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Capture Pause");
157     return AUDIO_SUCCESS;
158 }
159 
AudioCaptureResume(struct IAudioCapture * handle)160 int32_t AudioCaptureResume(struct IAudioCapture *handle)
161 {
162     AUDIO_FUNC_LOGD("Enter.");
163     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
164     if (hwCapture == NULL) {
165         AUDIO_FUNC_LOGE("hwCapture is empty");
166         return AUDIO_ERR_INVALID_PARAM;
167     }
168     if (!hwCapture->captureParam.captureMode.ctlParam.pause) {
169         AUDIO_FUNC_LOGE("Audio capture is already Resume !");
170         return AUDIO_ERR_NOT_SUPPORT;
171     }
172     if (hwCapture->devDataHandle == NULL) {
173         AUDIO_FUNC_LOGE("Capture Start Bind Fail!");
174         return AUDIO_ERR_INTERNAL;
175     }
176 
177     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
178     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
179         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
180         return AUDIO_ERR_INTERNAL;
181     }
182 
183     bool resumeStatus = hwCapture->captureParam.captureMode.ctlParam.pause;
184     hwCapture->captureParam.captureMode.ctlParam.pause = false;
185 
186     int32_t ret = (*pInterfaceLibModeCapture)(
187         hwCapture->devDataHandle, &hwCapture->captureParam, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE);
188     if (ret < 0) {
189         AUDIO_FUNC_LOGE("Audio capture Resume FAIL!");
190         hwCapture->captureParam.captureMode.ctlParam.pause = resumeStatus;
191         return AUDIO_ERR_INTERNAL;
192     }
193 
194     AudioLogRecord(AUDIO_INFO, "[%s]-[%s]-[%d] :> [%s]", __FILE__, __func__, __LINE__, "Audio Capture Resume");
195     return AUDIO_SUCCESS;
196 }
197 
AudioCaptureFlush(struct IAudioCapture * handle)198 int32_t AudioCaptureFlush(struct IAudioCapture *handle)
199 {
200     AUDIO_FUNC_LOGD("Enter.");
201     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
202     if (hwCapture == NULL) {
203         AUDIO_FUNC_LOGE("hwCapture is empty");
204         return AUDIO_ERR_INVALID_PARAM;
205     }
206     return AUDIO_ERR_NOT_SUPPORT;
207 }
208 
AudioCaptureGetFrameSize(struct IAudioCapture * handle,uint64_t * size)209 int32_t AudioCaptureGetFrameSize(struct IAudioCapture *handle, uint64_t *size)
210 {
211     AUDIO_FUNC_LOGD("Enter.");
212     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
213     if (hwCapture == NULL || size == NULL) {
214         AUDIO_FUNC_LOGE("Parameter error!");
215         return AUDIO_ERR_INVALID_PARAM;
216     }
217 
218     uint32_t channelCount = hwCapture->captureParam.frameCaptureMode.attrs.channelCount;
219     enum AudioFormat format = hwCapture->captureParam.frameCaptureMode.attrs.format;
220     uint32_t formatBitsCapture = 0;
221 
222     int32_t ret = FormatToBits(format, &formatBitsCapture);
223     if (ret != AUDIO_SUCCESS) {
224         return ret;
225     }
226 
227     *size = FRAME_SIZE * channelCount * (formatBitsCapture >> BITS_TO_FROMAT);
228     return AUDIO_SUCCESS;
229 }
230 
AudioCaptureGetFrameCount(struct IAudioCapture * handle,uint64_t * count)231 int32_t AudioCaptureGetFrameCount(struct IAudioCapture *handle, uint64_t *count)
232 {
233     AUDIO_FUNC_LOGD("Enter.");
234     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
235     if (hwCapture == NULL || count == NULL) {
236         AUDIO_FUNC_LOGE("Parameter error!");
237         return AUDIO_ERR_INVALID_PARAM;
238     }
239 
240     *count = hwCapture->captureParam.frameCaptureMode.frames;
241     return AUDIO_SUCCESS;
242 }
243 
AudioCaptureSetSampleAttributes(struct IAudioCapture * handle,const struct AudioSampleAttributes * attrs)244 int32_t AudioCaptureSetSampleAttributes(struct IAudioCapture *handle, const struct AudioSampleAttributes *attrs)
245 {
246     AUDIO_FUNC_LOGD("Enter.");
247     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
248     if (hwCapture == NULL || attrs == NULL) {
249         AUDIO_FUNC_LOGE("Parameter error!");
250         return AUDIO_ERR_INVALID_PARAM;
251     }
252 
253     int32_t ret = AudioCheckParaAttr(attrs);
254     if (ret != AUDIO_SUCCESS) {
255         AUDIO_FUNC_LOGE("AudioCheckParaAttr error!");
256         return ret;
257     }
258 
259     struct AudioSampleAttributes tempAttrs = hwCapture->captureParam.frameCaptureMode.attrs;
260     hwCapture->captureParam.frameCaptureMode.attrs = *attrs;
261 
262     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
263     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
264         hwCapture->captureParam.frameCaptureMode.attrs = tempAttrs;
265         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
266         return AUDIO_ERR_INTERNAL;
267     }
268     if (hwCapture->devDataHandle == NULL) {
269         hwCapture->captureParam.frameCaptureMode.attrs = tempAttrs;
270         return AUDIO_ERR_INTERNAL;
271     }
272 
273     ret = (*pInterfaceLibModeCapture)
274         (hwCapture->devDataHandle, &hwCapture->captureParam, AUDIO_DRV_PCM_IOCTL_HW_PARAMS);
275     if (ret < 0) {
276         AUDIO_FUNC_LOGE("CaptureSetSampleAttributes FAIL");
277         hwCapture->captureParam.frameCaptureMode.attrs = tempAttrs;
278         return AUDIO_ERR_INTERNAL;
279     }
280     return AUDIO_SUCCESS;
281 }
282 
AudioCaptureGetSampleAttributes(struct IAudioCapture * handle,struct AudioSampleAttributes * attrs)283 int32_t AudioCaptureGetSampleAttributes(struct IAudioCapture *handle, struct AudioSampleAttributes *attrs)
284 {
285     AUDIO_FUNC_LOGD("Enter.");
286     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
287     if (hwCapture == NULL || attrs == NULL) {
288         AUDIO_FUNC_LOGE("Parameter error!");
289         return AUDIO_ERR_INVALID_PARAM;
290     }
291     attrs->format = hwCapture->captureParam.frameCaptureMode.attrs.format;
292     attrs->sampleRate = hwCapture->captureParam.frameCaptureMode.attrs.sampleRate;
293     attrs->channelCount = hwCapture->captureParam.frameCaptureMode.attrs.channelCount;
294     attrs->interleaved = hwCapture->captureParam.frameCaptureMode.attrs.interleaved;
295     attrs->type = hwCapture->captureParam.frameCaptureMode.attrs.type;
296     attrs->period = hwCapture->captureParam.frameCaptureMode.attrs.period;
297     attrs->frameSize = hwCapture->captureParam.frameCaptureMode.attrs.frameSize;
298     attrs->isBigEndian = hwCapture->captureParam.frameCaptureMode.attrs.isBigEndian;
299     attrs->isSignedData = hwCapture->captureParam.frameCaptureMode.attrs.isSignedData;
300     attrs->startThreshold = hwCapture->captureParam.frameCaptureMode.attrs.startThreshold;
301     attrs->stopThreshold = hwCapture->captureParam.frameCaptureMode.attrs.stopThreshold;
302     attrs->silenceThreshold = hwCapture->captureParam.frameCaptureMode.attrs.silenceThreshold;
303     return AUDIO_SUCCESS;
304 }
305 
AudioCaptureGetCurrentChannelId(struct IAudioCapture * handle,uint32_t * channelId)306 int32_t AudioCaptureGetCurrentChannelId(struct IAudioCapture *handle, uint32_t *channelId)
307 {
308     AUDIO_FUNC_LOGD("Enter.");
309     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
310     if (hwCapture == NULL || channelId == NULL) {
311         AUDIO_FUNC_LOGE("Parameter error!");
312         return AUDIO_ERR_INVALID_PARAM;
313     }
314 
315     *channelId = hwCapture->captureParam.frameCaptureMode.attrs.channelCount;
316     return AUDIO_SUCCESS;
317 }
318 
AudioCaptureCheckSceneCapability(struct IAudioCapture * handle,const struct AudioSceneDescriptor * scene,bool * supported)319 int32_t AudioCaptureCheckSceneCapability(
320     struct IAudioCapture *handle, const struct AudioSceneDescriptor *scene, bool *supported)
321 {
322     AUDIO_FUNC_LOGD("Enter.");
323     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
324     if (hwCapture == NULL || scene == NULL || supported == NULL) {
325         AUDIO_FUNC_LOGE("Parameter error!");
326         return AUDIO_ERR_INVALID_PARAM;
327     }
328 #ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT
329     *supported = false;
330     /* Temporary storage does not save the structure */
331     struct AudioHwCaptureParam captureParam = hwCapture->captureParam;
332     captureParam.frameCaptureMode.attrs.type = (enum AudioCategory)scene->scene.id;
333     captureParam.captureMode.hwInfo.deviceDescript.pins = scene->desc.pins;
334 
335     PathSelAnalysisJson *pPathSelAnalysisJson = AudioPassthroughGetPathSelAnalysisJson();
336     if (pPathSelAnalysisJson == NULL || *pPathSelAnalysisJson == NULL) {
337         AUDIO_FUNC_LOGE("pPathSelAnalysisJson Is NULL!");
338         return AUDIO_ERR_NOT_SUPPORT;
339     }
340 
341     int32_t ret = (*pPathSelAnalysisJson)((void *)&captureParam, CHECKSCENE_PATH_SELECT_CAPTURE);
342     if (ret < 0) {
343         if (ret == AUDIO_ERR_NOT_SUPPORT) {
344             AUDIO_FUNC_LOGE("AudioCaptureCheckSceneCapability not Support!");
345             return AUDIO_ERR_NOT_SUPPORT;
346         } else {
347             AUDIO_FUNC_LOGE("AudioCaptureCheckSceneCapability fail!");
348             return AUDIO_ERR_INTERNAL;
349         }
350     }
351     *supported = true;
352     return AUDIO_SUCCESS;
353 #else
354     return AUDIO_ERR_NOT_SUPPORT;
355 #endif
356 }
357 
AudioCaptureSelectScene(struct IAudioCapture * handle,const struct AudioSceneDescriptor * scene)358 int32_t AudioCaptureSelectScene(struct IAudioCapture *handle, const struct AudioSceneDescriptor *scene)
359 {
360     AUDIO_FUNC_LOGD("Enter.");
361     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
362     if (hwCapture == NULL || scene == NULL) {
363         AUDIO_FUNC_LOGE("Parameter error!");
364         return AUDIO_ERR_INVALID_PARAM;
365     }
366     if (hwCapture->devCtlHandle == NULL) {
367         AUDIO_FUNC_LOGE("CaptureSelectScene Bind Fail!");
368         return AUDIO_ERR_INTERNAL;
369     }
370 #ifndef AUDIO_HAL_NOTSUPPORT_PATHSELECT
371     PathSelAnalysisJson *pPathSelAnalysisJson = AudioPassthroughGetPathSelAnalysisJson();
372     if (pPathSelAnalysisJson == NULL || *pPathSelAnalysisJson == NULL) {
373         AUDIO_FUNC_LOGE("pPathSelAnalysisJson Is NULL!");
374         return AUDIO_ERR_NOT_SUPPORT;
375     }
376 
377     enum AudioCategory typeTemp = hwCapture->captureParam.frameCaptureMode.attrs.type;
378     enum AudioPortPin pinsTemp = hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins;
379 
380     hwCapture->captureParam.frameCaptureMode.attrs.type = (enum AudioCategory)(scene->scene.id);
381     hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins = scene->desc.pins;
382     if ((*pPathSelAnalysisJson)((void *)&hwCapture->captureParam, CAPTURE_PATH_SELECT) < 0) {
383         AUDIO_FUNC_LOGE("AudioCaptureSelectScene Fail!");
384         hwCapture->captureParam.frameCaptureMode.attrs.type = typeTemp;
385         hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins = pinsTemp;
386         return AUDIO_ERR_INTERNAL;
387     }
388 
389     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
390     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
391         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Is NULL");
392         hwCapture->captureParam.frameCaptureMode.attrs.type = typeTemp;
393         hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins = pinsTemp;
394         return AUDIO_ERR_INTERNAL;
395     }
396 
397     int32_t ret = (*pInterfaceLibModeCapture)(
398         hwCapture->devCtlHandle, &hwCapture->captureParam, AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE);
399     if (ret < 0) {
400         AUDIO_FUNC_LOGE("SetSelectSceneParams FAIL!");
401         hwCapture->captureParam.frameCaptureMode.attrs.type = typeTemp;
402         hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins = pinsTemp;
403         return AUDIO_ERR_INTERNAL;
404     }
405     return AUDIO_SUCCESS;
406 #else
407     return AUDIO_ERR_NOT_SUPPORT;
408 #endif
409 }
410 
AudioCaptureSetMute(struct IAudioCapture * handle,bool mute)411 int32_t AudioCaptureSetMute(struct IAudioCapture *handle, bool mute)
412 {
413     AUDIO_FUNC_LOGD("Enter.");
414     struct AudioHwCapture *impl = (struct AudioHwCapture *)handle;
415     if (impl == NULL) {
416         AUDIO_FUNC_LOGE("Parameter error!");
417         return AUDIO_ERR_INVALID_PARAM;
418     }
419     if (impl->devCtlHandle == NULL) {
420         AUDIO_FUNC_LOGE("CaptureSetMute Bind Fail!");
421         return AUDIO_ERR_INTERNAL;
422     }
423 
424     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
425     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
426         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
427         return AUDIO_ERR_INTERNAL;
428     }
429 
430     bool muteStatus = impl->captureParam.captureMode.ctlParam.mute;
431     impl->captureParam.captureMode.ctlParam.mute = mute;
432 
433     int32_t ret =
434         (*pInterfaceLibModeCapture)(impl->devCtlHandle, &impl->captureParam, AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE);
435     if (ret < 0) {
436         AUDIO_FUNC_LOGE("SetMute SetParams FAIL");
437         impl->captureParam.captureMode.ctlParam.mute = muteStatus;
438         return AUDIO_ERR_INTERNAL;
439     }
440 
441     AudioLogRecord(AUDIO_INFO, "[%s]-[%s]-[%d] :> [Setmute = %d]", __FILE__, __func__, __LINE__, mute);
442     return AUDIO_SUCCESS;
443 }
444 
AudioCaptureGetMute(struct IAudioCapture * handle,bool * mute)445 int32_t AudioCaptureGetMute(struct IAudioCapture *handle, bool *mute)
446 {
447     AUDIO_FUNC_LOGD("Enter.");
448     struct AudioHwCapture *impl = (struct AudioHwCapture *)handle;
449     if (impl == NULL || mute == NULL) {
450         AUDIO_FUNC_LOGE("Parameter error!");
451         return AUDIO_ERR_INVALID_PARAM;
452     }
453     if (impl->devCtlHandle == NULL) {
454         AUDIO_FUNC_LOGE("CaptureGetMute Bind Fail!");
455         return AUDIO_ERR_INTERNAL;
456     }
457 
458     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
459     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
460         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
461         return AUDIO_ERR_INTERNAL;
462     }
463 
464     int32_t ret =
465         (*pInterfaceLibModeCapture)(impl->devCtlHandle, &impl->captureParam, AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE);
466     if (ret < 0) {
467         AUDIO_FUNC_LOGE("GetMute SetParams FAIL");
468         return AUDIO_ERR_INTERNAL;
469     }
470 
471     *mute = impl->captureParam.captureMode.ctlParam.mute;
472 
473     AUDIO_FUNC_LOGI("Get Mute SUCCESS!");
474     return AUDIO_SUCCESS;
475 }
476 
AudioCaptureSetVolume(struct IAudioCapture * handle,float volume)477 int32_t AudioCaptureSetVolume(struct IAudioCapture *handle, float volume)
478 {
479     AUDIO_FUNC_LOGD("Enter.");
480     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
481     if (hwCapture == NULL) {
482         AUDIO_FUNC_LOGE("Parameter error!");
483         return AUDIO_ERR_INVALID_PARAM;
484     }
485 
486     float volumeTemp = hwCapture->captureParam.captureMode.ctlParam.volume;
487     float volMax = (float)hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax;
488     float volMin = (float)hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin;
489     if (hwCapture->devCtlHandle == NULL) {
490         AUDIO_FUNC_LOGE("Bind Fail!");
491         return AUDIO_ERR_INTERNAL;
492     }
493     if (volume < 0 || volume > 1) {
494         AUDIO_FUNC_LOGE("volume param Is error!");
495         return AUDIO_ERR_INVALID_PARAM;
496     }
497 
498     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
499     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
500         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
501         return AUDIO_ERR_INTERNAL;
502     }
503 
504     volume = (volume == 0) ? 1 : (volume * VOLUME_CHANGE);
505 
506     /* change volume to db */
507     float volTemp = ((volMax - volMin) / 2) * log10(volume) + volMin;
508     if (volTemp < volMin || volTemp > volMax) {
509         AUDIO_FUNC_LOGE("volTemp fail");
510         return AUDIO_ERR_INTERNAL;
511     }
512 
513     hwCapture->captureParam.captureMode.ctlParam.volume = volTemp;
514 
515     int32_t ret = (*pInterfaceLibModeCapture)(
516         hwCapture->devCtlHandle, &hwCapture->captureParam, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE);
517     if (ret < 0) {
518         AUDIO_FUNC_LOGE("SetParams FAIL!");
519         hwCapture->captureParam.captureMode.ctlParam.volume = volumeTemp;
520         return AUDIO_ERR_INTERNAL;
521     }
522     return AUDIO_SUCCESS;
523 }
524 
AudioCaptureGetVolume(struct IAudioCapture * handle,float * volume)525 int32_t AudioCaptureGetVolume(struct IAudioCapture *handle, float *volume)
526 {
527     AUDIO_FUNC_LOGD("Enter.");
528     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
529     if (hwCapture == NULL || volume == NULL) {
530         AUDIO_FUNC_LOGE("Parameter error!");
531         return AUDIO_ERR_INVALID_PARAM;
532     }
533 
534     if (hwCapture->devCtlHandle == NULL) {
535         AUDIO_FUNC_LOGE("CaptureStart Bind Fail!");
536         return AUDIO_ERR_INTERNAL;
537     }
538 
539     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
540     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
541         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
542         return AUDIO_ERR_INTERNAL;
543     }
544 
545     int32_t ret = (*pInterfaceLibModeCapture)(
546         hwCapture->devCtlHandle, &hwCapture->captureParam, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE);
547     if (ret < 0) {
548         AUDIO_FUNC_LOGE("Get Volume FAIL!");
549         return AUDIO_ERR_INTERNAL;
550     }
551 
552     float volumeTemp = hwCapture->captureParam.captureMode.ctlParam.volume;
553     float volMax = (float)hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax;
554     float volMin = (float)hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin;
555     if ((volMax - volMin) == 0) {
556         AUDIO_FUNC_LOGE("Divisor cannot be zero!");
557         return AUDIO_ERR_INTERNAL;
558     }
559     volumeTemp = (volumeTemp - volMin) / ((volMax - volMin) / VOLUME_AVERAGE);
560 
561     int volumeT = (int)((pow(INTEGER_TO_DEC, volumeTemp) + DECIMAL_PART) / INTEGER_TO_DEC); // delet 0.X num
562 
563     *volume = (float)volumeT / INTEGER_TO_DEC;                                               // get volume (0-1)
564     return AUDIO_SUCCESS;
565 }
566 
AudioCaptureGetGainThreshold(struct IAudioCapture * handle,float * min,float * max)567 int32_t AudioCaptureGetGainThreshold(struct IAudioCapture *handle, float *min, float *max)
568 {
569     AUDIO_FUNC_LOGD("Enter.");
570     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
571     if (hwCapture == NULL || min == NULL || max == NULL) {
572         AUDIO_FUNC_LOGE("Parameter error!");
573         return AUDIO_ERR_INVALID_PARAM;
574     }
575     if (hwCapture->devCtlHandle == NULL) {
576         AUDIO_FUNC_LOGE("AudioCaptureGetGainThreshold Bind Fail!");
577         return AUDIO_ERR_INTERNAL;
578     }
579 
580     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
581     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
582         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Is NULL");
583         return AUDIO_ERR_INTERNAL;
584     }
585 
586     int32_t ret = (*pInterfaceLibModeCapture)(
587         hwCapture->devCtlHandle, &hwCapture->captureParam, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE);
588     if (ret < 0) {
589         AUDIO_FUNC_LOGE("SetParams FAIL!");
590         return AUDIO_ERR_INTERNAL;
591     }
592 
593     *max = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMax;
594     *min = hwCapture->captureParam.captureMode.ctlParam.audioGain.gainMin;
595     return AUDIO_SUCCESS;
596 }
597 
AudioCaptureGetGain(struct IAudioCapture * handle,float * gain)598 int32_t AudioCaptureGetGain(struct IAudioCapture *handle, float *gain)
599 {
600     struct AudioHwCapture *impl = (struct AudioHwCapture *)handle;
601     if (impl == NULL || gain == NULL) {
602         AUDIO_FUNC_LOGE("Parameter error!");
603         return AUDIO_ERR_INVALID_PARAM;
604     }
605     if (impl->devCtlHandle == NULL) {
606         AUDIO_FUNC_LOGE("CaptureStart Bind Fail!");
607         return AUDIO_ERR_INTERNAL;
608     }
609 
610     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
611     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
612         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
613         return AUDIO_ERR_INTERNAL;
614     }
615 
616     int32_t ret =
617         (*pInterfaceLibModeCapture)(impl->devCtlHandle, &impl->captureParam, AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE);
618     if (ret < 0) {
619         AUDIO_FUNC_LOGE("Get Volume FAIL!");
620         return AUDIO_ERR_INTERNAL;
621     }
622 
623     *gain = impl->captureParam.captureMode.ctlParam.audioGain.gain;
624     return AUDIO_SUCCESS;
625 }
626 
AudioCaptureSetGain(struct IAudioCapture * handle,float gain)627 int32_t AudioCaptureSetGain(struct IAudioCapture *handle, float gain)
628 {
629     AUDIO_FUNC_LOGD("Enter.");
630     struct AudioHwCapture *impl = (struct AudioHwCapture *)handle;
631     if (impl == NULL || gain < 0) {
632         AUDIO_FUNC_LOGE("Parameter error!");
633         return AUDIO_ERR_INVALID_PARAM;
634     }
635     if (impl->devCtlHandle == NULL) {
636         AUDIO_FUNC_LOGE("CaptureSetGain Bind Fail!");
637         return AUDIO_ERR_INTERNAL;
638     }
639 
640     float gainTemp = impl->captureParam.captureMode.ctlParam.audioGain.gain;
641     impl->captureParam.captureMode.ctlParam.audioGain.gain = gain;
642 
643     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
644     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
645         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
646         impl->captureParam.captureMode.ctlParam.audioGain.gain = gainTemp;
647         return AUDIO_ERR_INTERNAL;
648     }
649 
650     int32_t ret =
651         (*pInterfaceLibModeCapture)(impl->devCtlHandle, &impl->captureParam, AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE);
652     if (ret < 0) {
653         AUDIO_FUNC_LOGE("CaptureSetGain FAIL!");
654         impl->captureParam.captureMode.ctlParam.audioGain.gain = gainTemp;
655         return AUDIO_ERR_INTERNAL;
656     }
657     return AUDIO_SUCCESS;
658 }
659 
LogErrorGetRensonAndTime(struct AudioHwCapture * hwCapture,int errorReason)660 static int32_t LogErrorGetRensonAndTime(struct AudioHwCapture *hwCapture, int errorReason)
661 {
662     if (hwCapture == NULL) {
663         AUDIO_FUNC_LOGE("Parameter error!");
664         return AUDIO_ERR_INVALID_PARAM;
665     }
666     if (hwCapture->errorLog.iter >= ERROR_LOG_MAX_NUM) {
667         AUDIO_FUNC_LOGE("Capture item more then %{public}d.", ERROR_LOG_MAX_NUM);
668         return AUDIO_ERR_INTERNAL;
669     }
670     if (hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].reason == NULL) {
671         hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].reason = (char *)OsalMemCalloc(ERROR_REASON_DESC_LEN);
672         if (hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].reason == NULL) {
673             AUDIO_FUNC_LOGE("Calloc reasonDesc Fail!");
674             return AUDIO_ERR_MALLOC_FAIL;
675         }
676     }
677 
678     if (hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].currentTime == NULL) {
679         hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].currentTime =
680             (char *)OsalMemCalloc(ERROR_REASON_DESC_LEN);
681         if (hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].currentTime == NULL) {
682             AUDIO_FUNC_LOGE("Calloc time Fail!");
683             return AUDIO_ERR_MALLOC_FAIL;
684         }
685     }
686 
687     memset_s(hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].reason, ERROR_REASON_DESC_LEN, 0,
688         ERROR_REASON_DESC_LEN);
689     memset_s(hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].currentTime, ERROR_REASON_DESC_LEN, 0,
690         ERROR_REASON_DESC_LEN);
691 
692     int32_t ret = GetErrorReason(errorReason, hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].reason);
693     if (ret < 0) {
694         AUDIO_FUNC_LOGE("Capture GetErrorReason failed!");
695         return AUDIO_ERR_INTERNAL;
696     }
697 
698     ret = GetCurrentTime(hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].currentTime);
699     if (ret < 0) {
700         AUDIO_FUNC_LOGE("Capture GetCurrentTime failed!");
701         return AUDIO_ERR_INTERNAL;
702     }
703     return AUDIO_SUCCESS;
704 }
705 
LogErrorCapture(AudioHandle handle,int errorCode,int reason)706 static void LogErrorCapture(AudioHandle handle, int errorCode, int reason)
707 {
708     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
709     if (hwCapture == NULL) {
710         AUDIO_FUNC_LOGE("Parameter error!");
711         return;
712     }
713 
714     hwCapture->errorLog.totalErrors++;
715     if (hwCapture->errorLog.iter >= ERROR_LOG_MAX_NUM) {
716         hwCapture->errorLog.iter = 0;
717     }
718 
719     int32_t ret = LogErrorGetRensonAndTime(hwCapture, reason);
720     if (ret < 0) {
721         return;
722     }
723     if (errorCode == WRITE_FRAME_ERROR_CODE) {
724         hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].errorCode = errorCode;
725         hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].count = hwCapture->errorLog.iter;
726         hwCapture->errorLog.errorDump[hwCapture->errorLog.iter].frames =
727             hwCapture->captureParam.frameCaptureMode.frames;
728         hwCapture->errorLog.iter++;
729     }
730 }
731 
AudioCaptureCaptureFrame(struct IAudioCapture * capture,int8_t * frame,uint32_t * frameLen,uint64_t * replyBytes)732 int32_t AudioCaptureCaptureFrame(
733     struct IAudioCapture *capture, int8_t *frame, uint32_t *frameLen, uint64_t *replyBytes)
734 {
735     struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
736     if (hwCapture == NULL || frame == NULL || frameLen == NULL ||
737         hwCapture->captureParam.frameCaptureMode.buffer == NULL) {
738         AUDIO_FUNC_LOGE("Param is NULL Fail!");
739         return AUDIO_ERR_INVALID_PARAM;
740     }
741 
742     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
743     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
744         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
745         return AUDIO_ERR_INTERNAL;
746     }
747     if (hwCapture->devDataHandle == NULL) {
748         return AUDIO_ERR_INTERNAL;
749     }
750 
751     int32_t ret =
752         (*pInterfaceLibModeCapture)(hwCapture->devDataHandle, &hwCapture->captureParam, AUDIO_DRV_PCM_IOCTL_READ);
753     if (ret < 0) {
754         AUDIO_FUNC_LOGE("Capture Frame FAIL!");
755         LogErrorCapture(capture, WRITE_FRAME_ERROR_CODE, ret);
756         return AUDIO_ERR_INTERNAL;
757     }
758     if (*frameLen < hwCapture->captureParam.frameCaptureMode.bufferSize) {
759         AUDIO_FUNC_LOGE("Capture Frame frameLen too little!");
760         return AUDIO_ERR_INTERNAL;
761     }
762 
763     ret = memcpy_s(frame, (size_t)*frameLen, hwCapture->captureParam.frameCaptureMode.buffer,
764         (size_t)hwCapture->captureParam.frameCaptureMode.bufferSize);
765     if (ret != EOK) {
766         AUDIO_FUNC_LOGE("memcpy_s fail");
767         return AUDIO_ERR_INTERNAL;
768     }
769 
770     *replyBytes = (uint32_t)hwCapture->captureParam.frameCaptureMode.bufferSize;
771 
772     hwCapture->captureParam.frameCaptureMode.frames += hwCapture->captureParam.frameCaptureMode.bufferFrameSize;
773     if (hwCapture->captureParam.frameCaptureMode.attrs.sampleRate == 0) {
774         AUDIO_FUNC_LOGE("Divisor cannot be zero!");
775         return AUDIO_ERR_INTERNAL;
776     }
777     if (TimeToAudioTimeStamp(hwCapture->captureParam.frameCaptureMode.bufferFrameSize,
778         &hwCapture->captureParam.frameCaptureMode.time,
779         hwCapture->captureParam.frameCaptureMode.attrs.sampleRate) == HDF_FAILURE) {
780         AUDIO_FUNC_LOGE("Frame is NULL");
781         return AUDIO_ERR_INTERNAL;
782     }
783     return AUDIO_SUCCESS;
784 }
785 
AudioCaptureGetCapturePosition(struct IAudioCapture * capture,uint64_t * frames,struct AudioTimeStamp * time)786 int32_t AudioCaptureGetCapturePosition(struct IAudioCapture *capture, uint64_t *frames, struct AudioTimeStamp *time)
787 {
788     AUDIO_FUNC_LOGD("Enter.");
789     struct AudioHwCapture *impl = (struct AudioHwCapture *)capture;
790     if (impl == NULL || frames == NULL || time == NULL) {
791         AUDIO_FUNC_LOGE("Parameter error!");
792         return AUDIO_ERR_INVALID_PARAM;
793     }
794 
795     *frames = impl->captureParam.frameCaptureMode.frames;
796     *time = impl->captureParam.frameCaptureMode.time;
797     return AUDIO_SUCCESS;
798 }
799 
SetValueCapture(struct ExtraParams mExtraParams,struct AudioHwCapture * capture)800 static int32_t SetValueCapture(struct ExtraParams mExtraParams, struct AudioHwCapture *capture)
801 {
802     if (capture == NULL) {
803         AUDIO_FUNC_LOGE("Parameter error!");
804         return HDF_FAILURE;
805     }
806     if (mExtraParams.route != -1) {
807         capture->captureParam.captureMode.hwInfo.pathroute = mExtraParams.route;
808     }
809     if (mExtraParams.format != -1) {
810         capture->captureParam.frameCaptureMode.attrs.format = mExtraParams.format;
811     }
812     if (mExtraParams.channels != 0) {
813         capture->captureParam.frameCaptureMode.attrs.channelCount = mExtraParams.channels;
814     }
815     if (mExtraParams.flag) {
816         capture->captureParam.frameCaptureMode.frames = mExtraParams.frames;
817     }
818     if (mExtraParams.sampleRate != 0) {
819         capture->captureParam.frameCaptureMode.attrs.sampleRate = mExtraParams.sampleRate;
820     }
821     return HDF_SUCCESS;
822 }
823 
AudioCaptureSetExtraParams(struct IAudioCapture * handle,const char * keyValueList)824 int32_t AudioCaptureSetExtraParams(struct IAudioCapture *handle, const char *keyValueList)
825 {
826     AUDIO_FUNC_LOGD("Enter.");
827     int32_t check = 0;
828     int32_t count = 0;
829     struct ExtraParams mExtraParams;
830 
831     struct AudioHwCapture *capture = (struct AudioHwCapture *)handle;
832     if (capture == NULL || keyValueList == NULL) {
833         AUDIO_FUNC_LOGE("Parameter error!");
834         return AUDIO_ERR_INVALID_PARAM;
835     }
836 
837     if (AudioSetExtraParams(keyValueList, &count, &mExtraParams, &check) < 0) {
838         return AUDIO_ERR_INTERNAL;
839     }
840     if (count != 0 && check == count) {
841         SetValueCapture(mExtraParams, capture);
842         return AUDIO_SUCCESS;
843     } else {
844         AUDIO_FUNC_LOGE("AudioSetExtraParams error!");
845         return AUDIO_ERR_INTERNAL;
846     }
847 }
848 
AudioCaptureGetExtraParams(struct IAudioCapture * handle,char * keyValueList,uint32_t listLenth)849 int32_t AudioCaptureGetExtraParams(struct IAudioCapture *handle, char *keyValueList, uint32_t listLenth)
850 {
851     AUDIO_FUNC_LOGD("Enter.");
852     int32_t ret;
853     struct AudioHwCapture *capture = (struct AudioHwCapture *)handle;
854     if (capture == NULL || keyValueList == NULL || listLenth == 0) {
855         AUDIO_FUNC_LOGE("Parameter error!");
856         return AUDIO_ERR_INVALID_PARAM;
857     }
858 
859     uint32_t bufferSize = strlen(ROUTE_SAMPLE) + strlen(FORMAT_SAMPLE) + strlen(CHANNELS_SAMPLE) +
860         strlen(FRAME_COUNT_SAMPLE) + strlen(SAMPLING_RATE_SAMPLE) + 1;
861     if (listLenth < bufferSize) {
862         AUDIO_FUNC_LOGE("listLenth < bufferSize error!");
863         return AUDIO_ERR_INTERNAL;
864     }
865 
866     ret = AddElementToList(
867         keyValueList, listLenth, AUDIO_ATTR_PARAM_ROUTE, &capture->captureParam.captureMode.hwInfo.pathroute);
868     if (ret < 0) {
869         AUDIO_FUNC_LOGE("AddElementToList hwInfo.pathroute failed!");
870         return AUDIO_ERR_INTERNAL;
871     }
872 
873     ret = AddElementToList(
874         keyValueList, listLenth, AUDIO_ATTR_PARAM_FORMAT, &capture->captureParam.frameCaptureMode.attrs.format);
875     if (ret < 0) {
876         AUDIO_FUNC_LOGE("AddElementToList attrs.format failed!");
877         return AUDIO_ERR_INTERNAL;
878     }
879 
880     ret = AddElementToList(
881         keyValueList, listLenth, AUDIO_ATTR_PARAM_CHANNELS, &capture->captureParam.frameCaptureMode.attrs.channelCount);
882     if (ret < 0) {
883         AUDIO_FUNC_LOGE("AddElementToList attrs.channelCount failed!");
884         return AUDIO_ERR_INTERNAL;
885     }
886 
887     ret = AddElementToList(
888         keyValueList, listLenth, AUDIO_ATTR_PARAM_FRAME_COUNT, &capture->captureParam.frameCaptureMode.frames);
889     if (ret < 0) {
890         AUDIO_FUNC_LOGE("AddElementToList frameCaptureMode.frames failed!");
891         return AUDIO_ERR_INTERNAL;
892     }
893 
894     ret = AddElementToList(keyValueList, listLenth, AUDIO_ATTR_PARAM_SAMPLING_RATE,
895         &capture->captureParam.frameCaptureMode.attrs.sampleRate);
896     if (ret < 0) {
897         AUDIO_FUNC_LOGE("AddElementToList attrs.sampleRate failed!");
898         return AUDIO_ERR_INTERNAL;
899     }
900     return AUDIO_SUCCESS;
901 }
902 
AudioCaptureReqMmapBuffer(struct IAudioCapture * handle,int32_t reqSize,struct AudioMmapBufferDescriptor * desc)903 int32_t AudioCaptureReqMmapBuffer(
904     struct IAudioCapture *handle, int32_t reqSize, struct AudioMmapBufferDescriptor *desc)
905 {
906     (void)handle;
907     (void)reqSize;
908     (void)desc;
909     return HDF_ERR_NOT_SUPPORT;
910 }
911 
AudioCaptureGetMmapPosition(struct IAudioCapture * handle,uint64_t * frames,struct AudioTimeStamp * time)912 int32_t AudioCaptureGetMmapPosition(struct IAudioCapture *handle, uint64_t *frames, struct AudioTimeStamp *time)
913 {
914     AUDIO_FUNC_LOGD("Enter.");
915     struct AudioHwCapture *capture = (struct AudioHwCapture *)handle;
916     if (capture == NULL || frames == NULL || time == NULL) {
917         AUDIO_FUNC_LOGE("Parameter error!");
918         return AUDIO_ERR_INVALID_PARAM;
919     }
920 
921     InterfaceLibModeCapturePassthrough *pInterfaceLibModeCapture = AudioPassthroughGetInterfaceLibModeCapture();
922     if (pInterfaceLibModeCapture == NULL || *pInterfaceLibModeCapture == NULL) {
923         AUDIO_FUNC_LOGE("pInterfaceLibModeCapture Fail!");
924         return AUDIO_ERR_INTERNAL;
925     }
926 
927     if (capture->devDataHandle == NULL) {
928         return AUDIO_ERR_INTERNAL;
929     }
930 
931     int32_t ret = (*pInterfaceLibModeCapture)(
932         capture->devDataHandle, &capture->captureParam, AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE);
933     if (ret < 0) {
934         AUDIO_FUNC_LOGE("GetMmapPosition SetParams FAIL");
935         return AUDIO_ERR_INTERNAL;
936     }
937 
938     *frames = capture->captureParam.frameCaptureMode.frames;
939 
940     capture->captureParam.frameCaptureMode.time.tvSec = (int64_t)(capture->captureParam.frameCaptureMode.frames /
941         capture->captureParam.frameCaptureMode.attrs.sampleRate);
942 
943     uint64_t lastBufFrames =
944         capture->captureParam.frameCaptureMode.frames % capture->captureParam.frameCaptureMode.attrs.sampleRate;
945 
946     capture->captureParam.frameCaptureMode.time.tvNSec =
947         (int64_t)((lastBufFrames * SEC_TO_NSEC) / capture->captureParam.frameCaptureMode.attrs.sampleRate);
948 
949     *time = capture->captureParam.frameCaptureMode.time;
950     return AUDIO_SUCCESS;
951 }
952 
AudioCaptureTurnStandbyMode(struct IAudioCapture * handle)953 int32_t AudioCaptureTurnStandbyMode(struct IAudioCapture *handle)
954 {
955     AUDIO_FUNC_LOGD("Enter.");
956     struct AudioHwCapture *capture = (struct AudioHwCapture *)handle;
957     if (capture == NULL) {
958         AUDIO_FUNC_LOGE("capture is null");
959         return AUDIO_ERR_INVALID_PARAM;
960     }
961 
962     capture->captureParam.captureMode.hwInfo.deviceDescript.pins = PIN_NONE;
963 
964     int32_t ret = AudioCaptureStop((AudioHandle)capture);
965     if (ret < 0) {
966         return AUDIO_ERR_INTERNAL;
967     }
968     return AUDIO_SUCCESS;
969 }
970 
AudioCaptureAudioDevDump(struct IAudioCapture * handle,int32_t range,int32_t fd)971 int32_t AudioCaptureAudioDevDump(struct IAudioCapture *handle, int32_t range, int32_t fd)
972 {
973     AUDIO_FUNC_LOGD("Enter.");
974     struct AudioHwCapture *capture = (struct AudioHwCapture *)handle;
975     if (capture == NULL) {
976         AUDIO_FUNC_LOGE("Parameter error!");
977         return AUDIO_ERR_INVALID_PARAM;
978     }
979 
980     dprintf(fd, "%s%d\n", "Number of errors: ", capture->errorLog.totalErrors);
981 
982     if (range < RANGE_MIN - 1 || range > RANGE_MAX) {
983         dprintf(fd, "%s\n", "Out of range, invalid output");
984         return AUDIO_SUCCESS;
985     }
986 
987     uint32_t mSize = capture->errorLog.iter;
988     if (range < RANGE_MIN) {
989         dprintf(fd, "%-5s  %-10s  %s\n", "count", "errorCode", "Time");
990         for (uint32_t i = 0; i < mSize; i++) {
991             dprintf(fd, FORMAT_TWO, capture->errorLog.errorDump[i].count + 1, capture->errorLog.errorDump[i].errorCode,
992                 capture->errorLog.errorDump[i].currentTime);
993         }
994     } else {
995         dprintf(fd, "%-5s  %-10s  %-20s  %-15s  %s\n", "count", "errorCode", "frames", "fail reason", "Time");
996         for (uint32_t i = 0; i < mSize; i++) {
997             dprintf(fd, FORMAT_ONE, capture->errorLog.errorDump[i].count + 1, capture->errorLog.errorDump[i].errorCode,
998                 capture->errorLog.errorDump[i].frames, capture->errorLog.errorDump[i].reason,
999                 capture->errorLog.errorDump[i].currentTime);
1000         }
1001     }
1002     return AUDIO_SUCCESS;
1003 }
1004 
AudioCaptureRelease(struct IAudioCapture * instance)1005 void AudioCaptureRelease(struct IAudioCapture *instance)
1006 {
1007     (void)instance;
1008 }
1009