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