• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021 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 "audio_hal_log.h"
18 #ifdef ALSA_MODE
19 #include "alsa_audio.h"
20 struct pcm *pcm;
21 struct DevInfo g_inDevInfo;
22 #endif
23 
24 /* virtual mixer device */
25 #define AUDIODRV_CTL_CAPTUREELEM_IFACE_MIXER ((int32_t)2)
26 #define AUDIODRV_CTL_ELEM_IFACE_ADC 1
27 #define AUDIODRV_CTL_ELEM_IFACE_SELECT 5
28 #define AUDIO_REPLY_EXTEND 16
29 #define AUDIO_SIZE_FRAME_16K (16 * 1024)
30 #define AUDIO_TRYNUM 2
31 #define AUDIO_TRYNUM_TIME 3000
32 
33 /* Out Put Capture */
34 static struct AudioPcmHwParams g_hwParams;
35 static char *g_audioLibCaptureService[AUDIO_SERVICE_MAX] = {
36     [AUDIO_SERVICE_IN] = "hdf_audio_codec_dev0",
37     [AUDIO_SERVICE_OUT] = "hdf_audio_smartpa_dev0",
38 };
39 
SetHwParamsCapture(const struct AudioHwCaptureParam * const handleData)40 int32_t SetHwParamsCapture(const struct AudioHwCaptureParam * const handleData)
41 {
42     if (handleData == NULL) {
43         LOG_FUN_ERR("handleData is NULL!");
44         return HDF_FAILURE;
45     }
46     uint32_t card = handleData->captureMode.hwInfo.card;
47     if (card >= AUDIO_SERVICE_MAX) {
48         LOG_FUN_ERR("card is Error!");
49         return HDF_FAILURE;
50     }
51     (void)memset_s(&g_hwParams, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams));
52     g_hwParams.streamType = AUDIO_CAPTURE_STREAM;
53     g_hwParams.channels = handleData->frameCaptureMode.attrs.channelCount;
54     g_hwParams.rate = handleData->frameCaptureMode.attrs.sampleRate;
55     g_hwParams.periodSize = handleData->frameCaptureMode.periodSize;
56     g_hwParams.periodCount = handleData->frameCaptureMode.periodCount;
57     g_hwParams.cardServiceName = g_audioLibCaptureService[card];
58     g_hwParams.format = handleData->frameCaptureMode.attrs.format;
59     g_hwParams.period = handleData->frameCaptureMode.attrs.period;
60     g_hwParams.frameSize = handleData->frameCaptureMode.attrs.frameSize;
61     g_hwParams.isBigEndian = handleData->frameCaptureMode.attrs.isBigEndian;
62     g_hwParams.isSignedData = handleData->frameCaptureMode.attrs.isSignedData;
63     g_hwParams.startThreshold = handleData->frameCaptureMode.attrs.startThreshold;
64     g_hwParams.stopThreshold = handleData->frameCaptureMode.attrs.stopThreshold;
65     g_hwParams.silenceThreshold = handleData->frameCaptureMode.attrs.silenceThreshold;
66 #ifdef ALSA_MODE
67     LOG_FUN_ERR("ALSA_MODE streamType %d, channels %d, rate %d, periodSize %d, periodCount %d, \
68         cardServiceName %s, format %d, period %d, frameSize %d, isBigEndian %d, isSignedData %d, \
69         startThreshold %d, stopThreshold %d, silenceThreshold %d",
70         g_hwParams.streamType, g_hwParams.channels, g_hwParams.rate, g_hwParams.periodSize,
71         g_hwParams.periodCount, g_hwParams.cardServiceName, g_hwParams.format, g_hwParams.period,
72         g_hwParams.frameSize, g_hwParams.isBigEndian, g_hwParams.isSignedData, g_hwParams.startThreshold,
73         g_hwParams.stopThreshold, g_hwParams.silenceThreshold);
74 #endif
75     return HDF_SUCCESS;
76 }
77 
ParamsSbufWriteBuffer(struct HdfSBuf * sBuf)78 int32_t ParamsSbufWriteBuffer(struct HdfSBuf *sBuf)
79 {
80 #ifdef ALSA_MODE
81     return HDF_SUCCESS;
82 #endif
83     if (sBuf == NULL) {
84         return HDF_FAILURE;
85     }
86     if (!HdfSbufWriteUint32(sBuf, (uint32_t)g_hwParams.streamType)) {
87         return HDF_FAILURE;
88     }
89     if (!HdfSbufWriteUint32(sBuf, g_hwParams.channels)) {
90         return HDF_FAILURE;
91     }
92     if (!HdfSbufWriteUint32(sBuf, g_hwParams.rate)) {
93         return HDF_FAILURE;
94     }
95     if (!HdfSbufWriteUint32(sBuf, g_hwParams.periodSize)) {
96         return HDF_FAILURE;
97     }
98     if (!HdfSbufWriteUint32(sBuf, g_hwParams.periodCount)) {
99         return HDF_FAILURE;
100     }
101     if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.format))) {
102         return HDF_FAILURE;
103     }
104     if (!HdfSbufWriteString(sBuf, g_hwParams.cardServiceName)) {
105         return HDF_FAILURE;
106     }
107     if (!HdfSbufWriteUint32(sBuf, g_hwParams.period)) {
108         return HDF_FAILURE;
109     }
110     if (!HdfSbufWriteUint32(sBuf, g_hwParams.frameSize)) {
111         return HDF_FAILURE;
112     }
113     if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.isBigEndian))) {
114         return HDF_FAILURE;
115     }
116     if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.isSignedData))) {
117         return HDF_FAILURE;
118     }
119     if (!HdfSbufWriteUint32(sBuf, g_hwParams.startThreshold)) {
120         return HDF_FAILURE;
121     }
122     if (!HdfSbufWriteUint32(sBuf, g_hwParams.stopThreshold)) {
123         return HDF_FAILURE;
124     }
125     if (!HdfSbufWriteUint32(sBuf, g_hwParams.silenceThreshold)) {
126         return HDF_FAILURE;
127     }
128     return HDF_SUCCESS;
129 }
130 
AudioCtlCaptureSetPauseBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)131 int32_t AudioCtlCaptureSetPauseBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
132 {
133 #ifdef ALSA_MODE
134     return HDF_SUCCESS;
135 #endif
136     if (handleData == NULL || sBuf == NULL) {
137         LOG_FUN_ERR("handleData or sBuf is NULL!");
138         return HDF_FAILURE;
139     }
140     uint32_t card = handleData->captureMode.hwInfo.card;
141     if (card >= AUDIO_SERVICE_MAX) {
142         LOG_FUN_ERR("wrong card!");
143         return HDF_FAILURE;
144     }
145     struct AudioCtlElemValue elemCaptureValue;
146     elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card];
147     elemCaptureValue.id.iface = AUDIODRV_CTL_CAPTUREELEM_IFACE_MIXER;
148     elemCaptureValue.id.itemName = "Main Playback Pause";
149     elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.pause;
150     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.value[0])) {
151         LOG_FUN_ERR("CaptureSetPauseBuf pause Write Fail!");
152         return HDF_FAILURE;
153     }
154     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) {
155         LOG_FUN_ERR("CaptureSetPauseBuf iface Write Fail!");
156         return HDF_FAILURE;
157     }
158     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) {
159         LOG_FUN_ERR("CaptureSetPauseBuf cardServiceName Write Fail!");
160         return HDF_FAILURE;
161     }
162     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) {
163         LOG_FUN_ERR("CaptureSetPauseBuf itemName Write Fail!");
164         return HDF_FAILURE;
165     }
166     return HDF_SUCCESS;
167 }
168 
AudioCtlCaptureSetPauseStu(const struct DevHandleCapture * handle,int cmdId,const struct AudioHwCaptureParam * handleData)169 int32_t AudioCtlCaptureSetPauseStu(const struct DevHandleCapture *handle,
170     int cmdId, const struct AudioHwCaptureParam *handleData)
171 {
172 #ifdef ALSA_MODE
173     return HDF_SUCCESS;
174 #endif
175     int32_t ret;
176 
177     if (handle == NULL || handle->object == NULL || handleData == NULL) {
178         LOG_FUN_ERR("CaptureSetPauseStu paras is NULL!");
179         return HDF_FAILURE;
180     }
181     struct HdfIoService *service = NULL;
182     struct HdfSBuf *reply = NULL;
183     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
184     if (sBuf == NULL) {
185         LOG_FUN_ERR("CaptureSetPauseStu Failed to obtain sBuf");
186         return HDF_FAILURE;
187     }
188     ret = AudioCtlCaptureSetPauseBuf(sBuf, handleData);
189     if (ret < 0) {
190         LOG_FUN_ERR("Failed to Set Pause sBuf!");
191         AudioBufReplyRecycle(sBuf, NULL);
192         return ret;
193     }
194     service = (struct HdfIoService *)handle->object;
195     if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
196         LOG_FUN_ERR("SetPauseStu Service is NULL!");
197         AudioBufReplyRecycle(sBuf, NULL);
198         return HDF_FAILURE;
199     }
200     cmdId = handleData->captureMode.ctlParam.pause ?
201         AUDIO_DRV_PCM_IOCTRL_PAUSE_CAPTURE : AUDIO_DRV_PCM_IOCTRL_RESUME_CAPTURE;
202     ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply);
203     if (ret != HDF_SUCCESS) {
204         LOG_FUN_ERR("SetPauseStu Failed to send service call!");
205     }
206     AudioBufReplyRecycle(sBuf, NULL);
207     return ret;
208 }
209 
AudioCtlCaptureGetVolumeSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)210 int32_t AudioCtlCaptureGetVolumeSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
211 {
212 #ifdef ALSA_MODE
213     return HDF_SUCCESS;
214 #endif
215     if (handleData == NULL || sBuf == NULL) {
216         LOG_FUN_ERR("CaptureGetVolumeSBuf  parameter is empty!");
217         return HDF_FAILURE;
218     }
219     uint32_t card = handleData->captureMode.hwInfo.card;
220     if (card >= AUDIO_SERVICE_MAX) {
221         LOG_FUN_ERR("card is Error!");
222         return HDF_FAILURE;
223     }
224     struct AudioCtlElemValue elemCaptureValue;
225     elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card];
226     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC;
227     elemCaptureValue.id.itemName = "Main Capture Volume";
228     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) {
229         LOG_FUN_ERR("CaptureGetVolumeSBuf iface Write Fail!");
230         return HDF_FAILURE;
231     }
232     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) {
233         LOG_FUN_ERR("CaptureGetVolumeSBuf cardServiceName Write Fail!");
234         return HDF_FAILURE;
235     }
236     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) {
237         LOG_FUN_ERR("CaptureGetVolumeSBuf itemName Write Fail!");
238         return HDF_FAILURE;
239     }
240     return HDF_SUCCESS;
241 }
242 
AudioCtlCaptureGetVolume(const struct DevHandleCapture * handle,int cmdId,struct AudioHwCaptureParam * handleData)243 int32_t AudioCtlCaptureGetVolume(const struct DevHandleCapture *handle,
244     int cmdId, struct AudioHwCaptureParam *handleData)
245 {
246 #ifdef ALSA_MODE
247     char *ctlName = "DACL Capture Volume";
248     ReadInSoundCard();
249     (void)memset_s(&g_inDevInfo, sizeof(struct DevInfo), 0, sizeof(struct DevInfo));
250     GetInDevInfo(SND_IN_SOUND_CARD_MIC, &g_inDevInfo);
251     MixerOpenLegacy(false, g_inDevInfo.card);
252     handleData->captureMode.ctlParam.volume = RouteGetVoiceVolume(ctlName, false);
253     return HDF_SUCCESS;
254 #endif
255     int32_t ret;
256     if (handle == NULL || handle->object == NULL || handleData == NULL) {
257         LOG_FUN_ERR("CaptureGetVolume paras is NULL!");
258         return HDF_FAILURE;
259     }
260     struct HdfIoService *service = NULL;
261     struct HdfSBuf *reply = NULL;
262     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
263     if (sBuf == NULL) {
264         LOG_FUN_ERR("CaptureGetVolume Failed to obtain sBuf");
265         return HDF_FAILURE;
266     }
267     reply = AudioObtainHdfSBuf();
268     if (reply == NULL) {
269         LOG_FUN_ERR("Failed to obtain reply");
270         AudioBufReplyRecycle(sBuf, NULL);
271         return HDF_FAILURE;
272     }
273     ret = AudioCtlCaptureGetVolumeSBuf(sBuf, handleData);
274     if (ret < 0) {
275         LOG_FUN_ERR("Failed to Get Volume sBuf!");
276         AudioBufReplyRecycle(sBuf, reply);
277         return ret;
278     }
279     service = (struct HdfIoService *)handle->object;
280     cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM;
281     ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
282     if (ret != HDF_SUCCESS) {
283         LOG_FUN_ERR("GetVolume Dispatch Fail!");
284         AudioBufReplyRecycle(sBuf, reply);
285         return HDF_FAILURE;
286     }
287     int32_t elemValue = 0;
288     if (!HdfSbufReadInt32(reply, &elemValue)) {
289         LOG_FUN_ERR("Failed to Get Volume sBuf!");
290         AudioBufReplyRecycle(sBuf, reply);
291         return HDF_FAILURE;
292     }
293     handleData->captureMode.ctlParam.volume = (float)elemValue;
294     AudioBufReplyRecycle(sBuf, reply);
295     return ret;
296 }
297 
AudioCtlCaptureSetVolumeSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)298 int32_t AudioCtlCaptureSetVolumeSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
299 {
300 #ifdef ALSA_MODE
301     return HDF_SUCCESS;
302 #endif
303     if (handleData == NULL || sBuf == NULL) {
304         LOG_FUN_ERR("CaptureSetVolumeSBuf parameter is empty!");
305         return HDF_FAILURE;
306     }
307     uint32_t card = handleData->captureMode.hwInfo.card;
308     if (card >= AUDIO_SERVICE_MAX) {
309         LOG_FUN_ERR("CaptureSetVolumeSBuf card is Error!");
310         return HDF_FAILURE;
311     }
312     struct AudioCtlElemValue elemCaptureValue;
313     elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card];
314     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC;
315     elemCaptureValue.id.itemName = "Main Capture Volume";
316     elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.volume;
317     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.value[0])) {
318         LOG_FUN_ERR("CaptureSetVolumeSBuf value[0] Write Fail!");
319         return HDF_FAILURE;
320     }
321     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) {
322         LOG_FUN_ERR("CaptureSetVolumeSBuf iface Write Fail!");
323         return HDF_FAILURE;
324     }
325     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) {
326         LOG_FUN_ERR("CaptureSetVolumeSBuf cardServiceName Write Fail!");
327         return HDF_FAILURE;
328     }
329     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) {
330         LOG_FUN_ERR("CaptureSetVolumeSBuf itemName Write Fail!");
331         return HDF_FAILURE;
332     }
333     return HDF_SUCCESS;
334 }
335 
AudioCtlCaptureSetVolume(const struct DevHandleCapture * handle,int cmdId,const struct AudioHwCaptureParam * handleData)336 int32_t AudioCtlCaptureSetVolume(const struct DevHandleCapture *handle,
337     int cmdId, const struct AudioHwCaptureParam *handleData)
338 {
339 #ifdef ALSA_MODE
340     float volume = handleData->captureMode.ctlParam.volume;
341     RouteSetCaptureVoiceVolume(volume);
342     return HDF_SUCCESS;
343 #endif
344     int32_t ret;
345     LOG_FUN_INFO();
346     if (handle == NULL || handle->object == NULL || handleData == NULL) {
347         LOG_FUN_ERR("CaptureSetVolume paras is NULL!");
348         return HDF_FAILURE;
349     }
350     struct HdfIoService *service = NULL;
351     struct HdfSBuf *reply = NULL;
352     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
353     if (sBuf == NULL) {
354         LOG_FUN_ERR("CaptureSetVolume Failed to obtain sBuf");
355         return HDF_FAILURE;
356     }
357     ret = AudioCtlCaptureSetVolumeSBuf(sBuf, handleData);
358     if (ret < 0) {
359         LOG_FUN_ERR("CaptureSetVolume Failed to Set Volume sBuf!");
360         AudioBufReplyRecycle(sBuf, NULL);
361         return ret;
362     }
363     service = (struct HdfIoService *)handle->object;
364     if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
365         LOG_FUN_ERR("CaptureSetVolume Service is NULL!");
366         AudioBufReplyRecycle(sBuf, NULL);
367         return HDF_FAILURE;
368     }
369     cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM;
370     ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply);
371     if (ret != HDF_SUCCESS) {
372         LOG_FUN_ERR("CaptureSetVolume Failed to send service call!");
373     }
374     AudioBufReplyRecycle(sBuf, NULL);
375     return ret;
376 }
377 
AudioCtlCaptureSetMuteSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)378 int32_t AudioCtlCaptureSetMuteSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
379 {
380 #ifdef ALSA_MODE
381     return HDF_SUCCESS;
382 #endif
383     if (handleData == NULL || sBuf == NULL) {
384         LOG_FUN_ERR("handleData or sBuf is NULL!");
385         return HDF_FAILURE;
386     }
387     uint32_t card = handleData->captureMode.hwInfo.card;
388     if (card >= AUDIO_SERVICE_MAX) {
389         LOG_FUN_ERR("CaptureSetMuteSBuf card is Error!");
390         return HDF_FAILURE;
391     }
392     struct AudioCtlElemValue elemCaptureValue;
393     elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card];
394     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC;
395     elemCaptureValue.id.itemName = "Capture Mute";
396     elemCaptureValue.value[0] = (int32_t)handleData->captureMode.ctlParam.mute;
397     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.value[0])) {
398         LOG_FUN_ERR("CaptureSetMuteSBuf mute Write Fail!");
399         return HDF_FAILURE;
400     }
401     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) {
402         LOG_FUN_ERR("CaptureSetMuteSBuf iface Write Fail!");
403         return HDF_FAILURE;
404     }
405     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) {
406         LOG_FUN_ERR("CaptureSetMuteSBuf cardServiceName Write Fail!");
407         return HDF_FAILURE;
408     }
409     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) {
410         LOG_FUN_ERR("CaptureSetMuteSBuf itemName Write Fail!");
411         return HDF_FAILURE;
412     }
413     return HDF_SUCCESS;
414 }
415 
AudioCtlCaptureSetMuteStu(const struct DevHandleCapture * handle,int cmdId,const struct AudioHwCaptureParam * handleData)416 int32_t AudioCtlCaptureSetMuteStu(const struct DevHandleCapture *handle,
417     int cmdId, const struct AudioHwCaptureParam *handleData)
418 {
419 #ifdef ALSA_MODE
420     return HDF_SUCCESS;
421 #endif
422     int32_t ret;
423 
424     if (handle == NULL || handle->object == NULL || handleData == NULL) {
425         LOG_FUN_ERR("CaptureSetMuteStu paras is NULL!");
426         return HDF_FAILURE;
427     }
428     struct HdfIoService *service = NULL;
429     struct HdfSBuf *reply = NULL;
430     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
431     if (sBuf == NULL) {
432         LOG_FUN_ERR("CaptureSetMuteStu Failed to obtain sBuf");
433         return HDF_FAILURE;
434     }
435     ret = AudioCtlCaptureSetMuteSBuf(sBuf, handleData);
436     if (ret < 0) {
437         LOG_FUN_ERR("CaptureSetMuteStu Failed to Get Mute sBuf!");
438         AudioBufReplyRecycle(sBuf, NULL);
439         return ret;
440     }
441     service = (struct HdfIoService *)handle->object;
442     if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
443         LOG_FUN_ERR("CaptureSetMuteStu Service is NULL!");
444         AudioBufReplyRecycle(sBuf, NULL);
445         return HDF_FAILURE;
446     }
447     cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM;
448     ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply);
449     if (ret != HDF_SUCCESS) {
450         LOG_FUN_ERR("CaptureSetMuteStu Failed to send service call!");
451     }
452     AudioBufReplyRecycle(sBuf, NULL);
453     return ret;
454 }
455 
AudioCtlCaptureGetMuteSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)456 int32_t AudioCtlCaptureGetMuteSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
457 {
458 #ifdef ALSA_MODE
459     return HDF_SUCCESS;
460 #endif
461     if (handleData == NULL || sBuf == NULL) {
462         LOG_FUN_ERR("The parameter is empty!");
463         return HDF_FAILURE;
464     }
465     uint32_t card = handleData->captureMode.hwInfo.card;
466     if (card >= AUDIO_SERVICE_MAX) {
467         LOG_FUN_ERR("CaptureGetMuteSBuf card is Error!");
468         return HDF_FAILURE;
469     }
470     struct AudioCtlElemValue elemCaptureValue;
471     elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card];
472     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC;
473     elemCaptureValue.id.itemName = "Capture Mute";
474     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) {
475         LOG_FUN_ERR("CaptureGetMuteSBuf iface Write Fail!");
476         return HDF_FAILURE;
477     }
478     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) {
479         LOG_FUN_ERR("CaptureGetMuteSBuf cardServiceName Write Fail!");
480         return HDF_FAILURE;
481     }
482     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) {
483         LOG_FUN_ERR("CaptureGetMuteSBuf itemName Write Fail!");
484         return HDF_FAILURE;
485     }
486     return HDF_SUCCESS;
487 }
488 
AudioCtlCaptureGetMuteStu(const struct DevHandleCapture * handle,int cmdId,struct AudioHwCaptureParam * handleData)489 int32_t AudioCtlCaptureGetMuteStu(const struct DevHandleCapture *handle,
490     int cmdId, struct AudioHwCaptureParam *handleData)
491 {
492 #ifdef ALSA_MODE
493     return HDF_SUCCESS;
494 #endif
495     int32_t ret;
496 
497     if (handle == NULL || handle->object == NULL || handleData == NULL) {
498         LOG_FUN_ERR("CaptureGetMuteStu paras is NULL!");
499         return HDF_FAILURE;
500     }
501     struct HdfIoService *service = NULL;
502     struct HdfSBuf *reply = NULL;
503     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
504     if (sBuf == NULL) {
505         LOG_FUN_ERR("CaptureGetMuteStu Failed to obtain sBuf");
506         return HDF_FAILURE;
507     }
508     reply = AudioObtainHdfSBuf();
509     if (reply == NULL) {
510         LOG_FUN_ERR("Failed to obtain reply");
511         AudioBufReplyRecycle(sBuf, NULL);
512         return HDF_FAILURE;
513     }
514     ret = AudioCtlCaptureGetMuteSBuf(sBuf, handleData);
515     if (ret < 0) {
516         LOG_FUN_ERR("Failed to Get Mute sBuf!");
517         AudioBufReplyRecycle(sBuf, reply);
518         return ret;
519     }
520     service = (struct HdfIoService *)handle->object;
521     cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM;
522     ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
523     if (ret != HDF_SUCCESS) {
524         LOG_FUN_ERR("CaptureGetMuteStu Dispatch Fail!");
525         AudioBufReplyRecycle(sBuf, reply);
526         return HDF_FAILURE;
527     }
528     int32_t muteValueStu = 0;
529     if (!HdfSbufReadInt32(reply, &muteValueStu)) {
530         LOG_FUN_ERR("CaptureGetMuteStu Failed to Get Volume sBuf!");
531         AudioBufReplyRecycle(sBuf, reply);
532         return HDF_FAILURE;
533     }
534     handleData->captureMode.ctlParam.mute = (bool)muteValueStu;
535     AudioBufReplyRecycle(sBuf, reply);
536     return ret;
537 }
538 
AudioCtlCaptureSetGainSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)539 int32_t AudioCtlCaptureSetGainSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
540 {
541 #ifdef ALSA_MODE
542     return HDF_SUCCESS;
543 #endif
544     if (handleData == NULL || sBuf == NULL) {
545         LOG_FUN_ERR("CaptureSetGainSBuf( handleData or sBuf is NULL!");
546         return HDF_FAILURE;
547     }
548     uint32_t card = handleData->captureMode.hwInfo.card;
549     if (card >= AUDIO_SERVICE_MAX) {
550         LOG_FUN_ERR("CaptureSetGainSBuf card is Error!");
551         return HDF_FAILURE;
552     }
553     struct AudioCtlElemValue elemCaptureValue;
554     elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card];
555     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN;
556     elemCaptureValue.id.itemName = "Mic Left Gain";
557     elemCaptureValue.value[0] = handleData->captureMode.ctlParam.audioGain.gain;
558     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.value[0])) {
559         LOG_FUN_ERR("CaptureSetGainSBuf mute Write Fail!");
560         return HDF_FAILURE;
561     }
562     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) {
563         LOG_FUN_ERR("CaptureSetGainSBuf iface Write Fail!");
564         return HDF_FAILURE;
565     }
566     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) {
567         LOG_FUN_ERR("CaptureSetGainSBuf cardServiceName Write Fail!");
568         return HDF_FAILURE;
569     }
570     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) {
571         LOG_FUN_ERR("CaptureSetGainSBuf itemName Write Fail!");
572         return HDF_FAILURE;
573     }
574     return HDF_SUCCESS;
575 }
576 
AudioCtlCaptureSetGainStu(const struct DevHandleCapture * handle,int cmdId,const struct AudioHwCaptureParam * handleData)577 int32_t AudioCtlCaptureSetGainStu(const struct DevHandleCapture *handle,
578     int cmdId, const struct AudioHwCaptureParam *handleData)
579 {
580 #ifdef ALSA_MODE
581     return HDF_SUCCESS;
582 #endif
583     int32_t ret;
584 
585     if (handle == NULL || handle->object == NULL || handleData == NULL) {
586         LOG_FUN_ERR("CaptureSetGainStu paras is NULL!");
587         return HDF_FAILURE;
588     }
589     struct HdfIoService *service = NULL;
590     struct HdfSBuf *reply = NULL;
591     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
592     if (sBuf == NULL) {
593         LOG_FUN_ERR("CaptureSetGainStu Failed to obtain sBuf");
594         return HDF_FAILURE;
595     }
596     ret = AudioCtlCaptureSetGainSBuf(sBuf, handleData);
597     if (ret < 0) {
598         LOG_FUN_ERR("CaptureSetGainStu Failed to Get Gain sBuf!");
599         AudioBufReplyRecycle(sBuf, NULL);
600         return ret;
601     }
602     service = (struct HdfIoService *)handle->object;
603     if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
604         LOG_FUN_ERR("CaptureSetGainStu Service is NULL!");
605         AudioBufReplyRecycle(sBuf, NULL);
606         return HDF_FAILURE;
607     }
608     cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM;
609     ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply);
610     if (ret != HDF_SUCCESS) {
611         LOG_FUN_ERR("CaptureSetGainStu Failed to send service call!");
612     }
613     AudioBufReplyRecycle(sBuf, NULL);
614     return ret;
615 }
616 
AudioCtlCaptureGetGainSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)617 int32_t AudioCtlCaptureGetGainSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
618 {
619 #ifdef ALSA_MODE
620     return HDF_SUCCESS;
621 #endif
622     if (handleData == NULL || sBuf == NULL) {
623         LOG_FUN_ERR("CaptureGetGainSBuf paras is NULL!");
624         return HDF_FAILURE;
625     }
626     uint32_t card = handleData->captureMode.hwInfo.card;
627     if (card >= AUDIO_SERVICE_MAX) {
628         LOG_FUN_ERR("CaptureGetGainSBuf card is Error!");
629         return HDF_FAILURE;
630     }
631     struct AudioCtlElemValue elemCaptureValue;
632     elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card];
633     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN;
634     elemCaptureValue.id.itemName = "Mic Left Gain";
635     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) {
636         LOG_FUN_ERR("CaptureGetGainSBuf iface Write Fail!");
637         return HDF_FAILURE;
638     }
639     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) {
640         LOG_FUN_ERR("CaptureGetGainSBuf cardServiceName Write Fail!");
641         return HDF_FAILURE;
642     }
643     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) {
644         LOG_FUN_ERR("CaptureGetGainSBuf itemName Write Fail!");
645         return HDF_FAILURE;
646     }
647     return HDF_SUCCESS;
648 }
649 
AudioCtlCaptureGetGainStu(const struct DevHandleCapture * handle,int cmdId,struct AudioHwCaptureParam * handleData)650 int32_t AudioCtlCaptureGetGainStu(const struct DevHandleCapture *handle,
651     int cmdId, struct AudioHwCaptureParam *handleData)
652 {
653 #ifdef ALSA_MODE
654     return HDF_SUCCESS;
655 #endif
656     int32_t ret;
657 
658     if (handle == NULL || handle->object == NULL || handleData == NULL) {
659         LOG_FUN_ERR("CaptureGetGainStu paras is NULL!");
660         return HDF_FAILURE;
661     }
662     struct HdfIoService *service = NULL;
663     struct HdfSBuf *reply = NULL;
664     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
665     if (sBuf == NULL) {
666         LOG_FUN_ERR("CaptureGetGainStu Failed to obtain sBuf");
667         return HDF_FAILURE;
668     }
669     reply = AudioObtainHdfSBuf();
670     if (reply == NULL) {
671         LOG_FUN_ERR("Failed to obtain reply");
672         AudioBufReplyRecycle(sBuf, NULL);
673         return HDF_FAILURE;
674     }
675     ret = AudioCtlCaptureGetGainSBuf(sBuf, handleData);
676     if (ret < 0) {
677         LOG_FUN_ERR("Failed to Get Gain sBuf!");
678         AudioBufReplyRecycle(sBuf, reply);
679         return ret;
680     }
681     service = (struct HdfIoService *)handle->object;
682     cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE - CTRL_NUM;
683     ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
684     if (ret != HDF_SUCCESS) {
685         LOG_FUN_ERR("GetGainStu Dispatch Fail!");
686         AudioBufReplyRecycle(sBuf, reply);
687         return HDF_FAILURE;
688     }
689     int32_t muteValueStu = 0;
690     if (!HdfSbufReadInt32(reply, &muteValueStu)) {
691         LOG_FUN_ERR("Failed to GetGain sBuf!");
692         AudioBufReplyRecycle(sBuf, reply);
693         return HDF_FAILURE;
694     }
695     handleData->captureMode.ctlParam.audioGain.gain = (float)muteValueStu;
696     AudioBufReplyRecycle(sBuf, reply);
697     return ret;
698 }
699 
AudioCtlCaptureSceneSelectSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData,int32_t deviceIndex)700 int32_t AudioCtlCaptureSceneSelectSBuf(struct HdfSBuf *sBuf,
701     const struct AudioHwCaptureParam *handleData, int32_t deviceIndex)
702 {
703 #ifdef ALSA_MODE
704     return HDF_SUCCESS;
705 #endif
706     if (handleData == NULL || sBuf == NULL) {
707         LOG_FUN_ERR("CaptureSceneSelectSBuf handleData or sBufs is NULL!");
708         return HDF_FAILURE;
709     }
710     if (deviceIndex < 0 || deviceIndex > PATHPLAN_COUNT - 1) {
711         LOG_FUN_ERR("deviceIndex is Invalid!");
712         return HDF_FAILURE;
713     }
714     uint32_t card = handleData->captureMode.hwInfo.card;
715     if (card >= AUDIO_SERVICE_MAX) {
716         LOG_FUN_ERR("CaptureSceneSelectSBuf card is Error!");
717         return HDF_FAILURE;
718     }
719     struct AudioCtlElemValue elemCaptureValue;
720     elemCaptureValue.id.cardServiceName = g_audioLibCaptureService[card];
721     elemCaptureValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_SELECT;
722     elemCaptureValue.id.itemName =
723         handleData->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].deviceSwitch;
724     elemCaptureValue.value[0] = handleData->captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].value;
725     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.value[0])) {
726         LOG_FUN_ERR("CaptureSceneSelectSBuf Write Fail!");
727         return HDF_FAILURE;
728     }
729     if (!HdfSbufWriteInt32(sBuf, elemCaptureValue.id.iface)) {
730         LOG_FUN_ERR("CaptureSceneSelectSBuf iface Write Fail!");
731         return HDF_FAILURE;
732     }
733     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.cardServiceName)) {
734         LOG_FUN_ERR("CaptureSceneSelectSBuf cardServiceName Write Fail!");
735         return HDF_FAILURE;
736     }
737     if (!HdfSbufWriteString(sBuf, elemCaptureValue.id.itemName)) {
738         LOG_FUN_ERR("CaptureSceneSelectSBuf itemName Write Fail!");
739         return HDF_FAILURE;
740     }
741     return HDF_SUCCESS;
742 }
743 
AudioCtlCaptureSceneSelect(const struct DevHandleCapture * handle,int cmdId,const struct AudioHwCaptureParam * handleData)744 int32_t AudioCtlCaptureSceneSelect(const struct DevHandleCapture *handle,
745     int cmdId, const struct AudioHwCaptureParam *handleData)
746 {
747 #ifdef ALSA_MODE
748     return HDF_SUCCESS;
749 #endif
750     int32_t index;
751 
752     if (handle == NULL || handle->object == NULL || handleData == NULL) {
753         LOG_FUN_ERR("CaptureSceneSelect parameter is empty!");
754         return HDF_FAILURE;
755     }
756     struct HdfIoService *service = NULL;
757     struct HdfSBuf *reply = NULL;
758     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
759     if (sBuf == NULL) {
760         LOG_FUN_ERR("Failed to obtain sBuf");
761         return HDF_FAILURE;
762     }
763     service = (struct HdfIoService *)handle->object;
764     int32_t deviceNum = handleData->captureMode.hwInfo.pathSelect.deviceInfo.deviceNum;
765     if (deviceNum < AUDIO_MIN_DEVICENUM) {
766         LOG_FUN_ERR("AUDIO_MIN_ADAPTERNUM Failed!");
767         AudioBufReplyRecycle(sBuf, NULL);
768         return HDF_FAILURE;
769     }
770     cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE - CTRL_NUM;
771     for (index = 0; index < deviceNum; index++) {
772         HdfSbufFlush(sBuf);
773         if (AudioCtlCaptureSceneSelectSBuf(sBuf, handleData, index) < 0) {
774             LOG_FUN_ERR("AudioCtlRenderSceneSelectSBuf Failed!");
775             AudioBufReplyRecycle(sBuf, NULL);
776             return HDF_FAILURE;
777         }
778         if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
779             LOG_FUN_ERR("CaptureSceneSelect Service is NULL!");
780             AudioBufReplyRecycle(sBuf, NULL);
781             return HDF_FAILURE;
782         }
783         if (service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply) < 0) {
784             LOG_FUN_ERR("CaptureSceneSelect Failed to send service call!");
785             AudioBufReplyRecycle(sBuf, NULL);
786             return HDF_FAILURE;
787         }
788     }
789     AudioBufReplyRecycle(sBuf, NULL);
790     return HDF_SUCCESS;
791 }
792 
AudioCtlCaptureGetGainThresholdSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)793 int32_t AudioCtlCaptureGetGainThresholdSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
794 {
795 #ifdef ALSA_MODE
796     return HDF_SUCCESS;
797 #endif
798     if (handleData == NULL || sBuf == NULL) {
799         LOG_FUN_ERR("CaptureGetGainThresholdSBuf paras is empty!");
800         return HDF_FAILURE;
801     }
802     uint32_t card = handleData->captureMode.hwInfo.card;
803     if (card >= AUDIO_SERVICE_MAX) {
804         LOG_FUN_ERR("CaptureGetGainThresholdSBuf card is Error!");
805         return HDF_FAILURE;
806     }
807     struct AudioCtrlElemInfo elemCaptureInfo;
808     elemCaptureInfo.id.cardServiceName = g_audioLibCaptureService[card];
809     elemCaptureInfo.id.iface = AUDIODRV_CTL_CAPTUREELEM_IFACE_MIXER;
810     elemCaptureInfo.id.itemName = "Mic Left Gain";
811     if (!HdfSbufWriteInt32(sBuf, elemCaptureInfo.id.iface)) {
812         LOG_FUN_ERR("CaptureGetGainThresholdSBuf iface Write Fail!");
813         return HDF_FAILURE;
814     }
815     if (!HdfSbufWriteString(sBuf, elemCaptureInfo.id.cardServiceName)) {
816         LOG_FUN_ERR("CaptureGetGainThresholdSBuf cardServiceName Write Fail!");
817         return HDF_FAILURE;
818     }
819     if (!HdfSbufWriteString(sBuf, elemCaptureInfo.id.itemName)) {
820         LOG_FUN_ERR("CaptureGetGainThresholdSBuf itemName Write Fail!");
821         return HDF_FAILURE;
822     }
823     return HDF_SUCCESS;
824 }
825 
AudioCtlCaptureGetGainThreshold(const struct DevHandleCapture * handle,int cmdId,struct AudioHwCaptureParam * handleData)826 int32_t AudioCtlCaptureGetGainThreshold(const struct DevHandleCapture *handle,
827     int cmdId, struct AudioHwCaptureParam *handleData)
828 {
829 #ifdef ALSA_MODE
830     return HDF_SUCCESS;
831 #endif
832     int32_t ret;
833 
834     if (handle == NULL || handle->object == NULL || handleData == NULL) {
835         LOG_FUN_ERR("CaptureGetGainThreshold paras is NULL!");
836         return HDF_FAILURE;
837     }
838     struct HdfIoService *service = NULL;
839     struct HdfSBuf *reply = NULL;
840     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
841     if (sBuf == NULL) {
842         LOG_FUN_ERR("CaptureGetGainThreshold Failed to obtain sBuf");
843         return HDF_FAILURE;
844     }
845     reply = AudioObtainHdfSBuf();
846     if (reply == NULL) {
847         LOG_FUN_ERR("CaptureGetGainThreshold Failed to obtain reply");
848         AudioBufReplyRecycle(sBuf, NULL);
849         return HDF_FAILURE;
850     }
851     ret = AudioCtlCaptureGetGainThresholdSBuf(sBuf, handleData);
852     if (ret != HDF_SUCCESS) {
853         LOG_FUN_ERR("CaptureGetGainThreshold Failed to Get Threshold sBuf!");
854         AudioBufReplyRecycle(sBuf, reply);
855         return ret;
856     }
857     service = (struct HdfIoService *)handle->object;
858     cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE - CTRL_NUM;
859     ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
860     if (ret != HDF_SUCCESS) {
861         AudioBufReplyRecycle(sBuf, reply);
862         return HDF_FAILURE;
863     }
864     struct AudioCtrlElemInfo gainThreshold;
865     (void)memset_s(&gainThreshold, sizeof(struct AudioCtrlElemInfo), 0, sizeof(struct AudioCtrlElemInfo));
866     if (!HdfSbufReadInt32(reply, &gainThreshold.type)) {
867         LOG_FUN_ERR("CaptureGetGainThreshold Failed to HdfSbufReadBuffer!");
868         AudioBufReplyRecycle(sBuf, reply);
869         return HDF_FAILURE;
870     }
871     if (!HdfSbufReadInt32(reply, &gainThreshold.max)) {
872         LOG_FUN_ERR("CaptureGetGainThreshold Failed to HdfSbufReadBuffer!");
873         AudioBufReplyRecycle(sBuf, reply);
874         return HDF_FAILURE;
875     }
876     handleData->captureMode.ctlParam.audioGain.gainMax = gainThreshold.max;
877     handleData->captureMode.ctlParam.audioGain.gainMin = 0;
878     AudioBufReplyRecycle(sBuf, reply);
879     return ret;
880 }
881 
AudioCtlCaptureGetVolThresholdSBuf(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)882 int32_t AudioCtlCaptureGetVolThresholdSBuf(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
883 {
884 #ifdef ALSA_MODE
885     return HDF_SUCCESS;
886 #endif
887     if (handleData == NULL || sBuf == NULL) {
888         LOG_FUN_ERR("CaptureGetVolThresholdSBuf paras is empty!");
889         return HDF_FAILURE;
890     }
891     uint32_t card = handleData->captureMode.hwInfo.card;
892     if (card >= AUDIO_SERVICE_MAX) {
893         LOG_FUN_ERR("CaptureGetVolThresholdSBuf card is Error!");
894         return HDF_FAILURE;
895     }
896     struct AudioCtrlElemInfo elemCaptureInfo;
897     elemCaptureInfo.id.cardServiceName = g_audioLibCaptureService[card];
898     elemCaptureInfo.id.iface = AUDIODRV_CTL_ELEM_IFACE_ADC;
899     elemCaptureInfo.id.itemName = "Main Capture Volume";
900     if (!HdfSbufWriteInt32(sBuf, elemCaptureInfo.id.iface)) {
901         LOG_FUN_ERR("elemCaptureInfo.id.iface iface Write Fail!");
902         return HDF_FAILURE;
903     }
904     if (!HdfSbufWriteString(sBuf, elemCaptureInfo.id.cardServiceName)) {
905         LOG_FUN_ERR("CaptureGetVolThresholdSBuf cardServiceName Write Fail!");
906         return HDF_FAILURE;
907     }
908     if (!HdfSbufWriteString(sBuf, elemCaptureInfo.id.itemName)) {
909         LOG_FUN_ERR("CaptureGetVolThresholdSBuf itemName Write Fail!");
910         return HDF_FAILURE;
911     }
912     return HDF_SUCCESS;
913 }
914 
915 #ifdef ALSA_MODE
TinyAlsaAudioCtlCaptureGetVolThreshold(struct AudioHwCaptureParam * handleData)916 int32_t TinyAlsaAudioCtlCaptureGetVolThreshold(struct AudioHwCaptureParam *handleData)
917 {
918     long long volMin = 0;
919     long long volMax = 0;
920     char *ctlName = "DACL Capture Volume";
921     ReadInSoundCard();
922     (void)memset_s(&g_inDevInfo, sizeof(struct DevInfo), 0, sizeof(struct DevInfo));
923     GetInDevInfo(SND_IN_SOUND_CARD_MIC, &g_inDevInfo);
924     MixerOpenLegacy(false, g_inDevInfo.card);
925     RouteGetVoiceMinMaxStep(&volMin, &volMax, ctlName, false);
926     handleData->captureMode.ctlParam.volThreshold.volMax = volMax;
927     handleData->captureMode.ctlParam.volThreshold.volMin = volMin;
928     return HDF_SUCCESS;
929 }
930 #endif
931 
AudioCtlCaptureGetVolThreshold(const struct DevHandleCapture * handle,int cmdId,struct AudioHwCaptureParam * handleData)932 int32_t AudioCtlCaptureGetVolThreshold(const struct DevHandleCapture *handle,
933     int cmdId, struct AudioHwCaptureParam *handleData)
934 {
935 #ifdef ALSA_MODE
936     return TinyAlsaAudioCtlCaptureGetVolThreshold(handleData);
937 #endif
938     if (handle == NULL || handle->object == NULL || handleData == NULL) {
939         LOG_FUN_ERR("paras is NULL!");
940         return HDF_FAILURE;
941     }
942     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
943     if (sBuf == NULL) {
944         LOG_FUN_ERR("Failed to Get sBuf");
945         return HDF_FAILURE;
946     }
947     struct HdfSBuf *reply = AudioObtainHdfSBuf();
948     if (reply == NULL) {
949         LOG_FUN_ERR("Failed to obtain reply");
950         AudioBufReplyRecycle(sBuf, NULL);
951         return HDF_FAILURE;
952     }
953     int32_t ret = AudioCtlCaptureGetVolThresholdSBuf(sBuf, handleData);
954     if (ret < 0) {
955         LOG_FUN_ERR("Failed to Get Threshold sBuf!");
956         AudioBufReplyRecycle(sBuf, reply);
957         return ret;
958     }
959     struct HdfIoService *service = (struct HdfIoService *)handle->object;
960     cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO_CAPTURE - CTRL_NUM;
961     ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
962     if (ret != HDF_SUCCESS) {
963         AudioBufReplyRecycle(sBuf, reply);
964         return HDF_FAILURE;
965     }
966     struct AudioCtrlElemInfo volThreshold;
967     ret = AudioCtlGetVolThresholdRead(reply, &volThreshold);
968     if (ret < 0) {
969         AudioBufReplyRecycle(sBuf, reply);
970         return HDF_FAILURE;
971     }
972     handleData->captureMode.ctlParam.volThreshold.volMax = volThreshold.max;
973     handleData->captureMode.ctlParam.volThreshold.volMin = volThreshold.min;
974     AudioBufReplyRecycle(sBuf, reply);
975     return ret;
976 }
977 
AudioInterfaceLibCtlCapture(const struct DevHandleCapture * handle,int cmdId,struct AudioHwCaptureParam * handleData)978 int32_t AudioInterfaceLibCtlCapture(const struct DevHandleCapture *handle,
979     int cmdId, struct AudioHwCaptureParam *handleData)
980 {
981     int32_t ret;
982 
983     if (handle == NULL || handle->object == NULL || handleData == NULL) {
984         LOG_FUN_ERR("paras is NULL!");
985         return HDF_FAILURE;
986     }
987     switch (cmdId) {
988         /* setPara: */
989         case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE:
990             ret = AudioCtlCaptureSetVolume(handle, cmdId, handleData);
991             break;
992         case AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE:
993             ret = AudioCtlCaptureSetMuteStu(handle, cmdId, handleData);
994             break;
995         case AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE:
996             ret = AudioCtlCaptureGetMuteStu(handle, cmdId, handleData);
997             break;
998         /* getPara: */
999         case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE:
1000             ret = AudioCtlCaptureGetVolume(handle, cmdId, handleData);
1001             break;
1002         case AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE:
1003             ret = AudioCtlCaptureSetGainStu(handle, cmdId, handleData);
1004             break;
1005         case AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE:
1006             ret = AudioCtlCaptureGetGainStu(handle, cmdId, handleData);
1007             break;
1008         case AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE:
1009             ret = AudioCtlCaptureSceneSelect(handle, cmdId, handleData);
1010             break;
1011         case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE:
1012             ret = AudioCtlCaptureGetGainThreshold(handle, cmdId, handleData);
1013             break;
1014         case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE:
1015             ret = AudioCtlCaptureGetVolThreshold(handle, cmdId, handleData);
1016             break;
1017         default:
1018             LOG_FUN_ERR("Ctl Mode not support!");
1019             ret = HDF_FAILURE;
1020             break;
1021     }
1022     return ret;
1023 }
1024 
AudioOutputCaptureHwParams(const struct DevHandleCapture * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1025 int32_t AudioOutputCaptureHwParams(const struct DevHandleCapture *handle,
1026     int cmdId, const struct AudioHwCaptureParam *handleData)
1027 {
1028     if (handle == NULL || handle->object == NULL || handleData == NULL) {
1029         LOG_FUN_ERR("Function parameter is NULL!");
1030         return HDF_FAILURE;
1031     }
1032 #ifndef ALSA_MODE
1033     int32_t ret;
1034     struct HdfIoService *service = NULL;
1035 #else
1036     int32_t ret = HDF_SUCCESS;
1037 #endif
1038     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
1039     if (sBuf == NULL) {
1040         LOG_FUN_ERR("Failed to obtain sBuf");
1041         return HDF_FAILURE;
1042     }
1043     if (SetHwParamsCapture(handleData) < 0) {
1044         AudioBufReplyRecycle(sBuf, NULL);
1045         return HDF_FAILURE;
1046     }
1047     if (ParamsSbufWriteBuffer(sBuf) < 0) {
1048         AudioBufReplyRecycle(sBuf, NULL);
1049         return HDF_FAILURE;
1050     }
1051 #ifndef ALSA_MODE
1052     service = (struct HdfIoService *)handle->object;
1053     if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1054         LOG_FUN_ERR("Function parameter is empty!");
1055         AudioBufReplyRecycle(sBuf, NULL);
1056         return HDF_FAILURE;
1057     }
1058     ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL);
1059     if (ret != HDF_SUCCESS) {
1060         LOG_FUN_ERR("Failed to send service call!");
1061     }
1062 #endif
1063     AudioBufReplyRecycle(sBuf, NULL);
1064     return ret;
1065 }
1066 
AudioOutputCaptureOpen(const struct DevHandleCapture * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1067 int32_t AudioOutputCaptureOpen(const struct DevHandleCapture *handle,
1068     int cmdId, const struct AudioHwCaptureParam *handleData)
1069 {
1070 #ifdef ALSA_MODE
1071     return HDF_SUCCESS;
1072 #endif
1073     if (handle == NULL || handle->object == NULL || handleData == NULL) {
1074         LOG_FUN_ERR("Function parameter is NULL!");
1075         return HDF_FAILURE;
1076     }
1077     uint32_t card = handleData->captureMode.hwInfo.card;
1078     if (card >= AUDIO_SERVICE_MAX) {
1079         LOG_FUN_ERR("card is Error!");
1080         return HDF_FAILURE;
1081     }
1082     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
1083     if (sBuf == NULL) {
1084         LOG_FUN_ERR("Failed to obtain sBuf");
1085         return HDF_FAILURE;
1086     }
1087     if (!HdfSbufWriteString(sBuf, g_audioLibCaptureService[card])) {
1088         AudioBufReplyRecycle(sBuf, NULL);
1089         return HDF_FAILURE;
1090     }
1091     struct HdfIoService *service = (struct HdfIoService *)handle->object;
1092     if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1093         LOG_FUN_ERR("Function parameter is empty!");
1094         AudioBufReplyRecycle(sBuf, NULL);
1095         return HDF_FAILURE;
1096     }
1097     int32_t ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL);
1098     if (ret != HDF_SUCCESS) {
1099         LOG_FUN_ERR("Failed to send service call!");
1100     }
1101     AudioBufReplyRecycle(sBuf, NULL);
1102     return ret;
1103 }
1104 
AudioOutputCaptureReadFrame(struct HdfIoService * service,int cmdId,struct HdfSBuf * reply)1105 int32_t AudioOutputCaptureReadFrame(struct HdfIoService *service, int cmdId, struct HdfSBuf *reply)
1106 {
1107 #ifdef ALSA_MODE
1108     return HDF_SUCCESS;
1109 #endif
1110     int32_t ret;
1111     uint32_t buffStatus = 0;
1112     int32_t tryNumReply = 100; // try get reply count
1113     if (service == NULL || reply == NULL) {
1114         LOG_FUN_ERR("paras is NULL!");
1115         return HDF_FAILURE;
1116     }
1117     if (service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1118         LOG_FUN_ERR("service->dispatcher is null!");
1119         return HDF_FAILURE;
1120     }
1121     do {
1122         ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, reply);
1123         if (ret != HDF_SUCCESS) {
1124             LOG_FUN_ERR("Failed to send service call!");
1125             HdfSbufRecycle(reply);
1126             return ret;
1127         }
1128         if (!HdfSbufReadUint32(reply, &buffStatus)) {
1129             LOG_FUN_ERR("Failed to Get buffStatus!");
1130             HdfSbufRecycle(reply);
1131             return HDF_FAILURE;
1132         }
1133         if (buffStatus == CIR_BUFF_EMPTY) {
1134             LOG_PARA_INFO("Cir buff empty wait 50ms");
1135             tryNumReply--;
1136             HdfSbufFlush(reply);
1137             // wait (5 + tryNum)ms when buff empty
1138             usleep(AUDIO_CAP_WAIT_DELAY + (tryNumReply % AUDIO_TRYNUM) * AUDIO_TRYNUM_TIME);
1139             continue;
1140         }
1141         break;
1142     } while (tryNumReply > 0);
1143     if (tryNumReply <= 0) {
1144         HdfSbufRecycle(reply);
1145         LOG_FUN_ERR("Out of tryNumReply!");
1146         return HDF_FAILURE;
1147     }
1148     return HDF_SUCCESS;
1149 }
1150 
1151 #ifdef ALSA_MODE
TinyalsaAudioOutputCaptureRead(const struct DevHandleCapture * handle,int cmdId,struct AudioHwCaptureParam * handleData)1152 int32_t TinyalsaAudioOutputCaptureRead(const struct DevHandleCapture *handle,
1153     int cmdId, struct AudioHwCaptureParam *handleData)
1154 {
1155     char *buffer = NULL;
1156     uint32_t dataSize;
1157     if (!pcm) { // if pcm is num, need create it first
1158         int format = PCM_FORMAT_S16_LE;
1159         if (g_hwParams.format == AUDIO_FORMAT_PCM_8_BIT) {
1160             format = PCM_FORMAT_S8;
1161         } else if (g_hwParams.format == AUDIO_FORMAT_PCM_16_BIT) {
1162             format = PCM_FORMAT_S16_LE;
1163         } else if (g_hwParams.format == AUDIO_FORMAT_PCM_24_BIT) {
1164             format = PCM_FORMAT_S24_LE;
1165         } else if (g_hwParams.format == AUDIO_FORMAT_PCM_32_BIT) {
1166             format = PCM_FORMAT_S32_LE;
1167         } else {
1168             format = PCM_FORMAT_S16_LE;
1169         }
1170         ReadInSoundCard();
1171         (void)memset_s(&g_inDevInfo, sizeof(struct DevInfo), 0, sizeof(struct DevInfo));
1172         GetInDevInfo(SND_IN_SOUND_CARD_MIC, &g_inDevInfo);
1173         struct PcmCaptureParam param;
1174         (void)memset_s(&param, sizeof(param), 0, sizeof(param));
1175         param.card = g_inDevInfo.card;
1176         param.device = g_inDevInfo.device;
1177         param.channels = g_hwParams.channels;
1178         param.rate = g_hwParams.rate;
1179         param.format = format;
1180         param.periodSize = g_hwParams.periodSize / 4; // limited to 16K,periodSize/4.
1181         param.periodCount = g_hwParams.periodCount / 2; // limited to 16K, periodCount/2.
1182         CaptureSample(&pcm, &param);
1183         RoutePcmCardOpen(g_inDevInfo.card, DEV_IN_HANDS_FREE_MIC_CAPTURE_ROUTE);
1184     }
1185     if (pcm) {
1186         dataSize = pcm_frames_to_bytes(pcm, pcm_get_buffer_size(pcm));
1187         if (dataSize < 1) {
1188             return HDF_FAILURE;
1189         }
1190         buffer = malloc(dataSize);
1191         if (!buffer) {
1192             fprintf(stderr, "Unable to allocate \n");
1193             pcm_close(pcm);
1194             return HDF_FAILURE;
1195         }
1196         if (!pcm_read(pcm, buffer, dataSize)) {
1197             memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, buffer, dataSize);
1198         }
1199         handleData->frameCaptureMode.bufferSize = dataSize;
1200         handleData->frameCaptureMode.bufferFrameSize = pcm_bytes_to_frames(pcm, dataSize);
1201         free(buffer);
1202         return HDF_SUCCESS;
1203     }
1204     return HDF_FAILURE;
1205 }
1206 #endif
1207 
AudioOutputCaptureRead(const struct DevHandleCapture * handle,int cmdId,struct AudioHwCaptureParam * handleData)1208 int32_t AudioOutputCaptureRead(const struct DevHandleCapture *handle,
1209     int cmdId, struct AudioHwCaptureParam *handleData)
1210 {
1211 #ifdef ALSA_MODE
1212     return TinyalsaAudioOutputCaptureRead(handle, cmdId, handleData);
1213 #endif
1214     uint32_t dataSize = 0;
1215     uint32_t frameCount = 0;
1216     size_t replySize = AUDIO_SIZE_FRAME_16K + AUDIO_REPLY_EXTEND;
1217     char *frame = NULL;
1218     struct HdfIoService *service = NULL;
1219     if (handle == NULL || handle->object == NULL || handleData == NULL) {
1220         LOG_FUN_ERR("paras is NULL!");
1221         return HDF_FAILURE;
1222     }
1223     struct HdfSBuf *reply = HdfSbufTypedObtainCapacity(SBUF_RAW, replySize);
1224     if (reply == NULL) {
1225         return HDF_FAILURE;
1226     }
1227     service = (struct HdfIoService *)handle->object;
1228     if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1229         LOG_FUN_ERR("Service is NULL!");
1230         AudioBufReplyRecycle(NULL, reply);
1231         return HDF_FAILURE;
1232     }
1233     int32_t ret = AudioOutputCaptureReadFrame(service, cmdId, reply);
1234     if (ret != 0) {
1235         LOG_FUN_ERR("AudioOutputCaptureReadFrame is invalid!");
1236         return HDF_FAILURE;
1237     }
1238     if (!HdfSbufReadBuffer(reply, (const void **)&frame, &dataSize)) {
1239         HdfSbufRecycle(reply);
1240         return HDF_FAILURE;
1241     }
1242     if (dataSize > FRAME_DATA || handleData->frameCaptureMode.buffer == NULL) {
1243         LOG_FUN_ERR("Buffer is NULL or DataSize overflow!");
1244         HdfSbufRecycle(reply);
1245         return HDF_FAILURE;
1246     }
1247     if (!HdfSbufReadUint32(reply, &frameCount)) {
1248         LOG_FUN_ERR("Failed to Get buffStatus!");
1249         HdfSbufRecycle(reply);
1250         return HDF_FAILURE;
1251     }
1252     ret = memcpy_s(handleData->frameCaptureMode.buffer, FRAME_DATA, frame, dataSize);
1253     if (ret != 0) {
1254         HdfSbufRecycle(reply);
1255         return HDF_FAILURE;
1256     }
1257     handleData->frameCaptureMode.bufferSize = dataSize;
1258     handleData->frameCaptureMode.bufferFrameSize = frameCount;
1259     HdfSbufRecycle(reply);
1260     return HDF_SUCCESS;
1261 }
1262 
AudioOutputCaptureStartPrepare(const struct DevHandleCapture * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1263 int32_t AudioOutputCaptureStartPrepare(const struct DevHandleCapture *handle,
1264     int cmdId, const struct AudioHwCaptureParam *handleData)
1265 {
1266 #ifdef ALSA_MODE
1267     return HDF_SUCCESS;
1268 #endif
1269     int32_t ret;
1270     struct HdfIoService *service = NULL;
1271     if (handle == NULL || handle->object == NULL || handleData == NULL) {
1272         LOG_FUN_ERR("CaptureStartPrepare paras is NULL!");
1273         return HDF_FAILURE;
1274     }
1275     service = (struct HdfIoService *)handle->object;
1276     if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1277         LOG_FUN_ERR("CaptureStartPrepare Service is NULL!");
1278         return HDF_FAILURE;
1279     }
1280     ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, NULL);
1281     if (ret != HDF_SUCCESS) {
1282         LOG_FUN_ERR("CaptureStartPrepare Failed to send service call!");
1283         return ret;
1284     }
1285     return HDF_SUCCESS;
1286 }
1287 
AudioOutputCaptureStop(const struct DevHandleCapture * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1288 int32_t AudioOutputCaptureStop(const struct DevHandleCapture *handle,
1289     int cmdId, const struct AudioHwCaptureParam *handleData)
1290 {
1291 #ifdef ALSA_MODE
1292     if (pcm) {
1293         pcm_close(pcm);
1294         pcm = NULL;
1295     }
1296     RoutePcmClose(DEV_OFF_CAPTURE_OFF_ROUTE);
1297     return HDF_SUCCESS;
1298 #endif
1299     int32_t ret;
1300     struct HdfIoService *service = NULL;
1301     if (handle == NULL || handle->object == NULL || handleData == NULL) {
1302         LOG_FUN_ERR("CaptureStop paras is NULL!");
1303         return HDF_FAILURE;
1304     }
1305     service = (struct HdfIoService *)handle->object;
1306     if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1307         LOG_FUN_ERR("CaptureStop Service is NULL!");
1308         return HDF_FAILURE;
1309     }
1310     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
1311     if (sBuf == NULL) {
1312         return HDF_FAILURE;
1313     }
1314     if (!HdfSbufWriteUint32(sBuf, AUDIO_TURN_STANDBY_LATER)) {
1315         AudioBufReplyRecycle(sBuf, NULL);
1316         return HDF_FAILURE;
1317     }
1318     ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL);
1319     if (ret != HDF_SUCCESS) {
1320         AudioBufReplyRecycle(sBuf, NULL);
1321         LOG_FUN_ERR("CaptureStop Failed to send service call!");
1322         return ret;
1323     }
1324     AudioBufReplyRecycle(sBuf, NULL);
1325     return HDF_SUCCESS;
1326 }
1327 
MmapDescWriteBufferCapture(struct HdfSBuf * sBuf,const struct AudioHwCaptureParam * handleData)1328 int32_t MmapDescWriteBufferCapture(struct HdfSBuf *sBuf, const struct AudioHwCaptureParam *handleData)
1329 {
1330 #ifdef ALSA_MODE
1331     return HDF_SUCCESS;
1332 #endif
1333     if (sBuf == NULL || handleData == NULL) {
1334         return HDF_FAILURE;
1335     }
1336     uint64_t mmapAddr = (uint64_t)(uintptr_t)(handleData->frameCaptureMode.mmapBufDesc.memoryAddress);
1337     if (!HdfSbufWriteUint64(sBuf, mmapAddr)) {
1338         return HDF_FAILURE;
1339     }
1340     if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.memoryFd)) {
1341         return HDF_FAILURE;
1342     }
1343     if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames)) {
1344         return HDF_FAILURE;
1345     }
1346     if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.transferFrameSize)) {
1347         return HDF_FAILURE;
1348     }
1349     if (!HdfSbufWriteInt32(sBuf, handleData->frameCaptureMode.mmapBufDesc.isShareable)) {
1350         return HDF_FAILURE;
1351     }
1352     if (!HdfSbufWriteUint32(sBuf, handleData->frameCaptureMode.mmapBufDesc.offset)) {
1353         return HDF_FAILURE;
1354     }
1355     return HDF_SUCCESS;
1356 }
1357 
AudioOutputCaptureReqMmapBuffer(const struct DevHandleCapture * handle,int cmdId,const struct AudioHwCaptureParam * handleData)1358 int32_t AudioOutputCaptureReqMmapBuffer(const struct DevHandleCapture *handle,
1359     int cmdId, const struct AudioHwCaptureParam *handleData)
1360 {
1361 #ifdef ALSA_MODE
1362     return HDF_SUCCESS;
1363 #endif
1364     if (handle == NULL || handle->object == NULL || handleData == NULL) {
1365         return HDF_FAILURE;
1366     }
1367     int32_t ret;
1368     struct HdfIoService *service = NULL;
1369     struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
1370     if (sBuf == NULL) {
1371         return HDF_FAILURE;
1372     }
1373     if (MmapDescWriteBufferCapture(sBuf, handleData)) {
1374         AudioBufReplyRecycle(sBuf, NULL);
1375         return HDF_FAILURE;
1376     }
1377     service = (struct HdfIoService *)handle->object;
1378     if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1379         AudioBufReplyRecycle(sBuf, NULL);
1380         LOG_FUN_ERR("The pointer is empty!");
1381         return HDF_FAILURE;
1382     }
1383     ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL);
1384     if (ret != HDF_SUCCESS) {
1385         LOG_FUN_ERR("Failed to send service call!");
1386         AudioBufReplyRecycle(sBuf, NULL);
1387         return HDF_FAILURE;
1388     }
1389     AudioBufReplyRecycle(sBuf, NULL);
1390     return HDF_SUCCESS;
1391 }
1392 
AudioOutputCaptureGetMmapPosition(const struct DevHandleCapture * handle,int cmdId,struct AudioHwCaptureParam * handleData)1393 int32_t AudioOutputCaptureGetMmapPosition(const struct DevHandleCapture *handle,
1394     int cmdId, struct AudioHwCaptureParam *handleData)
1395 {
1396 #ifdef ALSA_MODE
1397     return HDF_SUCCESS;
1398 #endif
1399     if (handle == NULL || handle->object == NULL || handleData == NULL) {
1400         return HDF_FAILURE;
1401     }
1402     int32_t ret;
1403     struct HdfIoService *service = NULL;
1404     struct HdfSBuf *reply = NULL;
1405     service = (struct HdfIoService *)handle->object;
1406     if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1407         LOG_FUN_ERR("The pointer is empty!");
1408         return HDF_FAILURE;
1409     }
1410     reply = AudioObtainHdfSBuf();
1411     if (reply == NULL) {
1412         LOG_FUN_ERR("CaptureGetMmapPosition Failed to obtain reply");
1413         return HDF_FAILURE;
1414     }
1415     ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, reply);
1416     if (ret != HDF_SUCCESS) {
1417         LOG_FUN_ERR("Failed to send service call!");
1418         AudioBufReplyRecycle(NULL, reply);
1419         return HDF_FAILURE;
1420     }
1421     uint64_t frames = 0;
1422     if (!HdfSbufReadUint64(reply, &frames)) {
1423         LOG_FUN_ERR("Failed to Get frames sBuf!");
1424         AudioBufReplyRecycle(NULL, reply);
1425         return HDF_FAILURE;
1426     }
1427     handleData->frameCaptureMode.frames = frames;
1428     AudioBufReplyRecycle(NULL, reply);
1429     return HDF_SUCCESS;
1430 }
1431 
AudioInterfaceLibOutputCapture(const struct DevHandleCapture * handle,int cmdId,struct AudioHwCaptureParam * handleData)1432 int32_t AudioInterfaceLibOutputCapture(const struct DevHandleCapture *handle, int cmdId,
1433                                        struct AudioHwCaptureParam *handleData)
1434 {
1435     if (handle == NULL) {
1436         LOG_FUN_ERR("Input Capture handle is NULL!");
1437         return HDF_FAILURE;
1438     }
1439     if (handle->object == NULL || handleData == NULL) {
1440         return HDF_FAILURE;
1441     }
1442     int32_t ret;
1443     switch (cmdId) {
1444         case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
1445             ret = AudioOutputCaptureHwParams(handle, cmdId, handleData);
1446             break;
1447         case AUDIO_DRV_PCM_IOCTL_READ:
1448             ret = AudioOutputCaptureRead(handle, cmdId, handleData);
1449             break;
1450         case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE:
1451         case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE:
1452         case AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE:
1453             ret = AudioOutputCaptureStartPrepare(handle, cmdId, handleData);
1454             break;
1455         case AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN:
1456             ret = AudioOutputCaptureOpen(handle, cmdId, handleData);
1457             break;
1458         case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE:
1459             ret = AudioOutputCaptureStop(handle, cmdId, handleData);
1460             break;
1461         case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE:
1462             ret = AudioCtlCaptureSetPauseStu(handle, cmdId, handleData);
1463             break;
1464         case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE:
1465             ret = AudioOutputCaptureReqMmapBuffer(handle, cmdId, handleData);
1466             break;
1467         case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE:
1468             ret = AudioOutputCaptureGetMmapPosition(handle, cmdId, handleData);
1469             break;
1470         default:
1471             LOG_FUN_ERR("Output Mode not support!");
1472             ret = HDF_FAILURE;
1473             break;
1474     }
1475     return ret;
1476 }
1477 
AudioBindServiceCaptureObject(struct DevHandleCapture * const handle,const char * name)1478 struct DevHandleCapture *AudioBindServiceCaptureObject(struct DevHandleCapture * const handle,
1479     const char *name)
1480 {
1481     if (handle == NULL || name == NULL) {
1482         LOG_FUN_ERR("service name or handle is NULL!");
1483         return NULL;
1484     }
1485     char *serviceName = (char *)calloc(1, NAME_LEN);
1486     if (serviceName == NULL) {
1487         LOG_FUN_ERR("Failed to OsalMemCalloc serviceName");
1488         AudioMemFree((void **)&handle);
1489         return NULL;
1490     }
1491     int ret = snprintf_s(serviceName, NAME_LEN - 1, SERVIC_NAME_MAX_LEN + 1, "hdf_audio_%s", name);
1492     if (ret < 0) {
1493         LOG_FUN_ERR("Failed to snprintf_s");
1494         AudioMemFree((void **)&serviceName);
1495         AudioMemFree((void **)&handle);
1496         return NULL;
1497     }
1498     struct HdfIoService *service = HdfIoServiceBindName(serviceName);
1499     if (service == NULL) {
1500         LOG_FUN_ERR("Failed to get service!");
1501         AudioMemFree((void **)&serviceName);
1502         AudioMemFree((void **)&handle);
1503         return NULL;
1504     }
1505     AudioMemFree((void **)&serviceName);
1506     handle->object = service;
1507     return handle->object;
1508 }
1509 
1510 /* CreatCapture for Bind handle */
AudioBindServiceCapture(const char * name)1511 struct DevHandleCapture *AudioBindServiceCapture(const char *name)
1512 {
1513     struct DevHandleCapture *handle = NULL;
1514     struct DevHandleCapture *object = NULL;
1515     if (name == NULL) {
1516         LOG_FUN_ERR("service name NULL!");
1517         return NULL;
1518     }
1519     handle = (struct DevHandleCapture *)calloc(1, sizeof(struct DevHandleCapture));
1520     if (handle == NULL) {
1521         LOG_FUN_ERR("Failed to OsalMemCalloc handle");
1522         return NULL;
1523     }
1524     object = AudioBindServiceCaptureObject(handle, name);
1525     if (object != NULL) {
1526         handle->object = object;
1527     } else {
1528         LOG_FUN_ERR("handle->object is NULL!");
1529         return NULL;
1530     }
1531     LOG_PARA_INFO("BIND SERVICE SUCCESS!");
1532     return handle;
1533 }
1534 
AudioCloseServiceCapture(const struct DevHandleCapture * handle)1535 void AudioCloseServiceCapture(const struct DevHandleCapture *handle)
1536 {
1537 #ifdef ALSA_MODE
1538     return;
1539 #endif
1540     LOG_FUN_INFO();
1541     if (handle == NULL || handle->object == NULL) {
1542         LOG_FUN_ERR("Capture handle or handle->object is NULL");
1543         return;
1544     }
1545     struct HdfIoService *service = (struct HdfIoService *)handle->object;
1546     HdfIoServiceRecycle(service);
1547     AudioMemFree((void **)&handle);
1548     return;
1549 }
1550 
AudioInterfaceLibModeCapture(const struct DevHandleCapture * handle,struct AudioHwCaptureParam * handleData,int cmdId)1551 int32_t AudioInterfaceLibModeCapture(const struct DevHandleCapture *handle,
1552     struct AudioHwCaptureParam *handleData, int cmdId)
1553 {
1554     LOG_FUN_INFO();
1555     if (handle == NULL || handle->object == NULL || handleData == NULL) {
1556         LOG_FUN_ERR("paras is NULL!");
1557         return HDF_FAILURE;
1558     }
1559     switch (cmdId) {
1560         case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
1561         case AUDIO_DRV_PCM_IOCTL_READ:
1562         case AUDIO_DRV_PCM_IOCTRL_START_CAPTURE:
1563         case AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE:
1564         case AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE:
1565         case AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE:
1566         case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE:
1567         case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE:
1568         case AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN:
1569         case AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE:
1570             return (AudioInterfaceLibOutputCapture(handle, cmdId, handleData));
1571         case AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE:
1572         case AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE:
1573         case AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE:
1574         case AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE:
1575         case AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE:
1576         case AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE:
1577         case AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE:
1578         case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE:
1579         case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE:
1580             return (AudioInterfaceLibCtlCapture(handle, cmdId, handleData));
1581         default:
1582             LOG_FUN_ERR("Mode Error!");
1583             break;
1584     }
1585     return HDF_ERR_NOT_SUPPORT;
1586 }
1587