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