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 */
40int32_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
82int32_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
118int32_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
160int32_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
198int32_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
209int32_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
231int32_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
244int32_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
283int32_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
306int32_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
319int32_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
358int32_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
411int32_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
445int32_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
477int32_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
525int32_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
567int32_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
598int32_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
627int32_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
660static 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
706static 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
732int32_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
786int32_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
800static 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
824int32_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
849int32_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
903int32_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
912int32_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
953int32_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
971int32_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
1005void AudioCaptureRelease(struct IAudioCapture *instance)
1006{
1007    (void)instance;
1008}
1009