1 /*
2  * Copyright (c) 2021-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 "audio_interface_lib_capture.h"
17 #include <unistd.h>
18 #include "audio_common.h"
19 #include "audio_uhdf_log.h"
20 #include "osal_mem.h"
21 #include "securec.h"
22 
23 #define HDF_LOG_TAG HDF_AUDIO_HAL_LIB
24 
25 /* virtual mixer device */
26 #define AUDIO_REPLY_EXTEND 64
27 #define AUDIO_SIZE_FRAME_16K (16 * 1024)
28 #define AUDIO_TRYNUM 2
29 #define AUDIO_US_TO_MS          1000
30 #define AUDIO_TRYNUM_TIME       ((AUDIO_US_TO_MS) * 3)
31 #define AUDIO_CAP_WAIT_DELAY    ((AUDIO_US_TO_MS) * 5)
32 
33 /* Out Put Capture */
34 static struct AudioPcmHwParams g_hwParams;
35 
SetHwParamsCapture(const struct AudioHwCaptureParam * const handleData)36 int32_t SetHwParamsCapture(const struct AudioHwCaptureParam * const handleData)
37 {
38     if (handleData == NULL) {
39         AUDIO_FUNC_LOGE("handleData is NULL!");
40         return HDF_FAILURE;
41     }
42     (void)memset_s(&g_hwParams, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams));
43     g_hwParams.streamType = AUDIO_CAPTURE_STREAM;
44     g_hwParams.channels = handleData->frameCaptureMode.attrs.channelCount;
45     g_hwParams.rate = handleData->frameCaptureMode.attrs.sampleRate;
46     g_hwParams.periodSize = handleData->frameCaptureMode.periodSize;
47     g_hwParams.periodCount = handleData->frameCaptureMode.periodCount;
48     g_hwParams.cardServiceName = (char*)handleData->captureMode.hwInfo.cardServiceName;
49     g_hwParams.format = handleData->frameCaptureMode.attrs.format;
50     g_hwParams.period = handleData->frameCaptureMode.attrs.period;
51     g_hwParams.frameSize = handleData->frameCaptureMode.attrs.frameSize;
52     g_hwParams.isBigEndian = handleData->frameCaptureMode.attrs.isBigEndian;
53     g_hwParams.isSignedData = handleData->frameCaptureMode.attrs.isSignedData;
54     g_hwParams.startThreshold = handleData->frameCaptureMode.attrs.startThreshold;
55     g_hwParams.stopThreshold = handleData->frameCaptureMode.attrs.stopThreshold;
56     g_hwParams.silenceThreshold = handleData->frameCaptureMode.attrs.silenceThreshold;
57     return HDF_SUCCESS;
58 }
59 
ParamsSbufWriteBuffer(struct HdfSBuf * sBuf)60 int32_t ParamsSbufWriteBuffer(struct HdfSBuf *sBuf)
61 {
62     if (sBuf == NULL) {
63         return HDF_FAILURE;
64     }
65     if (!HdfSbufWriteUint32(sBuf, (uint32_t)g_hwParams.streamType)) {
66         return HDF_FAILURE;
67     }
68     if (!HdfSbufWriteUint32(sBuf, g_hwParams.channels)) {
69         return HDF_FAILURE;
70     }
71     if (!HdfSbufWriteUint32(sBuf, g_hwParams.rate)) {
72         return HDF_FAILURE;
73     }
74     if (!HdfSbufWriteUint32(sBuf, g_hwParams.periodSize)) {
75         return HDF_FAILURE;
76     }
77     if (!HdfSbufWriteUint32(sBuf, g_hwParams.periodCount)) {
78         return HDF_FAILURE;
79     }
80     if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.format))) {
81         return HDF_FAILURE;
82     }
83     if (!HdfSbufWriteString(sBuf, g_hwParams.cardServiceName)) {
84         return HDF_FAILURE;
85     }
86     if (!HdfSbufWriteUint32(sBuf, g_hwParams.period)) {
87         return HDF_FAILURE;
88     }
89     if (!HdfSbufWriteUint32(sBuf, g_hwParams.frameSize)) {
90         return HDF_FAILURE;
91     }
92     if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.isBigEndian))) {
93         return HDF_FAILURE;
94     }
95     if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.isSignedData))) {
96         return HDF_FAILURE;
97     }
98     if (!HdfSbufWriteUint32(sBuf, g_hwParams.startThreshold)) {
99         return HDF_FAILURE;
100     }
101     if (!HdfSbufWriteUint32(sBuf, g_hwParams.stopThreshold)) {
102         return HDF_FAILURE;
103     }
104     if (!HdfSbufWriteUint32(sBuf, g_hwParams.silenceThreshold)) {
105         return HDF_FAILURE;
106     }
107     return HDF_SUCCESS;
108 }
109 
AudioCtlCaptureSetPauseBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)110 int32_t AudioCtlCaptureSetPauseBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
111 {
112     if (handleData == NULL || sBuf == NULL) {
113         AUDIO_FUNC_LOGE("handleData or sBuf is NULL!");
114         return HDF_FAILURE;
115     }
116     struct AudioCtlElemValue elemCaptureValue;
117     elemCaptureValue.id.cardServiceName = handleData->captureMode.hwInfo.cardServiceName;
118     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
119     elemCaptureValue.id.itemName = "Main Playback Pause";
120     elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.pause;
121 
122     return AudioSetElemValue(sBuf, &elemCaptureValue, true);
123 }
124 
AudioCtlCaptureSetPauseStu(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)125 int32_t AudioCtlCaptureSetPauseStu(const struct DevHandle *handle,
126     int cmdId, const struct AudioHwCaptureParam *handleData)
127 {
128     if (handle == NULL || handle->object == NULL || handleData == NULL) {
129         AUDIO_FUNC_LOGE("CaptureSetPauseStu paras is NULL!");
130         return HDF_FAILURE;
131     }
132 
133     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
134     if (sBuf == NULL) {
135         AUDIO_FUNC_LOGE("CaptureSetPauseStu Failed to obtain sBuf");
136         return HDF_FAILURE;
137     }
138 
139     if (!HdfSbufWriteString(sBuf, handleData->captureMode.hwInfo.cardServiceName)) {
140         AUDIO_FUNC_LOGE("HdfSbufWriteString cardServiceName failed!");
141         AudioFreeHdfSBuf(sBuf, NULL);
142         return HDF_FAILURE;
143     }
144 
145     int32_t ret = AudioCtlCaptureSetPauseBuf(sBuf, handleData);
146     if (ret < 0) {
147         AUDIO_FUNC_LOGE("Failed to Set Pause sBuf!");
148         AudioFreeHdfSBuf(sBuf, NULL);
149         return ret;
150     }
151 
152     cmdId = handleData->captureMode.ctlParam.pause ?
153         AUDIO_DRV_PCM_IOCTRL_PAUSE_CAPTURE : AUDIO_DRV_PCM_IOCTRL_RESUME_CAPTURE;
154 
155     ret = AudioServiceDispatch(handle->object, cmdId, sBuf, NULL);
156     if (ret != HDF_SUCCESS) {
157         AudioFreeHdfSBuf(sBuf, NULL);
158         AUDIO_FUNC_LOGE("SetPauseStu Failed to send service call!");
159         return ret;
160     }
161 
162     AudioFreeHdfSBuf(sBuf, NULL);
163     return ret;
164 }
165 
AudioCtlCaptureGetVolumeSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)166 int32_t AudioCtlCaptureGetVolumeSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
167 {
168     if (handleData == NULL || sBuf == NULL) {
169         AUDIO_FUNC_LOGE("CaptureGetVolumeSBuf  parameter is empty!");
170         return HDF_FAILURE;
171     }
172     struct AudioCtlElemValue elemCaptureValue;
173     elemCaptureValue.id.cardServiceName = handleData->captureMode.hwInfo.cardServiceName;
174     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
175     elemCaptureValue.id.itemName = "Main Capture Volume";
176 
177     return AudioSetElemValue(sBuf, &elemCaptureValue, false);
178 }
179 
AudioCtlCaptureGetVolume(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)180 int32_t AudioCtlCaptureGetVolume(const struct DevHandle *handle,
181     int cmdId, struct AudioHwCaptureParam *handleData)
182 {
183     if (handle == NULL || handle->object == NULL || handleData == NULL) {
184         AUDIO_FUNC_LOGE("CaptureGetVolume paras is NULL!");
185         return HDF_FAILURE;
186     }
187 
188     int32_t elemValue = 0;
189     struct HdfSBuf *reply = NULL;
190     struct HdfSBuf *sBuf = NULL;
191 
192     int32_t ret = AudioAllocHdfSBuf(&sBuf, &reply);
193     if (ret != HDF_SUCCESS) {
194         return HDF_FAILURE;
195     }
196 
197     ret = AudioCtlCaptureGetVolumeSBuf(sBuf, handleData);
198     if (ret != HDF_SUCCESS) {
199         AUDIO_FUNC_LOGE("Failed to Get Volume sBuf!");
200         AudioFreeHdfSBuf(sBuf, reply);
201         return ret;
202     }
203 
204     cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM;
205 
206     ret = AudioServiceDispatch(handle->object, cmdId, sBuf, reply);
207     if (ret != HDF_SUCCESS) {
208         AudioFreeHdfSBuf(sBuf, reply);
209         AUDIO_FUNC_LOGE("GetVolume Dispatch Fail!");
210         return ret;
211     }
212 
213     if (!HdfSbufReadInt32(reply, &elemValue)) {
214         AUDIO_FUNC_LOGE("Failed to Get Volume sBuf!");
215         AudioFreeHdfSBuf(sBuf, reply);
216         return HDF_FAILURE;
217     }
218 
219     handleData->captureMode.ctlParam.volume = (float)elemValue;
220 
221     AudioFreeHdfSBuf(sBuf, reply);
222     return ret;
223 }
224 
AudioCtlCaptureSetVolumeSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)225 int32_t AudioCtlCaptureSetVolumeSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
226 {
227     if (handleData == NULL || sBuf == NULL) {
228         AUDIO_FUNC_LOGE("CaptureSetVolumeSBuf parameter is empty!");
229         return HDF_FAILURE;
230     }
231     struct AudioCtlElemValue elemCaptureValue;
232     elemCaptureValue.id.cardServiceName = handleData->captureMode.hwInfo.cardServiceName;
233     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
234     elemCaptureValue.id.itemName = "Main Capture Volume";
235     elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.volume;
236 
237     return AudioSetElemValue(sBuf, &elemCaptureValue, true);
238 }
239 
AudioCtlCaptureSetVolume(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)240 int32_t AudioCtlCaptureSetVolume(const struct DevHandle *handle,
241     int cmdId, const struct AudioHwCaptureParam *handleData)
242 {
243     if (handle == NULL || handle->object == NULL || handleData == NULL) {
244         AUDIO_FUNC_LOGE("CaptureSetVolume paras is NULL!");
245         return HDF_FAILURE;
246     }
247 
248     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
249     if (sBuf == NULL) {
250         AUDIO_FUNC_LOGE("CaptureSetVolume Failed to obtain sBuf");
251         return HDF_FAILURE;
252     }
253 
254     int32_t ret = AudioCtlCaptureSetVolumeSBuf(sBuf, handleData);
255     if (ret < 0) {
256         AUDIO_FUNC_LOGE("CaptureSetVolume Failed to Set Volume sBuf!");
257         AudioFreeHdfSBuf(sBuf, NULL);
258         return ret;
259     }
260 
261     cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM;
262 
263     ret = AudioServiceDispatch(handle->object, cmdId, sBuf, NULL);
264     if (ret != HDF_SUCCESS) {
265         AudioFreeHdfSBuf(sBuf, NULL);
266         AUDIO_FUNC_LOGE("CaptureSetVolume Service Failed!");
267         return ret;
268     }
269 
270     AudioFreeHdfSBuf(sBuf, NULL);
271     return ret;
272 }
273 
AudioCtlCaptureSetMuteSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)274 int32_t AudioCtlCaptureSetMuteSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
275 {
276     if (handleData == NULL || sBuf == NULL) {
277         AUDIO_FUNC_LOGE("handleData or sBuf is NULL!");
278         return HDF_FAILURE;
279     }
280     struct AudioCtlElemValue elemCaptureValue;
281     elemCaptureValue.id.cardServiceName = handleData->captureMode.hwInfo.cardServiceName;
282     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
283     elemCaptureValue.id.itemName = "Capture Mute";
284     elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.mute;
285 
286     return AudioSetElemValue(sBuf, &elemCaptureValue, true);
287 }
288 
AudioCtlCaptureSetMuteStu(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)289 int32_t AudioCtlCaptureSetMuteStu(const struct DevHandle *handle,
290     int cmdId, const struct AudioHwCaptureParam *handleData)
291 {
292     if (handle == NULL || handle->object == NULL || handleData == NULL) {
293         AUDIO_FUNC_LOGE("CaptureSetMuteStu paras is NULL!");
294         return HDF_FAILURE;
295     }
296 
297     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
298     if (sBuf == NULL) {
299         AUDIO_FUNC_LOGE("CaptureSetMuteStu Failed to obtain sBuf");
300         return HDF_FAILURE;
301     }
302 
303     int32_t ret = AudioCtlCaptureSetMuteSBuf(sBuf, handleData);
304     if (ret < 0) {
305         AUDIO_FUNC_LOGE("CaptureSetMuteStu Failed to Get Mute sBuf!");
306         AudioFreeHdfSBuf(sBuf, NULL);
307         return ret;
308     }
309 
310     cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM;
311 
312     ret = AudioServiceDispatch(handle->object, cmdId, sBuf, NULL);
313     if (ret != HDF_SUCCESS) {
314         AudioFreeHdfSBuf(sBuf, NULL);
315         AUDIO_FUNC_LOGE("CaptureSetMuteStu Service is NULL!");
316         return ret;
317     }
318 
319     AudioFreeHdfSBuf(sBuf, NULL);
320     return ret;
321 }
322 
AudioCtlCaptureGetMuteSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)323 int32_t AudioCtlCaptureGetMuteSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
324 {
325     if (handleData == NULL || sBuf == NULL) {
326         AUDIO_FUNC_LOGE("The parameter is empty!");
327         return HDF_FAILURE;
328     }
329     struct AudioCtlElemValue elemCaptureValue;
330     elemCaptureValue.id.cardServiceName = handleData->captureMode.hwInfo.cardServiceName;
331     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
332     elemCaptureValue.id.itemName = "Capture Mute";
333 
334     return AudioSetElemValue(sBuf, &elemCaptureValue, false);
335 }
336 
AudioCtlCaptureGetMuteStu(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)337 int32_t AudioCtlCaptureGetMuteStu(const struct DevHandle *handle,
338     int cmdId, struct AudioHwCaptureParam *handleData)
339 {
340     if (handle == NULL || handle->object == NULL || handleData == NULL) {
341         AUDIO_FUNC_LOGE("CaptureGetMuteStu paras is NULL!");
342         return HDF_FAILURE;
343     }
344 
345     int32_t muteValueStu = 0;
346     struct HdfSBuf *reply = NULL;
347     struct HdfSBuf *sBuf = NULL;
348 
349     int32_t ret = AudioAllocHdfSBuf(&sBuf, &reply);
350     if (ret != HDF_SUCCESS) {
351         return HDF_FAILURE;
352     }
353 
354     ret = AudioCtlCaptureGetMuteSBuf(sBuf, handleData);
355     if (ret < 0) {
356         AUDIO_FUNC_LOGE("Failed to Get Mute sBuf!");
357         AudioFreeHdfSBuf(sBuf, reply);
358         return ret;
359     }
360 
361     cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM;
362 
363     ret = AudioServiceDispatch(handle->object, cmdId, sBuf, reply);
364     if (ret != HDF_SUCCESS) {
365         AUDIO_FUNC_LOGE("CaptureGetMuteStu Dispatch Fail!");
366         AudioFreeHdfSBuf(sBuf, reply);
367         return HDF_FAILURE;
368     }
369 
370     if (!HdfSbufReadInt32(reply, &muteValueStu)) {
371         AUDIO_FUNC_LOGE("CaptureGetMuteStu Failed to Get Volume sBuf!");
372         AudioFreeHdfSBuf(sBuf, reply);
373         return HDF_FAILURE;
374     }
375 
376     handleData->captureMode.ctlParam.mute = (bool)muteValueStu;
377 
378     AudioFreeHdfSBuf(sBuf, reply);
379     return HDF_SUCCESS;
380 }
381 
AudioCtlCaptureSetGainSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)382 int32_t AudioCtlCaptureSetGainSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
383 {
384     if (handleData == NULL || sBuf == NULL) {
385         AUDIO_FUNC_LOGE("CaptureSetGainSBuf( handleData or sBuf is NULL!");
386         return HDF_FAILURE;
387     }
388     struct AudioCtlElemValue elemCaptureValue;
389     elemCaptureValue.id.cardServiceName = handleData->captureMode.hwInfo.cardServiceName;
390     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
391     elemCaptureValue.id.itemName = "Mic Left Gain";
392     elemCaptureValue.value[0] = handleData->captureMode.ctlParam.audioGain.gain;
393 
394     return AudioSetElemValue(sBuf, &elemCaptureValue, true);
395 }
396 
AudioCtlCaptureSetGainStu(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)397 int32_t AudioCtlCaptureSetGainStu(const struct DevHandle *handle,
398     int cmdId, const struct AudioHwCaptureParam *handleData)
399 {
400     if (handle == NULL || handle->object == NULL || handleData == NULL) {
401         AUDIO_FUNC_LOGE("CaptureSetGainStu paras is NULL!");
402         return HDF_FAILURE;
403     }
404 
405     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
406     if (sBuf == NULL) {
407         AUDIO_FUNC_LOGE("CaptureSetGainStu Failed to obtain sBuf");
408         return HDF_FAILURE;
409     }
410 
411     int32_t ret = AudioCtlCaptureSetGainSBuf(sBuf, handleData);
412     if (ret < 0) {
413         AUDIO_FUNC_LOGE("CaptureSetGainStu Failed to Get Gain sBuf!");
414         AudioFreeHdfSBuf(sBuf, NULL);
415         return ret;
416     }
417 
418     cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM;
419 
420     ret = AudioServiceDispatch(handle->object, cmdId, sBuf, NULL);
421     if (ret != HDF_SUCCESS) {
422         AUDIO_FUNC_LOGE("CaptureSetGainStu Failed to send service call!");
423         AudioFreeHdfSBuf(sBuf, NULL);
424         return HDF_FAILURE;
425     }
426 
427     AudioFreeHdfSBuf(sBuf, NULL);
428     return ret;
429 }
430 
AudioCtlCaptureGetGainSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)431 int32_t AudioCtlCaptureGetGainSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
432 {
433     if (handleData == NULL || sBuf == NULL) {
434         AUDIO_FUNC_LOGE("CaptureGetGainSBuf paras is NULL!");
435         return HDF_FAILURE;
436     }
437     struct AudioCtlElemValue elemCaptureValue;
438     elemCaptureValue.id.cardServiceName = handleData->captureMode.hwInfo.cardServiceName;
439     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
440     elemCaptureValue.id.itemName = "Mic Left Gain";
441 
442     return AudioSetElemValue(sBuf, &elemCaptureValue, false);
443 }
444 
AudioCtlCaptureGetGainStu(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)445 int32_t AudioCtlCaptureGetGainStu(const struct DevHandle *handle,
446     int cmdId, struct AudioHwCaptureParam *handleData)
447 {
448     if (handle == NULL || handle->object == NULL || handleData == NULL) {
449         AUDIO_FUNC_LOGE("CaptureGetGainStu paras is NULL!");
450         return HDF_FAILURE;
451     }
452 
453     int32_t muteValueStu = 0;
454     struct HdfSBuf *reply = NULL;
455     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
456 
457     int32_t ret = AudioAllocHdfSBuf(&sBuf, &reply);
458     if (ret != HDF_SUCCESS) {
459         return ret;
460     }
461 
462     ret = AudioCtlCaptureGetGainSBuf(sBuf, handleData);
463     if (ret < 0) {
464         AUDIO_FUNC_LOGE("Failed to Get Gain sBuf!");
465         AudioFreeHdfSBuf(sBuf, reply);
466         return ret;
467     }
468 
469     cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM;
470 
471     ret = AudioServiceDispatch(handle->object, cmdId, sBuf, reply);
472     if (ret != HDF_SUCCESS) {
473         AUDIO_FUNC_LOGE("GetGainStu Dispatch Fail!");
474         AudioFreeHdfSBuf(sBuf, reply);
475         return HDF_FAILURE;
476     }
477 
478     if (!HdfSbufReadInt32(reply, &muteValueStu)) {
479         AUDIO_FUNC_LOGE("Failed to GetGain sBuf!");
480         AudioFreeHdfSBuf(sBuf, reply);
481         return HDF_FAILURE;
482     }
483 
484     handleData->captureMode.ctlParam.audioGain.gain = (float)muteValueStu;
485 
486     AudioFreeHdfSBuf(sBuf, reply);
487     return ret;
488 }
489 
AudioCtlCaptureSceneSelectSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData,int32_t deviceIndex)490 int32_t AudioCtlCaptureSceneSelectSBuf(struct HdfSBuf *sBuf,
491     const struct AudioHwCaptureParam *handleData, int32_t deviceIndex)
492 {
493     if (handleData == NULL || sBuf == NULL) {
494         AUDIO_FUNC_LOGE("CaptureSceneSelectSBuf handleData or sBufs is NULL!");
495         return HDF_FAILURE;
496     }
497     if (deviceIndex < 0 || deviceIndex > PATHPLAN_COUNT - 1) {
498         AUDIO_FUNC_LOGE("deviceIndex is Invalid!");
499         return HDF_FAILURE;
500     }
501     struct AudioCtlElemValue elemCaptureValue;
502     elemCaptureValue.id.cardServiceName = handleData->captureMode.hwInfo.cardServiceName;
503     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
504     elemCaptureValue.id.itemName =
505         handleData->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].deviceSwitch;
506     elemCaptureValue.value[0] = handleData->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].value;
507 
508     return AudioSetElemValue(sBuf, &elemCaptureValue, true);
509 }
510 
AudioCtlCaptureSceneSelect(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)511 int32_t AudioCtlCaptureSceneSelect(const struct DevHandle *handle,
512     int cmdId, const struct AudioHwCaptureParam *handleData)
513 {
514     int32_t deviceNum;
515     struct HdfSBuf *sBuf = NULL;
516     int32_t index;
517 
518     if (handle == NULL || handle->object == NULL || handleData == NULL) {
519         AUDIO_FUNC_LOGE("CaptureSceneSelect parameter is empty!");
520         return HDF_FAILURE;
521     }
522 
523     if (strcmp(handleData->captureMode.hwInfo.adapterName, USB) == 0 ||
524         strcmp(handleData->captureMode.hwInfo.adapterName, HDMI) == 0) {
525         return HDF_SUCCESS;
526     }
527 
528     sBuf = HdfSbufObtainDefaultSize();
529     if (sBuf == NULL) {
530         AUDIO_FUNC_LOGE("Failed to obtain sBuf");
531         return HDF_FAILURE;
532     }
533 
534     deviceNum = handleData->captureMode.hwInfo.pathSelect.deviceInfo.deviceNum;
535     if (deviceNum < AUDIO_MIN_DEVICENUM) {
536         AUDIO_FUNC_LOGE("AUDIO_MIN_ADAPTERNUM Failed!");
537         AudioFreeHdfSBuf(sBuf, NULL);
538         return HDF_FAILURE;
539     }
540 
541     cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM;
542 
543     for (index = 0; index < deviceNum; index++) {
544         HdfSbufFlush(sBuf);
545         if (AudioCtlCaptureSceneSelectSBuf(sBuf, handleData, index) < 0) {
546             AUDIO_FUNC_LOGE("AudioCtlCaptureSceneSelectSBuf Failed!");
547             AudioFreeHdfSBuf(sBuf, NULL);
548             return HDF_FAILURE;
549         }
550 
551         if (AudioServiceDispatch(handle->object, cmdId, sBuf, NULL) < 0) {
552             AUDIO_FUNC_LOGE("Failed to call AudioServiceDispatch!");
553             AudioFreeHdfSBuf(sBuf, NULL);
554             return HDF_FAILURE;
555         }
556     }
557 
558     AudioFreeHdfSBuf(sBuf, NULL);
559     return HDF_SUCCESS;
560 }
561 
AudioCtlCaptureGetGainThresholdSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)562 int32_t AudioCtlCaptureGetGainThresholdSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
563 {
564     if (handleData == NULL || sBuf == NULL) {
565         AUDIO_FUNC_LOGE("CaptureGetGainThresholdSBuf paras is empty!");
566         return HDF_FAILURE;
567     }
568     struct AudioCtlElemValue elemCaptureInfo;
569     elemCaptureInfo.id.cardServiceName = handleData->captureMode.hwInfo.cardServiceName;
570     elemCaptureInfo.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
571     elemCaptureInfo.id.itemName = "Mic Left Gain";
572 
573     return AudioSetElemValue(sBuf, &elemCaptureInfo, false);
574 }
575 
AudioCtlCaptureGetGainThreshold(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)576 int32_t AudioCtlCaptureGetGainThreshold(const struct DevHandle *handle,
577     int cmdId, struct AudioHwCaptureParam *handleData)
578 {
579     if (handle == NULL || handle->object == NULL || handleData == NULL) {
580         AUDIO_FUNC_LOGE("CaptureGetGainThreshold paras is NULL!");
581         return HDF_FAILURE;
582     }
583 
584     struct HdfSBuf *sBuf = NULL;
585     struct HdfSBuf *reply = NULL;
586     struct AudioCtrlElemInfo gainThreshold;
587 
588     int32_t ret = AudioAllocHdfSBuf(&sBuf, &reply);
589     if (ret != HDF_SUCCESS) {
590         return ret;
591     }
592 
593     ret = AudioCtlCaptureGetGainThresholdSBuf(sBuf, handleData);
594     if (ret != HDF_SUCCESS) {
595         AUDIO_FUNC_LOGE("CaptureGetGainThreshold Failed to Get Threshold sBuf!");
596         AudioFreeHdfSBuf(sBuf, reply);
597         return ret;
598     }
599 
600     cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE - CTRL_NUM;
601 
602     ret = AudioServiceDispatch(handle->object, cmdId, sBuf, reply);
603     if (ret != HDF_SUCCESS) {
604         AudioFreeHdfSBuf(sBuf, reply);
605         return HDF_FAILURE;
606     }
607 
608     (void)memset_s(&gainThreshold, sizeof(struct AudioCtrlElemInfo), 0, sizeof(struct AudioCtrlElemInfo));
609 
610     if (!HdfSbufReadInt32(reply, &gainThreshold.type)) {
611         AUDIO_FUNC_LOGE("CaptureGetGainThreshold Failed to HdfSbufReadBuffer!");
612         AudioFreeHdfSBuf(sBuf, reply);
613         return HDF_FAILURE;
614     }
615 
616     if (!HdfSbufReadInt32(reply, &gainThreshold.max)) {
617         AUDIO_FUNC_LOGE("CaptureGetGainThreshold Failed to HdfSbufReadBuffer!");
618         AudioFreeHdfSBuf(sBuf, reply);
619         return HDF_FAILURE;
620     }
621 
622     handleData->captureMode.ctlParam.audioGain.gainMax = gainThreshold.max;
623     handleData->captureMode.ctlParam.audioGain.gainMin = 0;
624 
625     AudioFreeHdfSBuf(sBuf, reply);
626     return ret;
627 }
628 
AudioCtlCaptureGetVolThresholdSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)629 int32_t AudioCtlCaptureGetVolThresholdSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
630 {
631     if (handleData == NULL || sBuf == NULL) {
632         AUDIO_FUNC_LOGE("CaptureGetVolThresholdSBuf paras is empty!");
633         return HDF_FAILURE;
634     }
635     struct AudioCtlElemValue elemCaptureInfo;
636     elemCaptureInfo.id.cardServiceName = handleData->captureMode.hwInfo.cardServiceName;
637     elemCaptureInfo.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
638     elemCaptureInfo.id.itemName = "Main Capture Volume";
639 
640     return AudioSetElemValue(sBuf, &elemCaptureInfo, false);
641 }
642 
AudioCtlCaptureGetVolThreshold(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)643 int32_t AudioCtlCaptureGetVolThreshold(const struct DevHandle *handle,
644     int cmdId, struct AudioHwCaptureParam *handleData)
645 {
646     if (handle == NULL || handle->object == NULL || handleData == NULL) {
647         AUDIO_FUNC_LOGE("paras is NULL!");
648         return HDF_FAILURE;
649     }
650 
651     struct AudioCtrlElemInfo volThreshold;
652     struct HdfSBuf *reply = NULL;
653     struct HdfSBuf *sBuf = NULL;
654 
655     int32_t ret = AudioAllocHdfSBuf(&sBuf, &reply);
656     if (ret != HDF_SUCCESS) {
657         return ret;
658     }
659 
660     ret = AudioCtlCaptureGetVolThresholdSBuf(sBuf, handleData);
661     if (ret < 0) {
662         AUDIO_FUNC_LOGE("Failed to Get Threshold sBuf!");
663         AudioFreeHdfSBuf(sBuf, reply);
664         return ret;
665     }
666 
667     cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE - CTRL_NUM;
668 
669     ret = AudioServiceDispatch(handle->object, cmdId, sBuf, reply);
670     if (ret == HDF_ERR_NOT_SUPPORT) {
671         AUDIO_FUNC_LOGW("This sound card does not have a volume control component!");
672         AudioFreeHdfSBuf(sBuf, reply);
673         return HDF_SUCCESS;
674     } else if (ret != HDF_SUCCESS) {
675         AUDIO_FUNC_LOGE("AudioServiceDispatch failed!");
676         AudioFreeHdfSBuf(sBuf, reply);
677         return HDF_FAILURE;
678     }
679 
680     ret = AudioGetElemValue(reply, &volThreshold);
681     if (ret != HDF_SUCCESS) {
682         AUDIO_FUNC_LOGE("AudioGetElemValue failed!");
683         return HDF_FAILURE;
684     }
685 
686     handleData->captureMode.ctlParam.volThreshold.volMax = volThreshold.max;
687     handleData->captureMode.ctlParam.volThreshold.volMin = volThreshold.min;
688 
689     AudioFreeHdfSBuf(sBuf, reply);
690     return ret;
691 }
692 
AudioInterfaceLibCtlCapture(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)693 int32_t AudioInterfaceLibCtlCapture(const struct DevHandle *handle,
694     int cmdId, struct AudioHwCaptureParam *handleData)
695 {
696     if (handle == NULL || handle->object == NULL || handleData == NULL) {
697         AUDIO_FUNC_LOGE("paras is NULL!");
698         return HDF_FAILURE;
699     }
700 
701     switch (cmdId) {
702         /* setPara: */
703         case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE:
704             return AudioCtlCaptureSetVolume(handle, cmdId, handleData);
705         case AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE:
706             return AudioCtlCaptureSetMuteStu(handle, cmdId, handleData);
707         case AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE:
708             return AudioCtlCaptureGetMuteStu(handle, cmdId, handleData);
709         /* getPara: */
710         case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE:
711             return AudioCtlCaptureGetVolume(handle, cmdId, handleData);
712         case AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE:
713             return AudioCtlCaptureSetGainStu(handle, cmdId, handleData);
714         case AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE:
715             return AudioCtlCaptureGetGainStu(handle, cmdId, handleData);
716         case AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE:
717             return AudioCtlCaptureSceneSelect(handle, cmdId, handleData);
718         case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE:
719             return AudioCtlCaptureGetGainThreshold(handle, cmdId, handleData);
720         case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE:
721             return AudioCtlCaptureGetVolThreshold(handle, cmdId, handleData);
722         default:
723             AUDIO_FUNC_LOGE("Ctl Mode not support!");
724             return HDF_FAILURE;
725     }
726 }
727 
AudioOutputCaptureHwParams(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)728 int32_t AudioOutputCaptureHwParams(const struct DevHandle *handle,
729     int cmdId, const struct AudioHwCaptureParam *handleData)
730 {
731     if (handle == NULL || handle->object == NULL || handleData == NULL) {
732         AUDIO_FUNC_LOGE("Function parameter is NULL!");
733         return HDF_FAILURE;
734     }
735 
736     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
737     if (sBuf == NULL) {
738         AUDIO_FUNC_LOGE("Failed to obtain sBuf");
739         return HDF_FAILURE;
740     }
741 
742     int32_t ret = SetHwParamsCapture(handleData);
743     if (ret != HDF_SUCCESS) {
744         AUDIO_FUNC_LOGE("SetHwParamsCapture Failed");
745         AudioFreeHdfSBuf(sBuf, NULL);
746         return HDF_FAILURE;
747     }
748 
749     ret = ParamsSbufWriteBuffer(sBuf);
750     if (ret != HDF_SUCCESS) {
751         AUDIO_FUNC_LOGE("ParamsSbufWriteBuffer Failed");
752         AudioFreeHdfSBuf(sBuf, NULL);
753         return HDF_FAILURE;
754     }
755 
756     ret = AudioServiceDispatch(handle->object, cmdId, sBuf, NULL);
757     if (ret != HDF_SUCCESS) {
758         AUDIO_FUNC_LOGE("AudioServiceDispatch failed!");
759         AudioFreeHdfSBuf(sBuf, NULL);
760         return HDF_FAILURE;
761     }
762 
763     AudioFreeHdfSBuf(sBuf, NULL);
764     return HDF_SUCCESS;
765 }
766 
AudioOutputCaptureOpen(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)767 int32_t AudioOutputCaptureOpen(const struct DevHandle *handle,
768     int cmdId, const struct AudioHwCaptureParam *handleData)
769 {
770     if (handle == NULL || handle->object == NULL || handleData == NULL) {
771         AUDIO_FUNC_LOGE("Function parameter is NULL!");
772         return HDF_FAILURE;
773     }
774 
775     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
776     if (sBuf == NULL) {
777         AUDIO_FUNC_LOGE("Failed to obtain sBuf");
778         return HDF_FAILURE;
779     }
780 
781     if (!HdfSbufWriteString(sBuf, handleData->captureMode.hwInfo.cardServiceName)) {
782         AudioFreeHdfSBuf(sBuf, NULL);
783         return HDF_FAILURE;
784     }
785 
786     int32_t ret = AudioServiceDispatch(handle->object, cmdId, sBuf, NULL);
787     if (ret != HDF_SUCCESS) {
788         AUDIO_FUNC_LOGE("Failed to send service call!");
789         AudioFreeHdfSBuf(sBuf, NULL);
790         return HDF_FAILURE;
791     }
792 
793     AudioFreeHdfSBuf(sBuf, NULL);
794     return HDF_SUCCESS;
795 }
796 
AudioOutputCaptureReadFrame(const struct DevHandle * handle,struct AudioHwCaptureParam * handleData,int cmdId,struct HdfSBuf * reply)797 int32_t AudioOutputCaptureReadFrame(const struct DevHandle *handle, struct AudioHwCaptureParam *handleData,
798     int cmdId, struct HdfSBuf *reply)
799 {
800     int32_t buffStatus = 0;
801     int32_t tryNumReply = 100; // try get reply count
802 
803     if (handle == NULL || reply == NULL) {
804         AUDIO_FUNC_LOGE("paras is NULL!");
805         return HDF_FAILURE;
806     }
807     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
808     if (sBuf == NULL) {
809         AUDIO_FUNC_LOGE("Failed to obtain sBuf");
810         return HDF_FAILURE;
811     }
812 
813     if (!HdfSbufWriteString(sBuf, handleData->captureMode.hwInfo.cardServiceName)) {
814         AudioFreeHdfSBuf(sBuf, NULL);
815         return HDF_FAILURE;
816     }
817 
818     do {
819         if (AudioServiceDispatch(handle->object, cmdId, sBuf, reply) != HDF_SUCCESS) {
820             AUDIO_FUNC_LOGE("Failed to send service call!");
821             AudioFreeHdfSBuf(sBuf, NULL);
822             return HDF_FAILURE;
823         }
824 
825         if (!HdfSbufReadInt32(reply, &buffStatus)) {
826             AUDIO_FUNC_LOGE("Failed to Get buffStatus!");
827             return HDF_FAILURE;
828         }
829 
830         if (buffStatus == CIR_BUFF_EMPTY) {
831             usleep(AUDIO_CAP_WAIT_DELAY + (tryNumReply % AUDIO_TRYNUM) * AUDIO_TRYNUM_TIME);
832             AUDIO_FUNC_LOGD("Cir buff empty wait");
833         } else if (buffStatus >= 0) {
834             AUDIO_FUNC_LOGD("capture need wait for %{public}d ms!", buffStatus);
835             usleep(buffStatus * AUDIO_US_TO_MS);
836         } else {
837             break;
838         }
839 
840         tryNumReply--;
841         HdfSbufFlush(reply);
842     } while (tryNumReply > 0);
843 
844     if (tryNumReply <= 0) {
845         AUDIO_FUNC_LOGE("Out of tryNumReply!");
846         AudioFreeHdfSBuf(sBuf, NULL);
847         return HDF_FAILURE;
848     }
849 
850     AudioFreeHdfSBuf(sBuf, NULL);
851     return HDF_SUCCESS;
852 }
853 
854 #ifdef MONO_TO_STEREO
CaptureChannelFixed(void * data,uint32_t len)855 void CaptureChannelFixed(void *data, uint32_t len)
856 {
857     int16_t *pcmLeft = (int16_t*)data;
858     int16_t *pcmRight = pcmLeft + 1; // right channel offset + 1
859 
860     for (uint32_t index = 0; index < len; index += 2) { // 16bit, step = 2
861         pcmRight[index] = pcmLeft[index];
862     }
863     return;
864 }
865 #endif
866 
AudioInputCaptureReadInfoToHandleData(struct AudioHwCaptureParam * handleData,char * frame,uint32_t frameCount,uint32_t dataSize)867 int32_t AudioInputCaptureReadInfoToHandleData(struct AudioHwCaptureParam *handleData,
868     char *frame, uint32_t frameCount, uint32_t dataSize)
869 {
870     int32_t ret = memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, frame, dataSize);
871     if (ret != 0) {
872         return HDF_FAILURE;
873     }
874 #ifdef MONO_TO_STEREO
875     if (g_hwParams.channels == 2) { // if rk3568 channel = 2, and 16bit
876         CaptureChannelFixed(handleData->frameCaptureMode.buffer, dataSize / 2); // len = dataSize / 2
877     }
878 #endif
879     handleData->frameCaptureMode.bufferSize = dataSize;
880     handleData->frameCaptureMode.bufferFrameSize = frameCount;
881     return HDF_SUCCESS;
882 }
883 
AudioOutputCaptureRead(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)884 int32_t AudioOutputCaptureRead(const struct DevHandle *handle,
885     int cmdId, struct AudioHwCaptureParam *handleData)
886 {
887     uint32_t dataSize = 0;
888     uint32_t frameCount = 0;
889     char *frame = NULL;
890 
891     if (handle == NULL || handle->object == NULL || handleData == NULL) {
892         AUDIO_FUNC_LOGE("paras is NULL!");
893         return HDF_FAILURE;
894     }
895 
896     struct HdfSBuf *reply = HdfSbufTypedObtainCapacity(SBUF_RAW, (AUDIO_SIZE_FRAME_16K + AUDIO_REPLY_EXTEND));
897     if (reply == NULL) {
898         AUDIO_FUNC_LOGE("HdfSbufTypedObtainCapacity replySize failed!");
899         return HDF_FAILURE;
900     }
901 
902     int32_t ret = AudioOutputCaptureReadFrame(handle, handleData, cmdId, reply);
903     if (ret != HDF_SUCCESS) {
904         AudioFreeHdfSBuf(reply, NULL);
905         return HDF_FAILURE;
906     }
907 
908     if (!HdfSbufReadBuffer(reply, (const void **)&frame, &dataSize)) {
909         AUDIO_FUNC_LOGE("[HdfSbufReadBuffer]-[frame] failed!");
910         AudioFreeHdfSBuf(reply, NULL);
911         return HDF_FAILURE;
912     }
913 
914     if (dataSize > FRAME_DATA || handleData->frameCaptureMode.buffer == NULL) {
915         AUDIO_FUNC_LOGE("Buffer is NULL or DataSize overflow!");
916         AudioFreeHdfSBuf(reply, NULL);
917         return HDF_FAILURE;
918     }
919 
920     if (!HdfSbufReadUint32(reply, &frameCount)) {
921         AUDIO_FUNC_LOGE("Failed to Get buffStatus!");
922         AudioFreeHdfSBuf(reply, NULL);
923         return HDF_FAILURE;
924     }
925 
926     ret = AudioInputCaptureReadInfoToHandleData(handleData, frame, frameCount, dataSize);
927     if (ret != HDF_SUCCESS) {
928         AUDIO_FUNC_LOGE("AudioInputCaptureReadInfoToHandleData Failed!");
929         AudioFreeHdfSBuf(reply, NULL);
930         return HDF_FAILURE;
931     }
932 
933     AudioFreeHdfSBuf(reply, NULL);
934     return HDF_SUCCESS;
935 }
936 
AudioOutputCaptureStartPrepare(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)937 int32_t AudioOutputCaptureStartPrepare(const struct DevHandle *handle,
938     int cmdId, const struct AudioHwCaptureParam *handleData)
939 {
940     if (handle == NULL || handle->object == NULL || handleData == NULL) {
941         AUDIO_FUNC_LOGE("CaptureStartPrepare Failed to send service call!");
942         return HDF_FAILURE;
943     }
944 
945     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
946     if (sBuf == NULL) {
947         AUDIO_FUNC_LOGE("StartPrepare Failed to obtain sBuf");
948         return HDF_FAILURE;
949     }
950 
951     if (!HdfSbufWriteString(sBuf, handleData->captureMode.hwInfo.cardServiceName)) {
952         AUDIO_FUNC_LOGE("[HdfSbufWriteString]-[cardServiceName] failed!");
953         AudioFreeHdfSBuf(sBuf, NULL);
954         return HDF_FAILURE;
955     }
956 
957     int32_t ret = AudioServiceDispatch(handle->object, cmdId, sBuf, NULL);
958     if (ret != HDF_SUCCESS) {
959         AUDIO_FUNC_LOGE("Failed to send service call!");
960         AudioFreeHdfSBuf(sBuf, NULL);
961         return HDF_FAILURE;
962     }
963 
964     AudioFreeHdfSBuf(sBuf, NULL);
965     return HDF_SUCCESS;
966 }
967 
AudioOutputCaptureStop(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)968 int32_t AudioOutputCaptureStop(const struct DevHandle *handle,
969     int cmdId, const struct AudioHwCaptureParam *handleData)
970 {
971     if (handle == NULL || handle->object == NULL || handleData == NULL) {
972         AUDIO_FUNC_LOGE("CaptureStop paras is NULL!");
973         return HDF_FAILURE;
974     }
975 
976     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
977     if (sBuf == NULL) {
978         AUDIO_FUNC_LOGE("HdfSbufObtainDefaultSize failed!");
979         return HDF_FAILURE;
980     }
981     if (!HdfSbufWriteString(sBuf, handleData->captureMode.hwInfo.cardServiceName)) {
982         AUDIO_FUNC_LOGE("[HdfSbufWriteString]-[cardServiceName] failed!");
983         AudioFreeHdfSBuf(sBuf, NULL);
984         return HDF_FAILURE;
985     }
986 
987     if (!HdfSbufWriteUint32(sBuf, AUDIO_TURN_STANDBY_LATER)) {
988         AUDIO_FUNC_LOGE("write sBuf Failed!");
989         AudioFreeHdfSBuf(sBuf, NULL);
990         return HDF_FAILURE;
991     }
992 
993     if (AudioServiceDispatch(handle->object, cmdId, sBuf, NULL) != HDF_SUCCESS) {
994         AudioFreeHdfSBuf(sBuf, NULL);
995         AUDIO_FUNC_LOGE("CaptureStop Failed to send service call!");
996         return HDF_FAILURE;
997     }
998 
999     AudioFreeHdfSBuf(sBuf, NULL);
1000     return HDF_SUCCESS;
1001 }
1002 
MmapDescWriteBufferCapture(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)1003 int32_t MmapDescWriteBufferCapture(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
1004 {
1005     if (sBuf == NULL || handleData == NULL) {
1006         AUDIO_FUNC_LOGE("param sBuf or handleData is null!");
1007         return HDF_FAILURE;
1008     }
1009 
1010     uint64_t mmapAddr = (uint64_t)(uintptr_t)(handleData->frameCaptureMode.mmapBufDesc.memoryAddress);
1011 
1012     if (!HdfSbufWriteString(sBuf, handleData->captureMode.hwInfo.cardServiceName)) {
1013         AUDIO_FUNC_LOGE("[HdfSbufWriteString]-[cardServiceName] failed!");
1014         AudioFreeHdfSBuf(sBuf, NULL);
1015         return HDF_FAILURE;
1016     }
1017 
1018     if (!HdfSbufWriteUint64(sBuf, mmapAddr)) {
1019         AUDIO_FUNC_LOGE("HdfSbufWriteUint64 memoryAddress failed!");
1020         AudioFreeHdfSBuf(sBuf, NULL);
1021         return HDF_FAILURE;
1022     }
1023 
1024     if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.memoryFd)) {
1025         AUDIO_FUNC_LOGE("write memoryFd failed!");
1026         return HDF_FAILURE;
1027     }
1028 
1029     if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames)) {
1030         AUDIO_FUNC_LOGE("write totalBufferFrames failed!");
1031         return HDF_FAILURE;
1032     }
1033 
1034     if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.transferFrameSize)) {
1035         AUDIO_FUNC_LOGE("write transferFrameSize failed!");
1036         return HDF_FAILURE;
1037     }
1038 
1039     if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.isShareable)) {
1040         AUDIO_FUNC_LOGE("write isShareable failed!");
1041         return HDF_FAILURE;
1042     }
1043 
1044     if (!HdfSbufWriteUint32(sBuf, handleData->frameCaptureMode.mmapBufDesc.offset)) {
1045         AUDIO_FUNC_LOGE("write offset failed!");
1046         return HDF_FAILURE;
1047     }
1048     return HDF_SUCCESS;
1049 }
1050 
AudioOutputCaptureReqMmapBuffer(const struct DevHandle * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1051 int32_t AudioOutputCaptureReqMmapBuffer(const struct DevHandle *handle,
1052     int cmdId, const struct AudioHwCaptureParam *handleData)
1053 {
1054     if (handle == NULL || handle->object == NULL || handleData == NULL) {
1055         AUDIO_FUNC_LOGE("handle or handle->object or handleData is null!");
1056         return HDF_FAILURE;
1057     }
1058 
1059     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
1060     if (sBuf == NULL) {
1061         AUDIO_FUNC_LOGE("HdfSbufObtainDefaultSize failed!");
1062         return HDF_FAILURE;
1063     }
1064 
1065     if (MmapDescWriteBufferCapture(sBuf, handleData)) {
1066         AudioFreeHdfSBuf(sBuf, NULL);
1067         AUDIO_FUNC_LOGE("MmapDescWriteBufferCapture failed!");
1068         return HDF_FAILURE;
1069     }
1070 
1071     if (AudioServiceDispatch(handle->object, cmdId, sBuf, NULL) != HDF_SUCCESS) {
1072         AudioFreeHdfSBuf(sBuf, NULL);
1073         AUDIO_FUNC_LOGE("CaptureReqMmap Failed to send service call!");
1074         return HDF_FAILURE;
1075     }
1076 
1077     AudioFreeHdfSBuf(sBuf, NULL);
1078     return HDF_SUCCESS;
1079 }
1080 
AudioOutputCaptureGetMmapPosition(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)1081 int32_t AudioOutputCaptureGetMmapPosition(const struct DevHandle *handle,
1082     int cmdId, struct AudioHwCaptureParam *handleData)
1083 {
1084     if (handle == NULL || handle->object == NULL || handleData == NULL) {
1085         AUDIO_FUNC_LOGE("handle or handle->object or handleData is null!");
1086         return HDF_FAILURE;
1087     }
1088 
1089     uint64_t frames = 0;
1090     struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
1091     if (sBuf == NULL) {
1092         AUDIO_FUNC_LOGE("HdfSbufObtainDefaultSize failed!");
1093         return HDF_FAILURE;
1094     }
1095     if (!HdfSbufWriteString(sBuf, handleData->captureMode.hwInfo.cardServiceName)) {
1096         AUDIO_FUNC_LOGE("[HdfSbufWriteString]-[cardServiceName] failed!");
1097         AudioFreeHdfSBuf(sBuf, NULL);
1098         return HDF_FAILURE;
1099     }
1100 
1101     struct HdfSBuf *reply = HdfSbufObtainDefaultSize();
1102     if (reply == NULL) {
1103         AUDIO_FUNC_LOGE("CaptureGetMmapPosition Failed to obtain reply");
1104         AudioFreeHdfSBuf(sBuf, NULL);
1105         return HDF_FAILURE;
1106     }
1107 
1108     if (AudioServiceDispatch(handle->object, cmdId, sBuf, reply) != HDF_SUCCESS) {
1109         AudioFreeHdfSBuf(sBuf, reply);
1110         AUDIO_FUNC_LOGE("CaptureGetMmapPosition Failed to send service call!");
1111         return HDF_FAILURE;
1112     }
1113     AudioFreeHdfSBuf(sBuf, NULL);
1114 
1115     if (!HdfSbufReadUint64(reply, &frames)) {
1116         AudioFreeHdfSBuf(reply, NULL);
1117         AUDIO_FUNC_LOGE("Failed to Get frames sBuf");
1118         return HDF_FAILURE;
1119     }
1120 
1121     handleData->frameCaptureMode.frames = frames;
1122     AudioFreeHdfSBuf(reply, NULL);
1123     return HDF_SUCCESS;
1124 }
1125 
AudioInterfaceLibOutputCapture(const struct DevHandle * handle,int cmdId,struct AudioHwCaptureParam * handleData)1126 int32_t AudioInterfaceLibOutputCapture(const struct DevHandle *handle, int cmdId,
1127     struct AudioHwCaptureParam *handleData)
1128 {
1129     if (handle == NULL) {
1130         AUDIO_FUNC_LOGE("Input Capture handle is NULL!");
1131         return HDF_FAILURE;
1132     }
1133     if (handle->object == NULL || handleData == NULL) {
1134         AUDIO_FUNC_LOGE("handle->object or handleData is null!");
1135         return HDF_FAILURE;
1136     }
1137     int32_t ret;
1138     switch (cmdId) {
1139         case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
1140             ret = AudioOutputCaptureHwParams(handle, cmdId, handleData);
1141             break;
1142         case AUDIO_DRV_PCM_IOCTL_READ:
1143             ret = AudioOutputCaptureRead(handle, cmdId, handleData);
1144             break;
1145         case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE:
1146         case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE:
1147         case AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE:
1148             ret = AudioOutputCaptureStartPrepare(handle, cmdId, handleData);
1149             break;
1150         case AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN:
1151             ret = AudioOutputCaptureOpen(handle, cmdId, handleData);
1152             break;
1153         case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE:
1154             ret = AudioOutputCaptureStop(handle, cmdId, handleData);
1155             break;
1156         case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE:
1157             ret = AudioCtlCaptureSetPauseStu(handle, cmdId, handleData);
1158             break;
1159         case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE:
1160             ret = AudioOutputCaptureReqMmapBuffer(handle, cmdId, handleData);
1161             break;
1162         case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE:
1163             ret = AudioOutputCaptureGetMmapPosition(handle, cmdId, handleData);
1164             break;
1165         default:
1166             AUDIO_FUNC_LOGE("Output Mode not support!");
1167             ret = HDF_FAILURE;
1168             break;
1169     }
1170     return ret;
1171 }
1172 
AudioInterfaceLibModeCapture(const struct DevHandle * handle,struct AudioHwCaptureParam * handleData,int cmdId)1173 int32_t AudioInterfaceLibModeCapture(const struct DevHandle *handle,
1174     struct AudioHwCaptureParam *handleData, int cmdId)
1175 {
1176     if (handle == NULL || handle->object == NULL || handleData == NULL) {
1177         AUDIO_FUNC_LOGE("paras is NULL!");
1178         return HDF_FAILURE;
1179     }
1180     switch (cmdId) {
1181         case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
1182         case AUDIO_DRV_PCM_IOCTL_READ:
1183         case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE:
1184         case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE:
1185         case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE:
1186         case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE:
1187         case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE:
1188         case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE:
1189         case AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN:
1190         case AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE:
1191             return (AudioInterfaceLibOutputCapture(handle, cmdId, handleData));
1192         case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE:
1193         case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE:
1194         case AUDIODRV_CTL_IOCTL_ELEM_LIST_CAPTURE:
1195         case AUDIODRV_CTL_IOCTL_ELEM_CARD_CAPTURE:
1196         case AUDIODRV_CTL_IOCTL_ELEM_HDMI_CAPTURE:
1197         case AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE:
1198         case AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE:
1199         case AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE:
1200         case AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE:
1201         case AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE:
1202         case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE:
1203         case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE:
1204             return (AudioInterfaceLibCtlCapture(handle, cmdId, handleData));
1205         default:
1206             AUDIO_FUNC_LOGE("Mode Error!");
1207             break;
1208     }
1209     return HDF_ERR_NOT_SUPPORT;
1210 }
1211