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_hal_log.h"
18
19 #define AUDIODRV_CTL_ELEM_IFACE_DAC 0
20 #define AUDIODRV_CTL_ELEM_IFACE_MIX 3
21 #define AUDIO_SBUF_EXTEND 16
22
23 #define AUDIODRV_CTL_ELEM_IFACE_MIXER ((int32_t)2) /* virtual mixer device */
24 #define AUDIODRV_CTL_ELEM_IFACE_ACODEC ((int32_t)4) /* Acodec device */
25 #define AUDIODRV_CTL_ELEM_IFACE_AIAO ((int32_t)6)
26
27 #define AUDIODRV_CTL_ACODEC_ENABLE 1
28 #define AUDIODRV_CTL_ACODEC_DISABLE 0
29 #define AUDIODRV_CTL_INTERNAL_ACODEC_ENABLE 1
30 #define AUDIODRV_CTL_EXTERN_ACODEC_ENABLE 2
31 #define AUDIODRV_CTL_EXTERN_CODEC_STR "External Codec Enable"
32 #define AUDIODRV_CTL_INTERNAL_CODEC_STR "Internally Codec Enable"
33 #ifdef ALSA_MODE
34 #include "alsa_audio.h"
35 struct pcm *pcm;
36 struct DevInfo g_outDevInfo;
37 #endif
38
39 /* Out Put Render */
40 static struct AudioPcmHwParams g_hwParams;
41 char *g_audioLibRenderService[AUDIO_SERVICE_MAX] = {
42 [AUDIO_SERVICE_IN] = "hdf_audio_codec_dev0",
43 [AUDIO_SERVICE_OUT] = "hdf_audio_smartpa_dev0",
44 };
45
SetHwParams(const struct AudioHwRenderParam * handleData)46 int32_t SetHwParams(const struct AudioHwRenderParam *handleData)
47 {
48 if (handleData == NULL) {
49 LOG_FUN_ERR("handleData is NULL!");
50 return HDF_FAILURE;
51 }
52 uint32_t card = handleData->renderMode.hwInfo.card;
53 if (card >= AUDIO_SERVICE_MAX) {
54 LOG_FUN_ERR("card is Error!");
55 return HDF_FAILURE;
56 }
57 (void)memset_s(&g_hwParams, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams));
58 g_hwParams.streamType = AUDIO_RENDER_STREAM;
59 g_hwParams.channels = handleData->frameRenderMode.attrs.channelCount;
60 g_hwParams.rate = handleData->frameRenderMode.attrs.sampleRate;
61 g_hwParams.periodSize = handleData->frameRenderMode.periodSize;
62 g_hwParams.periodCount = handleData->frameRenderMode.periodCount;
63 g_hwParams.cardServiceName = g_audioLibRenderService[card];
64 g_hwParams.format = handleData->frameRenderMode.attrs.format;
65 g_hwParams.period = handleData->frameRenderMode.attrs.period;
66 g_hwParams.frameSize = handleData->frameRenderMode.attrs.frameSize;
67 g_hwParams.isBigEndian = handleData->frameRenderMode.attrs.isBigEndian;
68 g_hwParams.isSignedData = handleData->frameRenderMode.attrs.isSignedData;
69 g_hwParams.startThreshold = handleData->frameRenderMode.attrs.startThreshold;
70 g_hwParams.stopThreshold = handleData->frameRenderMode.attrs.stopThreshold;
71 g_hwParams.silenceThreshold = handleData->frameRenderMode.attrs.silenceThreshold;
72
73 #ifdef ALSA_MODE
74 LOG_PARA_INFO("ALSA_MODE streamType %d, channels %d, rate %d, periodSize %d, periodCount %d, \
75 cardServiceName %s, format %d, period %d, frameSize %d, isBigEndian %d, isSignedData %d, \
76 startThreshold %d, stopThreshold %d, silenceThreshold %d",
77 g_hwParams.streamType, g_hwParams.channels, g_hwParams.rate, g_hwParams.periodSize,
78 g_hwParams.periodCount, g_hwParams.cardServiceName, g_hwParams.format, g_hwParams.period,
79 g_hwParams.frameSize, g_hwParams.isBigEndian, g_hwParams.isSignedData, g_hwParams.startThreshold,
80 g_hwParams.stopThreshold, g_hwParams.silenceThreshold);
81 #endif
82 return HDF_SUCCESS;
83 }
84
AudioCtlRenderSetVolumeSBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)85 int32_t AudioCtlRenderSetVolumeSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
86 {
87 #ifdef ALSA_MODE
88 return HDF_SUCCESS;
89 #endif
90
91 if (handleData == NULL || sBuf == NULL) {
92 LOG_FUN_ERR("RenderSetVolumeSBuf handleData or sBuf is NULL!");
93 return HDF_FAILURE;
94 }
95 uint32_t card = handleData->renderMode.hwInfo.card;
96 if (card >= AUDIO_SERVICE_MAX) {
97 LOG_FUN_ERR("RenderSetVolumeSBuf card is Error!");
98 return HDF_FAILURE;
99 }
100 struct AudioCtlElemValue elemValue;
101 elemValue.id.cardServiceName = g_audioLibRenderService[card];
102 elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC;
103 elemValue.id.itemName = "Main Playback Volume";
104 elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.volume;
105 if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) {
106 LOG_FUN_ERR("RenderSetVolumeSBuf Write Fail!");
107 return HDF_FAILURE;
108 }
109 if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) {
110 LOG_FUN_ERR("RenderSetVolumeSBuf iface Write Fail!");
111 return HDF_FAILURE;
112 }
113 if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) {
114 LOG_FUN_ERR("RenderSetVolumeSBuf cardServiceName Write Fail!");
115 return HDF_FAILURE;
116 }
117 if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) {
118 LOG_FUN_ERR("RenderSetVolumeSBuf itemName Write Fail!");
119 return HDF_FAILURE;
120 }
121 return HDF_SUCCESS;
122 }
123
AudioCtlRenderGetVolumeSBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)124 int32_t AudioCtlRenderGetVolumeSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
125 {
126 #ifdef ALSA_MODE
127 return HDF_SUCCESS;
128 #endif
129 if (handleData == NULL || sBuf == NULL) {
130 LOG_FUN_ERR("RenderGetVolumeSBuf handleData or sBuf is NULL!");
131 return HDF_FAILURE;
132 }
133 uint32_t card = handleData->renderMode.hwInfo.card;
134 if (card >= AUDIO_SERVICE_MAX) {
135 LOG_FUN_ERR("RenderGetVolumeSBuf card is Error!");
136 return HDF_FAILURE;
137 }
138 struct AudioCtlElemValue elemValue;
139 elemValue.id.cardServiceName = g_audioLibRenderService[card];
140 elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC;
141 elemValue.id.itemName = "Main Playback Volume";
142 if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) {
143 LOG_FUN_ERR("RenderGetVolumeSBuf iface Write Fail!");
144 return HDF_FAILURE;
145 }
146 if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) {
147 LOG_FUN_ERR("RenderGetVolumeSBuf cardServiceName Write Fail!");
148 return HDF_FAILURE;
149 }
150 if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) {
151 LOG_FUN_ERR("RenderGetVolumeSBuf itemName Write Fail!");
152 return HDF_FAILURE;
153 }
154 return HDF_SUCCESS;
155 }
156
AudioCtlRenderSetVolume(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)157 int32_t AudioCtlRenderSetVolume(const struct DevHandle *handle, int cmdId,
158 const struct AudioHwRenderParam *handleData)
159 {
160 #ifdef ALSA_MODE
161 RouteSetVoiceVolume(handleData->renderMode.ctlParam.volume);
162 return HDF_SUCCESS;
163 #endif
164 int32_t ret;
165
166 if (handle == NULL || handle->object == NULL || handleData == NULL) {
167 LOG_FUN_ERR("RenderSetVolume parameter is empty!");
168 return HDF_FAILURE;
169 }
170 struct HdfIoService *service = NULL;
171 struct HdfSBuf *reply = NULL;
172 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
173 if (sBuf == NULL) {
174 LOG_FUN_ERR("Failed to obtain sBuf");
175 return HDF_FAILURE;
176 }
177 ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData);
178 if (ret < 0) {
179 LOG_FUN_ERR("Failed to Set Volume sBuf!");
180 AudioBufReplyRecycle(sBuf, NULL);
181 return ret;
182 }
183 service = (struct HdfIoService *)handle->object;
184 cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM;
185 ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
186 if (ret != HDF_SUCCESS) {
187 LOG_FUN_ERR("Failed to AudioServiceDispatch!");
188 }
189 AudioBufReplyRecycle(sBuf, NULL);
190 return ret;
191 }
192
193 #ifdef ALSA_MODE
AudioCtlRenderGetVolumeALSA(struct AudioHwRenderParam * handleData)194 int32_t AudioCtlRenderGetVolumeALSA(struct AudioHwRenderParam *handleData)
195 {
196 char *ctlName = "DACL Playback Volume";
197 ReadOutSoundCard();
198 (void)memset_s(&g_outDevInfo, sizeof(struct DevInfo), 0, sizeof(struct DevInfo));
199 GetOutDevInfo(SND_OUT_SOUND_CARD_SPEAKER, &g_outDevInfo);
200 MixerOpenLegacy(true, g_outDevInfo.card);
201 handleData->renderMode.ctlParam.volume = RouteGetVoiceVolume(ctlName, true);
202 return HDF_SUCCESS;
203 }
204 #endif
205
AudioCtlRenderGetVolume(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)206 int32_t AudioCtlRenderGetVolume(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
207 {
208 int32_t ret;
209 #ifdef ALSA_MODE
210 return AudioCtlRenderGetVolumeALSA(handleData);
211 #endif
212 if (handle == NULL || handle->object == NULL || handleData == NULL) {
213 LOG_FUN_ERR("RenderGetVolume parameter is empty!");
214 return HDF_FAILURE;
215 }
216 struct HdfIoService *service = NULL;
217 struct HdfSBuf *reply = NULL;
218 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
219 if (sBuf == NULL) {
220 LOG_FUN_ERR("RenderGetVolume Failed to obtain sBuf");
221 return HDF_FAILURE;
222 }
223 reply = AudioObtainHdfSBuf();
224 if (reply == NULL) {
225 LOG_FUN_ERR("RenderGetVolume Failed to obtain reply");
226 AudioBufReplyRecycle(sBuf, NULL);
227 return HDF_FAILURE;
228 }
229 ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData);
230 if (ret < 0) {
231 LOG_FUN_ERR("RenderGetVolume Failed to Get Volume sBuf!");
232 AudioBufReplyRecycle(sBuf, reply);
233 return ret;
234 }
235 service = (struct HdfIoService *)handle->object;
236 cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM;
237 ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
238 if (ret != HDF_SUCCESS) {
239 LOG_FUN_ERR("RenderGetVolume RenderDispatch Failed!");
240 AudioBufReplyRecycle(sBuf, reply);
241 return HDF_FAILURE;
242 }
243 struct AudioCtlElemValue elemValue;
244 (void)memset_s(&elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue));
245 if (!HdfSbufReadInt32(reply, &elemValue.value[0])) {
246 LOG_FUN_ERR("RenderGetVolume Failed to Get Volume sBuf!");
247 AudioBufReplyRecycle(sBuf, reply);
248 return HDF_FAILURE;
249 }
250 handleData->renderMode.ctlParam.volume = elemValue.value[0];
251 AudioBufReplyRecycle(sBuf, reply);
252 return ret;
253 }
254
AudioCtlRenderSetPauseBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)255 int32_t AudioCtlRenderSetPauseBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
256 {
257 #ifdef ALSA_MODE
258 return HDF_SUCCESS;
259 #endif
260 if (handleData == NULL || sBuf == NULL) {
261 LOG_FUN_ERR("RenderSetPauseBuf handleData or sBuf is NULL!");
262 return HDF_FAILURE;
263 }
264 uint32_t card = handleData->renderMode.hwInfo.card;
265 if (card >= AUDIO_SERVICE_MAX) {
266 LOG_FUN_ERR("RenderSetPauseBuf card is Error!");
267 return HDF_FAILURE;
268 }
269 struct AudioCtlElemValue elemValue;
270 elemValue.id.cardServiceName = g_audioLibRenderService[card];
271 elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
272 elemValue.id.itemName = "Main Playback Pause";
273 elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.pause;
274 if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) {
275 LOG_FUN_ERR("RenderSetPauseBuf pause Write Fail!");
276 return HDF_FAILURE;
277 }
278 if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) {
279 LOG_FUN_ERR("RenderSetPauseBuf iface Write Fail!");
280 return HDF_FAILURE;
281 }
282 if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) {
283 LOG_FUN_ERR("RenderSetPauseBuf cardServiceName Write Fail!");
284 return HDF_FAILURE;
285 }
286 if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) {
287 LOG_FUN_ERR("RenderSetPauseBuf itemName Write Fail!");
288 return HDF_FAILURE;
289 }
290 return HDF_SUCCESS;
291 }
292
AudioCtlRenderSetPauseStu(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)293 int32_t AudioCtlRenderSetPauseStu(const struct DevHandle *handle,
294 int cmdId, const struct AudioHwRenderParam *handleData)
295 {
296 #ifdef ALSA_MODE
297 return HDF_SUCCESS;
298 #endif
299 int32_t ret;
300
301 if (handle == NULL || handle->object == NULL || handleData == NULL) {
302 LOG_FUN_ERR("RenderSetPauseStu parameter is empty!");
303 return HDF_FAILURE;
304 }
305 struct HdfIoService *service = NULL;
306 struct HdfSBuf *reply = NULL;
307 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
308 if (sBuf == NULL) {
309 LOG_FUN_ERR("RenderSetPauseStu Failed to obtain sBuf");
310 return HDF_FAILURE;
311 }
312 ret = AudioCtlRenderSetPauseBuf(sBuf, handleData);
313 if (ret < 0) {
314 LOG_FUN_ERR("RenderSetPauseStu Failed to Set Pause sBuf!");
315 AudioBufReplyRecycle(sBuf, NULL);
316 return ret;
317 }
318 service = (struct HdfIoService *)handle->object;
319 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
320 LOG_FUN_ERR("RenderSetPauseStu Service is NULL!");
321 AudioBufReplyRecycle(sBuf, NULL);
322 return HDF_FAILURE;
323 }
324 cmdId = handleData->renderMode.ctlParam.pause ?
325 AUDIO_DRV_PCM_IOCTRL_PAUSE : AUDIO_DRV_PCM_IOCTRL_RESUME;
326 ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply);
327 if (ret != HDF_SUCCESS) {
328 LOG_FUN_ERR("RenderSetPauseStu Failed to send service call!");
329 }
330 AudioBufReplyRecycle(sBuf, NULL);
331 return ret;
332 }
333
AudioCtlRenderSetMuteBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)334 int32_t AudioCtlRenderSetMuteBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
335 {
336 #ifdef ALSA_MODE
337 return HDF_SUCCESS;
338 #endif
339 if (handleData == NULL || sBuf == NULL) {
340 LOG_FUN_ERR("RenderSetMuteBuf handleData or sBuf is NULL!");
341 return HDF_FAILURE;
342 }
343 uint32_t card = handleData->renderMode.hwInfo.card;
344 if (card < 0 || card >= AUDIO_SERVICE_MAX) {
345 LOG_FUN_ERR("RenderSetMuteBuf card is Error!");
346 return HDF_FAILURE;
347 }
348 struct AudioCtlElemValue elemValue;
349 elemValue.id.cardServiceName = g_audioLibRenderService[card];
350 elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC;
351 elemValue.id.itemName = "Playback Mute";
352 elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.mute;
353 if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) {
354 LOG_FUN_ERR("RenderSetMuteBuf value[0] Write Fail!");
355 return HDF_FAILURE;
356 }
357 if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) {
358 LOG_FUN_ERR("RenderSetMuteBuf iface Write Fail!");
359 return HDF_FAILURE;
360 }
361 if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) {
362 LOG_FUN_ERR("RenderSetMuteBuf cardServiceName Write Fail!");
363 return HDF_FAILURE;
364 }
365 if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) {
366 LOG_FUN_ERR("RenderSetMuteBuf itemName Write Fail!");
367 return HDF_FAILURE;
368 }
369 return HDF_SUCCESS;
370 }
371
AudioCtlRenderSetMuteStu(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)372 int32_t AudioCtlRenderSetMuteStu(const struct DevHandle *handle,
373 int cmdId, const struct AudioHwRenderParam *handleData)
374 {
375 #ifdef ALSA_MODE
376 return HDF_SUCCESS;
377 #endif
378 int32_t ret;
379
380 if (handle == NULL || handle->object == NULL || handleData == NULL) {
381 LOG_FUN_ERR("RenderSetMuteStu paras is NULL!");
382 return HDF_FAILURE;
383 }
384 struct HdfIoService *service = NULL;
385 struct HdfSBuf *reply = NULL;
386 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
387 if (sBuf == NULL) {
388 LOG_FUN_ERR("RenderSetMuteStu Failed to obtain sBuf");
389 return HDF_FAILURE;
390 }
391 ret = AudioCtlRenderSetMuteBuf(sBuf, handleData);
392 if (ret < 0) {
393 LOG_FUN_ERR("RenderSetMuteStu Failed to Set Mute sBuf!");
394 AudioBufReplyRecycle(sBuf, NULL);
395 return ret;
396 }
397 service = (struct HdfIoService *)handle->object;
398 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
399 LOG_FUN_ERR("RenderSetMuteStu Service is NULL!");
400 AudioBufReplyRecycle(sBuf, NULL);
401 return HDF_FAILURE;
402 }
403 cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM;
404 ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply);
405 if (ret != HDF_SUCCESS) {
406 LOG_FUN_ERR("RenderSetMuteStu Failed to send service call!");
407 }
408 AudioBufReplyRecycle(sBuf, NULL);
409 return ret;
410 }
411
AudioCtlRenderGetMuteSBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)412 int32_t AudioCtlRenderGetMuteSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
413 {
414 #ifdef ALSA_MODE
415 return HDF_SUCCESS;
416 #endif
417 if (handleData == NULL || sBuf == NULL) {
418 LOG_FUN_ERR("RenderGetMuteSBuf handleData or sBuf is NULL!");
419 return HDF_FAILURE;
420 }
421 uint32_t card = handleData->renderMode.hwInfo.card;
422 if (card >= AUDIO_SERVICE_MAX) {
423 LOG_FUN_ERR("RenderGetMuteSBuf card is Error!");
424 return HDF_FAILURE;
425 }
426 struct AudioCtlElemValue elemValue;
427 elemValue.id.cardServiceName = g_audioLibRenderService[card];
428 elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC;
429 elemValue.id.itemName = "Playback Mute";
430 if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) {
431 LOG_FUN_ERR("RenderGetMuteSBuf iface Write Fail!");
432 return HDF_FAILURE;
433 }
434 if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) {
435 LOG_FUN_ERR("RenderGetMuteSBuf cardServiceName Write Fail!");
436 return HDF_FAILURE;
437 }
438 if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) {
439 LOG_FUN_ERR("RenderGetMuteSBuf itemName Write Fail!");
440 return HDF_FAILURE;
441 }
442 return HDF_SUCCESS;
443 }
444
AudioCtlRenderGetMuteStu(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)445 int32_t AudioCtlRenderGetMuteStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
446 {
447 #ifdef ALSA_MODE
448 return HDF_SUCCESS;
449 #endif
450 int32_t ret;
451
452 if (handle == NULL || handle->object == NULL || handleData == NULL) {
453 LOG_FUN_ERR("RenderGetMuteStu paras is NULL!");
454 return HDF_FAILURE;
455 }
456 struct HdfIoService *service = NULL;
457 struct HdfSBuf *reply = NULL;
458 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
459 if (sBuf == NULL) {
460 LOG_FUN_ERR("RenderGetMuteStu Failed to obtain sBuf");
461 return HDF_FAILURE;
462 }
463 reply = AudioObtainHdfSBuf();
464 if (reply == NULL) {
465 LOG_FUN_ERR("RenderGetMuteStu Failed to obtain reply");
466 AudioBufReplyRecycle(sBuf, NULL);
467 return HDF_FAILURE;
468 }
469 ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData);
470 if (ret < 0) {
471 LOG_FUN_ERR("RenderGetMuteStu Failed to Get Mute sBuf!");
472 AudioBufReplyRecycle(sBuf, reply);
473 return ret;
474 }
475 service = (struct HdfIoService *)handle->object;
476 cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM;
477 ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
478 if (ret != HDF_SUCCESS) {
479 LOG_FUN_ERR("RenderGetMuteStu RenderDispatch Failed!");
480 AudioBufReplyRecycle(sBuf, reply);
481 return HDF_FAILURE;
482 }
483 struct AudioCtlElemValue muteValueStu;
484 (void)memset_s(&muteValueStu, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue));
485 if (!HdfSbufReadInt32(reply, &muteValueStu.value[0])) {
486 LOG_FUN_ERR("RenderGetMuteStu Failed to Get Volume sBuf!");
487 AudioBufReplyRecycle(sBuf, reply);
488 return HDF_FAILURE;
489 }
490 handleData->renderMode.ctlParam.mute = muteValueStu.value[0];
491 AudioBufReplyRecycle(sBuf, reply);
492 return ret;
493 }
494
AudioCtlRenderSetGainBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)495 int32_t AudioCtlRenderSetGainBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
496 {
497 #ifdef ALSA_MODE
498 return HDF_SUCCESS;
499 #endif
500 if (handleData == NULL || sBuf == NULL) {
501 LOG_FUN_ERR("RenderSetGainBuf handleData or sBuf is NULL!");
502 return HDF_FAILURE;
503 }
504 uint32_t card = handleData->renderMode.hwInfo.card;
505 if (card >= AUDIO_SERVICE_MAX) {
506 LOG_FUN_ERR("RenderSetGainBuf card is Error!");
507 return HDF_FAILURE;
508 }
509 struct AudioCtlElemValue elemValue;
510 elemValue.id.cardServiceName = g_audioLibRenderService[card];
511 elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN;
512 elemValue.id.itemName = "Mic Left Gain";
513 elemValue.value[0] = (int32_t)handleData->renderMode.ctlParam.audioGain.gain;
514 if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) {
515 LOG_FUN_ERR("RenderSetGainBuf value[0] Write Fail!");
516 return HDF_FAILURE;
517 }
518 if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) {
519 LOG_FUN_ERR("RenderSetGainBuf iface Write Fail!");
520 return HDF_FAILURE;
521 }
522 if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) {
523 LOG_FUN_ERR("RenderSetGainBuf cardServiceName Write Fail!");
524 return HDF_FAILURE;
525 }
526 if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) {
527 LOG_FUN_ERR("RenderSetGainBuf itemName Write Fail!");
528 return HDF_FAILURE;
529 }
530 return HDF_SUCCESS;
531 }
532
AudioCtlRenderSetGainStu(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)533 int32_t AudioCtlRenderSetGainStu(const struct DevHandle *handle,
534 int cmdId, const struct AudioHwRenderParam *handleData)
535 {
536 #ifdef ALSA_MODE
537 return HDF_SUCCESS;
538 #endif
539 int32_t ret;
540
541 if (handle == NULL || handle->object == NULL || handleData == NULL) {
542 LOG_FUN_ERR("RenderSetGainStu paras is NULL!");
543 return HDF_FAILURE;
544 }
545 struct HdfIoService *service = NULL;
546 struct HdfSBuf *reply = NULL;
547 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
548 if (sBuf == NULL) {
549 LOG_FUN_ERR("RenderSetGainStu Failed to obtain sBuf");
550 return HDF_FAILURE;
551 }
552 ret = AudioCtlRenderSetGainBuf(sBuf, handleData);
553 if (ret < 0) {
554 LOG_FUN_ERR("RenderSetGainStu Failed to Set Gain sBuf!");
555 AudioBufReplyRecycle(sBuf, NULL);
556 return ret;
557 }
558 service = (struct HdfIoService *)handle->object;
559 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
560 LOG_FUN_ERR("RenderSetGainStu Service is NULL!");
561 AudioBufReplyRecycle(sBuf, NULL);
562 return HDF_FAILURE;
563 }
564 cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM;
565 ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply);
566 if (ret != HDF_SUCCESS) {
567 LOG_FUN_ERR("RenderSetGainStu Failed to send service call!");
568 }
569 AudioBufReplyRecycle(sBuf, NULL);
570 return ret;
571 }
572
AudioCtlRenderGetGainSBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)573 int32_t AudioCtlRenderGetGainSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
574 {
575 #ifdef ALSA_MODE
576 return HDF_SUCCESS;
577 #endif
578 if (handleData == NULL || sBuf == NULL) {
579 LOG_FUN_ERR("RenderGetGainSBuf handleData or sBuf is NULL!");
580 return HDF_FAILURE;
581 }
582 uint32_t card = handleData->renderMode.hwInfo.card;
583 if (card >= AUDIO_SERVICE_MAX) {
584 LOG_FUN_ERR("RenderGetGainSBuf card is invalid!");
585 return HDF_FAILURE;
586 }
587 struct AudioCtlElemValue elemValue;
588 elemValue.id.cardServiceName = g_audioLibRenderService[card];
589 elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_GAIN;
590 elemValue.id.itemName = "Mic Left Gain";
591 if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) {
592 LOG_FUN_ERR("RenderGetGainSBuf iface Write Fail!");
593 return HDF_FAILURE;
594 }
595 if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) {
596 LOG_FUN_ERR("RenderGetGainSBuf cardServiceName Write Fail!");
597 return HDF_FAILURE;
598 }
599 if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) {
600 LOG_FUN_ERR("RenderGetGainSBuf itemName Write Fail!");
601 return HDF_FAILURE;
602 }
603 return HDF_SUCCESS;
604 }
605
AudioCtlRenderGetGainStu(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)606 int32_t AudioCtlRenderGetGainStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
607 {
608 #ifdef ALSA_MODE
609 return HDF_SUCCESS;
610 #endif
611 int32_t ret;
612
613 if (handle == NULL || handle->object == NULL || handleData == NULL) {
614 LOG_FUN_ERR("RenderGetGainStu paras is NULL!");
615 return HDF_FAILURE;
616 }
617 struct HdfIoService *service = NULL;
618 struct HdfSBuf *reply = NULL;
619 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
620 if (sBuf == NULL) {
621 LOG_FUN_ERR("RenderGetGainStu Failed to obtain sBuf");
622 return HDF_FAILURE;
623 }
624 reply = AudioObtainHdfSBuf();
625 if (reply == NULL) {
626 LOG_FUN_ERR("RenderGetGainStu Failed to obtain reply");
627 AudioBufReplyRecycle(sBuf, NULL);
628 return HDF_FAILURE;
629 }
630 ret = AudioCtlRenderGetGainSBuf(sBuf, handleData);
631 if (ret < 0) {
632 LOG_FUN_ERR("RenderGetGainStu ailed to Get Gain sBuf!");
633 AudioBufReplyRecycle(sBuf, reply);
634 return ret;
635 }
636 service = (struct HdfIoService *)handle->object;
637 cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM;
638 ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
639 if (ret != HDF_SUCCESS) {
640 LOG_FUN_ERR("Dispatch Fail!");
641 AudioBufReplyRecycle(sBuf, reply);
642 return HDF_FAILURE;
643 }
644 struct AudioCtlElemValue gainValueStu;
645 (void)memset_s(&gainValueStu, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue));
646 if (!HdfSbufReadInt32(reply, &gainValueStu.value[0])) {
647 LOG_FUN_ERR("Failed to Get Gain sBuf!");
648 AudioBufReplyRecycle(sBuf, reply);
649 return HDF_FAILURE;
650 }
651 handleData->renderMode.ctlParam.audioGain.gain = gainValueStu.value[0];
652 AudioBufReplyRecycle(sBuf, reply);
653 return ret;
654 }
655
AudioCtlRenderSceneSelectSBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData,const int32_t deviceIndex)656 int32_t AudioCtlRenderSceneSelectSBuf(struct HdfSBuf *sBuf,
657 const struct AudioHwRenderParam *handleData,
658 const int32_t deviceIndex)
659 {
660 #ifdef ALSA_MODE
661 return HDF_SUCCESS;
662 #endif
663 if (handleData == NULL || sBuf == NULL) {
664 LOG_FUN_ERR("RenderSceneSelectSBuf handleData or sBuf is NULL!");
665 return HDF_FAILURE;
666 }
667 if (deviceIndex < 0 || deviceIndex > PATHPLAN_COUNT - 1) {
668 LOG_FUN_ERR("deviceIndex is error!");
669 return HDF_FAILURE;
670 }
671 uint32_t card = handleData->renderMode.hwInfo.card;
672 if (card >= AUDIO_SERVICE_MAX) {
673 LOG_FUN_ERR("card is invalid!");
674 return HDF_FAILURE;
675 }
676 struct AudioCtlElemValue elemValue;
677 elemValue.id.cardServiceName = g_audioLibRenderService[card];
678 elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC;
679 elemValue.id.itemName =
680 handleData->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].deviceSwitch;
681 elemValue.value[0] =
682 handleData->renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[deviceIndex].value;
683 if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) {
684 LOG_FUN_ERR("RenderSceneSelectSBuf Write Fail!");
685 return HDF_FAILURE;
686 }
687 if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) {
688 LOG_FUN_ERR("RenderSceneSelectSBuf iface Write Fail!");
689 return HDF_FAILURE;
690 }
691 if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) {
692 LOG_FUN_ERR("RenderSceneSelectSBuf cardServiceName Write Fail!");
693 return HDF_FAILURE;
694 }
695 if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) {
696 LOG_FUN_ERR("RenderSceneSelectSBuf itemName Write Fail!");
697 return HDF_FAILURE;
698 }
699 return HDF_SUCCESS;
700 }
701
AudioCtlRenderSceneSelect(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)702 int32_t AudioCtlRenderSceneSelect(const struct DevHandle *handle,
703 int cmdId, const struct AudioHwRenderParam *handleData)
704 {
705 #ifdef ALSA_MODE
706 return HDF_SUCCESS;
707 #endif
708 int32_t index;
709 if (handle == NULL || handle->object == NULL || handleData == NULL) {
710 LOG_FUN_ERR("RenderSceneSelect paras is NULL!");
711 return HDF_FAILURE;
712 }
713 struct HdfIoService *service = NULL;
714 struct HdfSBuf *reply = NULL;
715 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
716 if (sBuf == NULL) {
717 LOG_FUN_ERR("RenderSceneSelect Failed to obtain sBuf");
718 return HDF_FAILURE;
719 }
720 service = (struct HdfIoService *)handle->object;
721 int32_t deviceNum = handleData->renderMode.hwInfo.pathSelect.deviceInfo.deviceNum;
722 if (deviceNum < AUDIO_MIN_DEVICENUM) {
723 LOG_FUN_ERR("AUDIO_MIN_ADAPTERNUM Failed!");
724 AudioBufReplyRecycle(sBuf, NULL);
725 return HDF_FAILURE;
726 }
727 cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM;
728 for (index = 0; index < deviceNum; index++) {
729 HdfSbufFlush(sBuf);
730 if (AudioCtlRenderSceneSelectSBuf(sBuf, handleData, index) < 0) {
731 LOG_FUN_ERR("AudioCtlRenderSceneSelectSBuf Failed!");
732 AudioBufReplyRecycle(sBuf, NULL);
733 return HDF_FAILURE;
734 }
735 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
736 LOG_FUN_ERR("Service is NULL!");
737 AudioBufReplyRecycle(sBuf, NULL);
738 return HDF_FAILURE;
739 }
740 if (service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply) < 0) {
741 LOG_FUN_ERR("Failed to send service call!");
742 AudioBufReplyRecycle(sBuf, NULL);
743 return HDF_FAILURE;
744 }
745 }
746 AudioBufReplyRecycle(sBuf, NULL);
747 return HDF_SUCCESS;
748 }
749
AudioCtlRenderGetVolThresholdSBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)750 int32_t AudioCtlRenderGetVolThresholdSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
751 {
752 #ifdef ALSA_MODE
753 return HDF_SUCCESS;
754 #endif
755 if (handleData == NULL || sBuf == NULL) {
756 LOG_FUN_ERR("RenderGetVolThresholdSBuf paras is NULL!");
757 return HDF_FAILURE;
758 }
759 uint32_t card = handleData->renderMode.hwInfo.card;
760 if (card >= AUDIO_SERVICE_MAX) {
761 LOG_FUN_ERR("RenderGetVolThresholdSBuf card is Invalid!");
762 return HDF_FAILURE;
763 }
764 struct AudioCtrlElemInfo elemInfo;
765 elemInfo.id.cardServiceName = g_audioLibRenderService[card];
766 elemInfo.id.iface = AUDIODRV_CTL_ELEM_IFACE_DAC;
767 elemInfo.id.itemName = "Main Playback Volume";
768 if (!HdfSbufWriteInt32(sBuf, elemInfo.id.iface)) {
769 LOG_FUN_ERR("RenderGetVolThresholdSBuf iface Write Fail!");
770 return HDF_FAILURE;
771 }
772 if (!HdfSbufWriteString(sBuf, elemInfo.id.cardServiceName)) {
773 LOG_FUN_ERR("RenderGetVolThresholdSBuf cardServiceName Write Fail!");
774 return HDF_FAILURE;
775 }
776 if (!HdfSbufWriteString(sBuf, elemInfo.id.itemName)) {
777 LOG_FUN_ERR("RenderGetVolThresholdSBuf itemName Write Fail!");
778 return HDF_FAILURE;
779 }
780 return HDF_SUCCESS;
781 }
782
AudioCtlRenderSceneGetGainThresholdSBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)783 int32_t AudioCtlRenderSceneGetGainThresholdSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
784 {
785 #ifdef ALSA_MODE
786 return HDF_SUCCESS;
787 #endif
788 if (handleData == NULL || sBuf == NULL) {
789 LOG_FUN_ERR("RenderSceneGetGainThresholdSBuf paras is NULL!");
790 return HDF_FAILURE;
791 }
792 uint32_t card = handleData->renderMode.hwInfo.card;
793 if (card >= AUDIO_SERVICE_MAX) {
794 LOG_FUN_ERR("RenderSceneGetGainThresholdSBuf card is Invalid!");
795 return HDF_FAILURE;
796 }
797 struct AudioCtrlElemInfo elemInfo;
798 elemInfo.id.cardServiceName = g_audioLibRenderService[card];
799 elemInfo.id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER;
800 elemInfo.id.itemName = "Mic Left Gain";
801 if (!HdfSbufWriteInt32(sBuf, elemInfo.id.iface)) {
802 LOG_FUN_ERR("RenderSceneGetGainThresholdSBuf iface Write Fail!");
803 return HDF_FAILURE;
804 }
805 if (!HdfSbufWriteString(sBuf, elemInfo.id.cardServiceName)) {
806 LOG_FUN_ERR("RenderSceneGetGainThresholdSBuf cardServiceName Write Fail!");
807 return HDF_FAILURE;
808 }
809 if (!HdfSbufWriteString(sBuf, elemInfo.id.itemName)) {
810 LOG_FUN_ERR("RenderSceneGetGainThresholdSBuf itemName Write Fail!");
811 return HDF_FAILURE;
812 }
813 return HDF_SUCCESS;
814 }
815
AudioCtlRenderSceneGetGainThreshold(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)816 int32_t AudioCtlRenderSceneGetGainThreshold(const struct DevHandle *handle,
817 int cmdId, struct AudioHwRenderParam *handleData)
818 {
819 #ifdef ALSA_MODE
820 return HDF_SUCCESS;
821 #endif
822 int32_t ret;
823
824 if (handle == NULL || handle->object == NULL || handleData == NULL) {
825 LOG_FUN_ERR("RenderSceneGetGainThreshold paras is NULL!");
826 return HDF_FAILURE;
827 }
828 struct HdfIoService *service = NULL;
829 struct HdfSBuf *reply = NULL;
830 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
831 if (sBuf == NULL) {
832 LOG_FUN_ERR("RenderSceneGetGainThreshold Failed to obtain sBuf");
833 return HDF_FAILURE;
834 }
835 reply = AudioObtainHdfSBuf();
836 if (reply == NULL) {
837 LOG_FUN_ERR("RenderSceneGetGainThreshold reply is NULL");
838 AudioBufReplyRecycle(sBuf, NULL);
839 return HDF_FAILURE;
840 }
841 ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData);
842 if (ret < 0) {
843 LOG_FUN_ERR("RenderSceneGetGainThreshold Get Threshold sBuf Fail!");
844 AudioBufReplyRecycle(sBuf, reply);
845 return ret;
846 }
847 service = (struct HdfIoService *)handle->object;
848 cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO - CTRL_NUM;
849 ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
850 if (ret != HDF_SUCCESS) {
851 AudioBufReplyRecycle(sBuf, reply);
852 return HDF_FAILURE;
853 }
854 struct AudioCtrlElemInfo gainThreshold;
855 (void)memset_s(&gainThreshold, sizeof(struct AudioCtrlElemInfo), 0, sizeof(struct AudioCtrlElemInfo));
856 if (!HdfSbufReadInt32(reply, &gainThreshold.type)) {
857 LOG_FUN_ERR("RenderSceneGetGainThreshold Failed to Get Volume sBuf!");
858 AudioBufReplyRecycle(sBuf, reply);
859 return HDF_FAILURE;
860 }
861 if (!HdfSbufReadInt32(reply, &gainThreshold.max)) {
862 LOG_FUN_ERR("RenderSceneGetGainThreshold Failed to Get Volume sBuf!");
863 AudioBufReplyRecycle(sBuf, reply);
864 return HDF_FAILURE;
865 }
866 handleData->renderMode.ctlParam.audioGain.gainMax = gainThreshold.max;
867 handleData->renderMode.ctlParam.audioGain.gainMin = 0;
868 AudioBufReplyRecycle(sBuf, reply);
869 return ret;
870 }
871
AudioCtlRenderGetVolThreshold(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)872 int32_t AudioCtlRenderGetVolThreshold(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
873 {
874 #ifdef ALSA_MODE
875 long long volMin = 0;
876 long long volMax = 0;
877 char *ctlName = "DACL Playback Volume";
878 ReadOutSoundCard();
879 (void)memset_s(&g_outDevInfo, sizeof(struct DevInfo), 0, sizeof(struct DevInfo));
880 GetOutDevInfo(SND_OUT_SOUND_CARD_SPEAKER, &g_outDevInfo);
881 MixerOpenLegacy(true, g_outDevInfo.card);
882 RouteGetVoiceMinMaxStep(&volMin, &volMax, ctlName, true);
883 handleData->renderMode.ctlParam.volThreshold.volMax = volMax;
884 handleData->renderMode.ctlParam.volThreshold.volMin = volMin;
885 return HDF_SUCCESS;
886 #endif
887 if (handle == NULL || handle->object == NULL || handleData == NULL) {
888 LOG_FUN_ERR("paras is NULL!");
889 return HDF_FAILURE;
890 }
891 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
892 if (sBuf == NULL) {
893 LOG_FUN_ERR("Failed to obtain sBuf");
894 return HDF_FAILURE;
895 }
896 struct HdfSBuf *reply = AudioObtainHdfSBuf();
897 if (reply == NULL) {
898 AudioBufReplyRecycle(sBuf, NULL);
899 return HDF_FAILURE;
900 }
901 int32_t ret = AudioCtlRenderGetVolThresholdSBuf(sBuf, handleData);
902 if (ret < 0) {
903 LOG_FUN_ERR("Get Threshold sBuf Fail!");
904 AudioBufReplyRecycle(sBuf, reply);
905 return ret;
906 }
907 struct HdfIoService *service = (struct HdfIoService *)handle->object;
908 cmdId = AUDIODRV_CTL_IOCTL_ELEM_INFO - CTRL_NUM;
909 ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
910 if (ret != HDF_SUCCESS) {
911 AudioBufReplyRecycle(sBuf, reply);
912 return HDF_FAILURE;
913 }
914 struct AudioCtrlElemInfo volThreshold;
915 if (AudioCtlGetVolThresholdRead(reply, &volThreshold) < 0) {
916 AudioBufReplyRecycle(sBuf, reply);
917 return HDF_FAILURE;
918 }
919 handleData->renderMode.ctlParam.volThreshold.volMax = volThreshold.max;
920 handleData->renderMode.ctlParam.volThreshold.volMin = volThreshold.min;
921 AudioBufReplyRecycle(sBuf, reply);
922 return ret;
923 }
924
AudioCtlRenderSetChannelModeBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)925 int32_t AudioCtlRenderSetChannelModeBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
926 {
927 #ifdef ALSA_MODE
928 return HDF_SUCCESS;
929 #endif
930 if (handleData == NULL || sBuf == NULL) {
931 LOG_FUN_ERR("RenderSetChannelModeBuf parameter is empty!");
932 return HDF_FAILURE;
933 }
934 uint32_t card = handleData->renderMode.hwInfo.card;
935 if (card >= AUDIO_SERVICE_MAX) {
936 LOG_FUN_ERR("RenderSetChannelModeBuf card is Error!");
937 return HDF_FAILURE;
938 }
939 struct AudioCtlElemValue elemValue;
940 elemValue.id.cardServiceName = g_audioLibRenderService[card];
941 elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO;
942 elemValue.id.itemName = "Render Channel Mode";
943 elemValue.value[0] = handleData->frameRenderMode.mode;
944 if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) {
945 LOG_FUN_ERR("RenderSetChannelModeBuf mode Write Fail!");
946 return HDF_FAILURE;
947 }
948 if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) {
949 LOG_FUN_ERR("RenderSetChannelModeBuf iface Write Fail!");
950 return HDF_FAILURE;
951 }
952 if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) {
953 LOG_FUN_ERR("RenderSetChannelModeBuf cardServiceName Write Fail!");
954 return HDF_FAILURE;
955 }
956 if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) {
957 LOG_FUN_ERR("RenderSetChannelModeBuf itemName Write Fail!");
958 return HDF_FAILURE;
959 }
960 return HDF_SUCCESS;
961 }
962
AudioCtlRenderSetChannelMode(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)963 int32_t AudioCtlRenderSetChannelMode(const struct DevHandle *handle,
964 int cmdId, const struct AudioHwRenderParam *handleData)
965 {
966 #ifdef ALSA_MODE
967 return HDF_SUCCESS;
968 #endif
969 int32_t ret;
970
971 if (handle == NULL || handle->object == NULL || handleData == NULL) {
972 LOG_FUN_ERR("RenderSetChannelMode paras is NULL!");
973 return HDF_FAILURE;
974 }
975 struct HdfIoService *service = NULL;
976 struct HdfSBuf *reply = NULL;
977 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
978 if (sBuf == NULL) {
979 LOG_FUN_ERR("RenderSetChannelMode Failed to obtain sBuf");
980 return HDF_FAILURE;
981 }
982 ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData);
983 if (ret < 0) {
984 LOG_FUN_ERR("RenderSetChannelMode Failed to Set ChannelMode sBuf!");
985 AudioBufReplyRecycle(sBuf, NULL);
986 return ret;
987 }
988 service = (struct HdfIoService *)handle->object;
989 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
990 LOG_FUN_ERR("RenderSetChannelMode Service is NULL!");
991 AudioBufReplyRecycle(sBuf, NULL);
992 return HDF_FAILURE;
993 }
994 cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM;
995 ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply);
996 if (ret != HDF_SUCCESS) {
997 LOG_FUN_ERR("RenderSetChannelMode Failed to send service call!");
998 }
999 AudioBufReplyRecycle(sBuf, NULL);
1000 return ret;
1001 }
1002
AudioCtlRenderGetChannelModeSBuf(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)1003 int32_t AudioCtlRenderGetChannelModeSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
1004 {
1005 #ifdef ALSA_MODE
1006 return HDF_SUCCESS;
1007 #endif
1008 if (handleData == NULL || sBuf == NULL) {
1009 LOG_FUN_ERR("RenderGetChannelModeSBuf parameter is empty!");
1010 return HDF_FAILURE;
1011 }
1012 uint32_t card = handleData->renderMode.hwInfo.card;
1013 if (card >= AUDIO_SERVICE_MAX) {
1014 LOG_FUN_ERR("RenderGetChannelModeSBuf card is Error!");
1015 return HDF_FAILURE;
1016 }
1017 struct AudioCtlElemValue elemValue;
1018 elemValue.id.cardServiceName = g_audioLibRenderService[card];
1019 elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_AIAO;
1020 elemValue.id.itemName = "Render Channel Mode";
1021 if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) {
1022 LOG_FUN_ERR("RenderGetChannelModeSBuf iface Write Fail!");
1023 return HDF_FAILURE;
1024 }
1025 if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) {
1026 LOG_FUN_ERR("RenderGetChannelModeSBuf cardServiceName Write Fail!");
1027 return HDF_FAILURE;
1028 }
1029 if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) {
1030 LOG_FUN_ERR("RenderGetChannelModeSBuf itemName Write Fail!");
1031 return HDF_FAILURE;
1032 }
1033 return HDF_SUCCESS;
1034 }
1035
AudioCtlRenderGetChannelMode(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)1036 int32_t AudioCtlRenderGetChannelMode(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
1037 {
1038 #ifdef ALSA_MODE
1039 return HDF_SUCCESS;
1040 #endif
1041 int32_t ret;
1042
1043 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1044 LOG_FUN_ERR("RenderGetChannelMode paras is NULL!");
1045 return HDF_FAILURE;
1046 }
1047 struct HdfIoService *service = NULL;
1048 struct HdfSBuf *reply = NULL;
1049 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
1050 if (sBuf == NULL) {
1051 LOG_FUN_ERR("RenderGetChannelMode Failed to obtain sBuf");
1052 return HDF_FAILURE;
1053 }
1054 reply = AudioObtainHdfSBuf();
1055 if (reply == NULL) {
1056 LOG_FUN_ERR("RenderGetChannelMode Failed to obtain reply");
1057 AudioBufReplyRecycle(sBuf, NULL);
1058 return HDF_FAILURE;
1059 }
1060 ret = AudioCtlRenderGetChannelModeSBuf(sBuf, handleData);
1061 if (ret < 0) {
1062 LOG_FUN_ERR("RenderGetChannelMode Failed to Get Channel Mode sBuf!");
1063 AudioBufReplyRecycle(sBuf, reply);
1064 return ret;
1065 }
1066 service = (struct HdfIoService *)handle->object;
1067 handleData->frameRenderMode.mode = 1;
1068 cmdId = AUDIODRV_CTL_IOCTL_ELEM_READ - CTRL_NUM;
1069 ret = AudioServiceDispatch(service, cmdId, sBuf, reply);
1070 if (ret != HDF_SUCCESS) {
1071 AudioBufReplyRecycle(sBuf, reply);
1072 return HDF_FAILURE;
1073 }
1074 struct AudioCtlElemValue elemValue;
1075 (void)memset_s(&elemValue, sizeof(struct AudioCtlElemValue), 0, sizeof(struct AudioCtlElemValue));
1076 if (!HdfSbufReadInt32(reply, &elemValue.value[0])) {
1077 LOG_FUN_ERR("Failed to Get ChannelMode sBuf!");
1078 AudioBufReplyRecycle(sBuf, reply);
1079 return HDF_FAILURE;
1080 }
1081 handleData->frameRenderMode.mode = (enum AudioChannelMode)elemValue.value[0];
1082 AudioBufReplyRecycle(sBuf, reply);
1083 return ret;
1084 }
1085
AudioCtlRenderSetAcodecSBuf(struct HdfSBuf * sBuf,const char * codec,int enable,enum AudioServiceNameType serviceNameMode)1086 int32_t AudioCtlRenderSetAcodecSBuf(struct HdfSBuf *sBuf, const char *codec,
1087 int enable, enum AudioServiceNameType serviceNameMode)
1088 {
1089 #ifdef ALSA_MODE
1090 return HDF_SUCCESS;
1091 #endif
1092 if (sBuf == NULL) {
1093 LOG_FUN_ERR("handleData or sBuf is NULL!");
1094 return HDF_FAILURE;
1095 }
1096 if (serviceNameMode >= AUDIO_SERVICE_MAX) {
1097 LOG_FUN_ERR("serviceNameMode is fail!");
1098 return HDF_FAILURE;
1099 }
1100 struct AudioCtlElemValue elemValue;
1101 elemValue.id.cardServiceName = g_audioLibRenderService[serviceNameMode];
1102 elemValue.id.iface = AUDIODRV_CTL_ELEM_IFACE_ACODEC;
1103 elemValue.id.itemName = codec;
1104 elemValue.value[0] = enable;
1105 if (!HdfSbufWriteInt32(sBuf, elemValue.value[0])) {
1106 LOG_FUN_ERR("RenderSetAcodecSBuf value Write Fail!");
1107 return HDF_FAILURE;
1108 }
1109 if (!HdfSbufWriteInt32(sBuf, elemValue.id.iface)) {
1110 LOG_FUN_ERR("RenderSetAcodecSBuf iface Write Fail!");
1111 return HDF_FAILURE;
1112 }
1113 if (!HdfSbufWriteString(sBuf, elemValue.id.cardServiceName)) {
1114 LOG_FUN_ERR("RenderSetAcodecSBuf cardServiceName Write Fail!");
1115 return HDF_FAILURE;
1116 }
1117 if (!HdfSbufWriteString(sBuf, elemValue.id.itemName)) {
1118 LOG_FUN_ERR("RenderSetAcodecSBuf itemName Write Fail!");
1119 return HDF_FAILURE;
1120 }
1121 return HDF_SUCCESS;
1122 }
1123
AudioCtlRenderChangeInAcodec(struct HdfIoService * service,const char * codecName,struct HdfSBuf * sBuf,const int32_t status,int cmdId)1124 int32_t AudioCtlRenderChangeInAcodec(struct HdfIoService *service,
1125 const char *codecName, struct HdfSBuf *sBuf, const int32_t status, int cmdId)
1126 {
1127 #ifdef ALSA_MODE
1128 return HDF_SUCCESS;
1129 #endif
1130 enum AudioServiceNameType serviceNameMode;
1131 if (service == NULL || sBuf == NULL) {
1132 LOG_FUN_ERR("service or sBuf is NULL!");
1133 return HDF_FAILURE;
1134 }
1135 if (cmdId == AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT) {
1136 serviceNameMode = AUDIO_SERVICE_OUT;
1137 } else {
1138 serviceNameMode = AUDIO_SERVICE_IN;
1139 }
1140 if (AudioCtlRenderSetAcodecSBuf(sBuf, codecName, status, serviceNameMode)) {
1141 return HDF_FAILURE;
1142 }
1143 cmdId = AUDIODRV_CTL_IOCTL_ELEM_WRITE - CTRL_NUM;
1144 return (AudioServiceDispatch(service, cmdId, sBuf, NULL));
1145 }
1146
AudioCtlRenderSetAcodecMode(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)1147 int32_t AudioCtlRenderSetAcodecMode(const struct DevHandle *handle,
1148 int cmdId, const struct AudioHwRenderParam *handleData)
1149 {
1150 #ifdef ALSA_MODE
1151 return HDF_SUCCESS;
1152 #endif
1153 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1154 LOG_FUN_ERR("paras is NULL!");
1155 return HDF_FAILURE;
1156 }
1157 struct HdfIoService *service = NULL;
1158 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
1159 if (sBuf == NULL) {
1160 LOG_FUN_ERR("Failed to obtain sBuf");
1161 return HDF_FAILURE;
1162 }
1163 service = (struct HdfIoService *)handle->object;
1164 if (cmdId == AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN) {
1165 LOG_PARA_INFO("****Acodec is In****");
1166 /* enable Internally Codec */
1167 HdfSbufFlush(sBuf);
1168 if (AudioCtlRenderChangeInAcodec(service, AUDIODRV_CTL_INTERNAL_CODEC_STR,
1169 sBuf, AUDIODRV_CTL_INTERNAL_ACODEC_ENABLE, cmdId)) {
1170 AudioBufReplyRecycle(sBuf, NULL);
1171 return HDF_FAILURE;
1172 }
1173 } else if (cmdId == AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT) {
1174 LOG_PARA_INFO("****Acodec is Out****");
1175 /* enable External Codec */
1176 HdfSbufFlush(sBuf);
1177 if (AudioCtlRenderChangeInAcodec(service, AUDIODRV_CTL_EXTERN_CODEC_STR,
1178 sBuf, AUDIODRV_CTL_EXTERN_ACODEC_ENABLE, cmdId)) {
1179 AudioBufReplyRecycle(sBuf, NULL);
1180 return HDF_FAILURE;
1181 }
1182 } else {
1183 AudioBufReplyRecycle(sBuf, NULL);
1184 return HDF_FAILURE;
1185 }
1186 AudioBufReplyRecycle(sBuf, NULL);
1187 return HDF_SUCCESS;
1188 }
1189
AudioInterfaceLibCtlRender(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)1190 int32_t AudioInterfaceLibCtlRender(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData)
1191 {
1192 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1193 LOG_FUN_ERR("paras is NULL!");
1194 return HDF_FAILURE;
1195 }
1196 if (cmdId < AUDIODRV_CTL_IOCTL_ELEM_INFO || cmdId > AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ) {
1197 LOG_FUN_ERR("cmdId Not Supported!");
1198 return HDF_FAILURE;
1199 }
1200 switch (cmdId) {
1201 case AUDIODRV_CTL_IOCTL_ELEM_READ:
1202 return (AudioCtlRenderGetVolume(handle, cmdId, handleData));
1203 case AUDIODRV_CTL_IOCTL_ELEM_WRITE:
1204 return (AudioCtlRenderSetVolume(handle, cmdId, handleData));
1205 case AUDIODRV_CTL_IOCTL_MUTE_READ:
1206 return (AudioCtlRenderGetMuteStu(handle, cmdId, handleData));
1207 case AUDIODRV_CTL_IOCTL_MUTE_WRITE:
1208 return (AudioCtlRenderSetMuteStu(handle, cmdId, handleData));
1209 case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ:
1210 return (AudioCtlRenderGetChannelMode(handle, cmdId, handleData));
1211 case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE:
1212 return (AudioCtlRenderSetChannelMode(handle, cmdId, handleData));
1213 case AUDIODRV_CTL_IOCTL_GAIN_WRITE:
1214 return (AudioCtlRenderSetGainStu(handle, cmdId, handleData));
1215 case AUDIODRV_CTL_IOCTL_GAIN_READ:
1216 return (AudioCtlRenderGetGainStu(handle, cmdId, handleData));
1217 case AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE:
1218 return (AudioCtlRenderSceneSelect(handle, cmdId, handleData));
1219 case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ:
1220 return (AudioCtlRenderSceneGetGainThreshold(handle, cmdId, handleData));
1221 case AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN:
1222 case AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT:
1223 return (AudioCtlRenderSetAcodecMode(handle, cmdId, handleData));
1224 case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ:
1225 return (AudioCtlRenderGetVolThreshold(handle, cmdId, handleData));
1226 default:
1227 LOG_FUN_ERR("Output Mode not support!");
1228 break;
1229 }
1230 return HDF_FAILURE;
1231 }
1232
ParamsSbufWriteBuffer(struct HdfSBuf * sBuf)1233 int32_t ParamsSbufWriteBuffer(struct HdfSBuf *sBuf)
1234 {
1235 #ifdef ALSA_MODE
1236 return HDF_SUCCESS;
1237 #endif
1238 if (!HdfSbufWriteUint32(sBuf, (uint32_t)g_hwParams.streamType)) {
1239 return HDF_FAILURE;
1240 }
1241 if (!HdfSbufWriteUint32(sBuf, g_hwParams.channels)) {
1242 return HDF_FAILURE;
1243 }
1244 if (!HdfSbufWriteUint32(sBuf, g_hwParams.rate)) {
1245 return HDF_FAILURE;
1246 }
1247 if (!HdfSbufWriteUint32(sBuf, g_hwParams.periodSize)) {
1248 return HDF_FAILURE;
1249 }
1250 if (!HdfSbufWriteUint32(sBuf, g_hwParams.periodCount)) {
1251 return HDF_FAILURE;
1252 }
1253 if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.format))) {
1254 return HDF_FAILURE;
1255 }
1256 if (!HdfSbufWriteString(sBuf, g_hwParams.cardServiceName)) {
1257 return HDF_FAILURE;
1258 }
1259 if (!HdfSbufWriteUint32(sBuf, g_hwParams.period)) {
1260 return HDF_FAILURE;
1261 }
1262 if (!HdfSbufWriteUint32(sBuf, g_hwParams.frameSize)) {
1263 return HDF_FAILURE;
1264 }
1265 if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.isBigEndian))) {
1266 return HDF_FAILURE;
1267 }
1268 if (!HdfSbufWriteUint32(sBuf, (uint32_t)(g_hwParams.isSignedData))) {
1269 return HDF_FAILURE;
1270 }
1271 if (!HdfSbufWriteUint32(sBuf, g_hwParams.startThreshold)) {
1272 return HDF_FAILURE;
1273 }
1274 if (!HdfSbufWriteUint32(sBuf, g_hwParams.stopThreshold)) {
1275 return HDF_FAILURE;
1276 }
1277 if (!HdfSbufWriteUint32(sBuf, g_hwParams.silenceThreshold)) {
1278 return HDF_FAILURE;
1279 }
1280 return HDF_SUCCESS;
1281 }
1282
FrameSbufWriteBuffer(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)1283 int32_t FrameSbufWriteBuffer(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
1284 {
1285 #ifdef ALSA_MODE
1286 if (!pcm) {
1287 int bits;
1288 if (g_hwParams.format == AUDIO_FORMAT_PCM_8_BIT) {
1289 bits = TINYALSAPCM_8_BIT;
1290 } else if (g_hwParams.format == AUDIO_FORMAT_PCM_16_BIT) {
1291 bits = TINYALSAPCM_16_BIT;
1292 } else if (g_hwParams.format == AUDIO_FORMAT_PCM_24_BIT) {
1293 bits = TINYALSAPCM_24_BIT;
1294 } else if (g_hwParams.format == AUDIO_FORMAT_PCM_32_BIT) {
1295 bits = TINYALSAPCM_32_BIT;
1296 } else {
1297 bits = TINYALSAPCM_16_BIT;
1298 }
1299 ReadOutSoundCard();
1300 (void)memset_s(&g_outDevInfo, sizeof(struct DevInfo), 0, sizeof(struct DevInfo));
1301 GetOutDevInfo(SND_OUT_SOUND_CARD_SPEAKER, &g_outDevInfo);
1302 struct PcmRenderParam param;
1303 (void)memset_s(¶m, sizeof(param), 0, sizeof(param));
1304 param.card = g_outDevInfo.card;
1305 param.device = g_outDevInfo.device;
1306 param.channels = g_hwParams.channels;
1307 param.rate = g_hwParams.rate;
1308 param.bits = bits;
1309 param.periodSize = g_hwParams.periodSize / 4; // Because the data frame size is limited to 16K,periodSize/4.
1310 param.periodCount = g_hwParams.periodCount / 2; // Because the data frame size is limited to 16K,periodcount/2
1311 RenderSample(&pcm, ¶m);
1312 RoutePcmCardOpen(g_outDevInfo.card, DEV_OUT_SPEAKER_HEADPHONE_NORMAL_ROUTE);
1313 }
1314 if (pcm) {
1315 pcm_write(pcm, handleData->frameRenderMode.buffer, handleData->frameRenderMode.bufferSize);
1316 return HDF_SUCCESS;
1317 } else {
1318 return HDF_FAILURE;
1319 }
1320 #endif
1321 if (sBuf == NULL || handleData == NULL || handleData->frameRenderMode.buffer == NULL) {
1322 return HDF_FAILURE;
1323 }
1324 if (!HdfSbufWriteUint32(sBuf, (uint32_t)(handleData->frameRenderMode.bufferFrameSize))) {
1325 return HDF_FAILURE;
1326 }
1327 if (!HdfSbufWriteBuffer(sBuf, handleData->frameRenderMode.buffer,
1328 (uint32_t)handleData->frameRenderMode.bufferSize)) {
1329 return HDF_FAILURE;
1330 }
1331 return HDF_SUCCESS;
1332 }
1333
AudioOutputRenderHwParams(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)1334 int32_t AudioOutputRenderHwParams(const struct DevHandle *handle,
1335 int cmdId, const struct AudioHwRenderParam *handleData)
1336 {
1337 #ifndef ALSA_MODE
1338 int32_t ret;
1339 struct HdfIoService *service = NULL;
1340 #else
1341 int32_t ret = HDF_SUCCESS;
1342 #endif
1343 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1344 LOG_FUN_ERR("The parameter is empty");
1345 return HDF_FAILURE;
1346 }
1347 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
1348 if (sBuf == NULL) {
1349 return HDF_FAILURE;
1350 }
1351 if (SetHwParams(handleData) < 0) {
1352 AudioBufReplyRecycle(sBuf, NULL);
1353 return HDF_FAILURE;
1354 }
1355 if (ParamsSbufWriteBuffer(sBuf)) {
1356 AudioBufReplyRecycle(sBuf, NULL);
1357 return HDF_FAILURE;
1358 }
1359
1360 #ifndef ALSA_MODE
1361 service = (struct HdfIoService *)handle->object;
1362 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1363 LOG_FUN_ERR("The pointer is null!");
1364 AudioBufReplyRecycle(sBuf, NULL);
1365 return HDF_FAILURE;
1366 }
1367 ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL);
1368 if (ret != HDF_SUCCESS) {
1369 LOG_FUN_ERR("Failed to send service call!");
1370 }
1371 #endif
1372 AudioBufReplyRecycle(sBuf, NULL);
1373 return ret;
1374 }
1375
AudioCallbackModeStatus(const struct AudioHwRenderParam * handleData,enum AudioCallbackType callbackType)1376 int32_t AudioCallbackModeStatus(const struct AudioHwRenderParam *handleData,
1377 enum AudioCallbackType callbackType)
1378 {
1379 if (handleData == NULL) {
1380 return HDF_FAILURE;
1381 }
1382 bool callBackStatus = handleData->renderMode.hwInfo.callBackEnable;
1383 if (callBackStatus) {
1384 handleData->frameRenderMode.callbackProcess(handleData->frameRenderMode.renderhandle, callbackType);
1385 }
1386 return HDF_SUCCESS;
1387 }
1388
AudioOutputRenderWriteFrame(struct HdfIoService * service,int cmdId,struct HdfSBuf * sBuf,struct HdfSBuf * reply,const struct AudioHwRenderParam * handleData)1389 int32_t AudioOutputRenderWriteFrame(struct HdfIoService *service,
1390 int cmdId, struct HdfSBuf *sBuf, struct HdfSBuf *reply, const struct AudioHwRenderParam *handleData)
1391 {
1392 #ifdef ALSA_MODE
1393 return HDF_SUCCESS;
1394 #endif
1395 int32_t ret;
1396 int32_t tryNum = 50; // try send sBuf 50 count
1397 uint32_t buffStatus = 0;
1398 if (service == NULL || sBuf == NULL || reply == NULL || handleData == NULL) {
1399 return HDF_FAILURE;
1400 }
1401 if (service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1402 return HDF_FAILURE;
1403 }
1404 do {
1405 ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, reply);
1406 if (ret != HDF_SUCCESS) {
1407 LOG_FUN_ERR("Failed to send service call!");
1408 return ret;
1409 }
1410 if (!HdfSbufReadUint32(reply, &buffStatus)) {
1411 LOG_FUN_ERR("Failed to Get buffStatus!");
1412 return HDF_FAILURE;
1413 }
1414 if (buffStatus == CIR_BUFF_FULL) {
1415 LOG_PARA_INFO("Cir buff fulled wait 10ms");
1416 (void)AudioCallbackModeStatus(handleData, AUDIO_RENDER_FULL);
1417 tryNum--;
1418 usleep(AUDIO_WAIT_DELAY);
1419 continue;
1420 }
1421 break;
1422 } while (tryNum > 0);
1423 AudioBufReplyRecycle(sBuf, reply);
1424 if (tryNum > 0) {
1425 (void)AudioCallbackModeStatus(handleData, AUDIO_NONBLOCK_WRITE_COMPELETED);
1426 return HDF_SUCCESS;
1427 } else {
1428 (void)AudioCallbackModeStatus(handleData, AUDIO_ERROR_OCCUR);
1429 LOG_FUN_ERR("Out of tryNum!");
1430 return HDF_FAILURE;
1431 }
1432 }
1433
1434 #ifdef ALSA_MODE
TinyAlsaAudioOutputRenderWrite(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)1435 int32_t TinyAlsaAudioOutputRenderWrite(const struct DevHandle *handle,
1436 int cmdId, const struct AudioHwRenderParam *handleData)
1437 {
1438 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1439 return HDF_FAILURE;
1440 }
1441 size_t sbufSize = handleData->frameRenderMode.bufferSize + AUDIO_SBUF_EXTEND;
1442 struct HdfSBuf *sBuf = HdfSbufTypedObtainCapacity(SBUF_RAW, sbufSize);
1443 if (sBuf == NULL) {
1444 LOG_FUN_ERR("Get sBuf Fail");
1445 return HDF_FAILURE;
1446 }
1447 struct HdfSBuf *reply = AudioObtainHdfSBuf();
1448 if (reply == NULL) {
1449 LOG_FUN_ERR("reply is empty");
1450 HdfSbufRecycle(sBuf);
1451 return HDF_FAILURE;
1452 }
1453 if (FrameSbufWriteBuffer(sBuf, handleData)) {
1454 AudioBufReplyRecycle(sBuf, reply);
1455 return HDF_FAILURE;
1456 }
1457 return HDF_SUCCESS;
1458 }
1459 #endif
1460
AudioOutputRenderWrite(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)1461 int32_t AudioOutputRenderWrite(const struct DevHandle *handle,
1462 int cmdId, const struct AudioHwRenderParam *handleData)
1463 {
1464 #ifdef ALSA_MODE
1465 int32_t ret = TinyAlsaAudioOutputRenderWrite(handle, cmdId, handleData);
1466 if (ret == HDF_FAILURE) {
1467 return HDF_FAILURE;
1468 }
1469 #else
1470 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1471 return HDF_FAILURE;
1472 }
1473 struct HdfIoService *service = NULL;
1474 size_t sbufSize = (size_t)handleData->frameRenderMode.bufferSize + AUDIO_SBUF_EXTEND;
1475 struct HdfSBuf *sBuf = HdfSbufTypedObtainCapacity(SBUF_RAW, sbufSize);
1476 if (sBuf == NULL) {
1477 LOG_FUN_ERR("Get sBuf Fail");
1478 return HDF_FAILURE;
1479 }
1480 struct HdfSBuf *reply = AudioObtainHdfSBuf();
1481 if (reply == NULL) {
1482 LOG_FUN_ERR("reply is empty");
1483 HdfSbufRecycle(sBuf);
1484 return HDF_FAILURE;
1485 }
1486 if (FrameSbufWriteBuffer(sBuf, handleData)) {
1487 AudioBufReplyRecycle(sBuf, reply);
1488 return HDF_FAILURE;
1489 }
1490 service = (struct HdfIoService *)handle->object;
1491 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1492 LOG_FUN_ERR("Service is NULL!");
1493 AudioBufReplyRecycle(sBuf, reply);
1494 return HDF_FAILURE;
1495 }
1496 int32_t ret = AudioOutputRenderWriteFrame(service, cmdId, sBuf, reply, handleData);
1497 if (ret != 0) {
1498 LOG_FUN_ERR("AudioOutputRenderWriteFrame is Fail!");
1499 return HDF_FAILURE;
1500 }
1501 #endif
1502 return HDF_SUCCESS;
1503 }
1504
AudioOutputRenderStartPrepare(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)1505 int32_t AudioOutputRenderStartPrepare(const struct DevHandle *handle,
1506 int cmdId, const struct AudioHwRenderParam *handleData)
1507 {
1508 #ifdef ALSA_MODE
1509 return HDF_SUCCESS;
1510 #endif
1511 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1512 return HDF_FAILURE;
1513 }
1514 int32_t ret;
1515 struct HdfIoService *service = NULL;
1516 service = (struct HdfIoService *)handle->object;
1517 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1518 LOG_FUN_ERR("RenderStartPrepare Service is NULL!");
1519 return HDF_FAILURE;
1520 }
1521 ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, NULL);
1522 if (ret != HDF_SUCCESS) {
1523 LOG_FUN_ERR("RenderStartPrepare Failed to send service call cmdId = %d!", cmdId);
1524 return ret;
1525 }
1526 return HDF_SUCCESS;
1527 }
1528
AudioOutputRenderOpen(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)1529 int32_t AudioOutputRenderOpen(const struct DevHandle *handle,
1530 int cmdId, const struct AudioHwRenderParam *handleData)
1531 {
1532 #ifdef ALSA_MODE
1533 return HDF_SUCCESS;
1534 #endif
1535 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1536 return HDF_FAILURE;
1537 }
1538 int32_t ret;
1539 struct HdfIoService *service = NULL;
1540 service = (struct HdfIoService *)handle->object;
1541 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1542 LOG_FUN_ERR("RenderStartPrepare Service is NULL!");
1543 return HDF_FAILURE;
1544 }
1545 uint32_t card = handleData->renderMode.hwInfo.card;
1546 if (card >= AUDIO_SERVICE_MAX) {
1547 LOG_FUN_ERR("card is Error!");
1548 return HDF_FAILURE;
1549 }
1550 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
1551 if (sBuf == NULL) {
1552 return HDF_FAILURE;
1553 }
1554 if (!HdfSbufWriteString(sBuf, g_audioLibRenderService[card])) {
1555 AudioBufReplyRecycle(sBuf, NULL);
1556 return HDF_FAILURE;
1557 }
1558 ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL);
1559 if (ret != HDF_SUCCESS) {
1560 LOG_FUN_ERR("RenderStartPrepare Failed to send service call cmdId = %d!", cmdId);
1561 }
1562 AudioBufReplyRecycle(sBuf, NULL);
1563 return ret;
1564 }
1565
AudioOutputRenderStop(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)1566 int32_t AudioOutputRenderStop(const struct DevHandle *handle,
1567 int cmdId, const struct AudioHwRenderParam *handleData)
1568 {
1569 #ifdef ALSA_MODE
1570 if (pcm) {
1571 pcm_close(pcm);
1572 pcm = NULL;
1573 }
1574 RoutePcmClose(DEV_OFF_PLAYBACK_OFF_ROUTE);
1575 return HDF_SUCCESS;
1576 #endif
1577 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1578 return HDF_FAILURE;
1579 }
1580 struct HdfIoService *service = NULL;
1581 service = (struct HdfIoService *)handle->object;
1582 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1583 LOG_FUN_ERR("RenderStop Service is NULL!");
1584 return HDF_FAILURE;
1585 }
1586 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
1587 if (sBuf == NULL) {
1588 return HDF_FAILURE;
1589 }
1590 if (!HdfSbufWriteUint32(sBuf, handleData->renderMode.ctlParam.turnStandbyStatus)) {
1591 AudioBufReplyRecycle(sBuf, NULL);
1592 return HDF_FAILURE;
1593 }
1594 int32_t ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL);
1595 if (ret != HDF_SUCCESS) {
1596 LOG_FUN_ERR("RenderStop Failed to send service call!");
1597 AudioBufReplyRecycle(sBuf, NULL);
1598 return ret;
1599 }
1600 AudioBufReplyRecycle(sBuf, NULL);
1601 return HDF_SUCCESS;
1602 }
1603
MmapDescWriteBuffer(struct HdfSBuf * sBuf,const struct AudioHwRenderParam * handleData)1604 int32_t MmapDescWriteBuffer(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData)
1605 {
1606 #ifdef ALSA_MODE
1607 return HDF_SUCCESS;
1608 #endif
1609 if (sBuf == NULL || handleData == NULL) {
1610 return HDF_FAILURE;
1611 }
1612 uint64_t mmapAddr = (uint64_t)(uintptr_t)(handleData->frameRenderMode.mmapBufDesc.memoryAddress);
1613 if (!HdfSbufWriteUint64(sBuf, mmapAddr)) {
1614 return HDF_FAILURE;
1615 }
1616 if (!HdfSbufWriteInt32(sBuf, handleData->frameRenderMode.mmapBufDesc.memoryFd)) {
1617 return HDF_FAILURE;
1618 }
1619 if (!HdfSbufWriteInt32(sBuf, handleData->frameRenderMode.mmapBufDesc.totalBufferFrames)) {
1620 return HDF_FAILURE;
1621 }
1622 if (!HdfSbufWriteInt32(sBuf, handleData->frameRenderMode.mmapBufDesc.transferFrameSize)) {
1623 return HDF_FAILURE;
1624 }
1625 if (!HdfSbufWriteInt32(sBuf, handleData->frameRenderMode.mmapBufDesc.isShareable)) {
1626 return HDF_FAILURE;
1627 }
1628 if (!HdfSbufWriteUint32(sBuf, handleData->frameRenderMode.mmapBufDesc.offset)) {
1629 return HDF_FAILURE;
1630 }
1631 return HDF_SUCCESS;
1632 }
1633
AudioOutputRenderReqMmapBuffer(const struct DevHandle * handle,int cmdId,const struct AudioHwRenderParam * handleData)1634 int32_t AudioOutputRenderReqMmapBuffer(const struct DevHandle *handle,
1635 int cmdId, const struct AudioHwRenderParam *handleData)
1636 {
1637 #ifdef ALSA_MODE
1638 return HDF_SUCCESS;
1639 #endif
1640 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1641 return HDF_FAILURE;
1642 }
1643 struct HdfIoService *service = NULL;
1644 int32_t ret;
1645 struct HdfSBuf *sBuf = AudioObtainHdfSBuf();
1646 if (sBuf == NULL) {
1647 return HDF_FAILURE;
1648 }
1649 if (MmapDescWriteBuffer(sBuf, handleData)) {
1650 AudioBufReplyRecycle(sBuf, NULL);
1651 return HDF_FAILURE;
1652 }
1653 service = (struct HdfIoService *)handle->object;
1654 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1655 AudioBufReplyRecycle(sBuf, NULL);
1656 LOG_FUN_ERR("Failed to send service call!");
1657 return HDF_FAILURE;
1658 }
1659 ret = service->dispatcher->Dispatch(&service->object, cmdId, sBuf, NULL);
1660 if (ret != HDF_SUCCESS) {
1661 AudioBufReplyRecycle(sBuf, NULL);
1662 return HDF_FAILURE;
1663 }
1664 AudioBufReplyRecycle(sBuf, NULL);
1665 return HDF_SUCCESS;
1666 }
1667
AudioOutputRenderGetMmapPosition(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)1668 int32_t AudioOutputRenderGetMmapPosition(const struct DevHandle *handle,
1669 int cmdId, struct AudioHwRenderParam *handleData)
1670 {
1671 #ifdef ALSA_MODE
1672 return HDF_SUCCESS;
1673 #endif
1674 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1675 return HDF_FAILURE;
1676 }
1677 struct HdfIoService *service = NULL;
1678 struct HdfSBuf *reply = NULL;
1679 int32_t ret;
1680 service = (struct HdfIoService *)handle->object;
1681 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
1682 LOG_FUN_ERR("Failed to send service call!");
1683 return HDF_FAILURE;
1684 }
1685 reply = AudioObtainHdfSBuf();
1686 if (reply == NULL) {
1687 LOG_FUN_ERR("RenderGetMmapPosition Failed to obtain reply");
1688 return HDF_FAILURE;
1689 }
1690 ret = service->dispatcher->Dispatch(&service->object, cmdId, NULL, reply);
1691 if (ret != HDF_SUCCESS) {
1692 AudioBufReplyRecycle(NULL, reply);
1693 return HDF_FAILURE;
1694 }
1695 uint64_t frames = 0;
1696 if (!HdfSbufReadUint64(reply, &frames)) {
1697 LOG_FUN_ERR("Failed to Get Mmap Position sBuf!");
1698 AudioBufReplyRecycle(NULL, reply);
1699 return HDF_FAILURE;
1700 }
1701 handleData->frameRenderMode.frames = frames;
1702 AudioBufReplyRecycle(NULL, reply);
1703 return HDF_SUCCESS;
1704 }
1705
AudioInterfaceLibOutputRender(const struct DevHandle * handle,int cmdId,struct AudioHwRenderParam * handleData)1706 int32_t AudioInterfaceLibOutputRender(const struct DevHandle *handle,
1707 int cmdId, struct AudioHwRenderParam *handleData)
1708 {
1709 if (handle == NULL) {
1710 LOG_FUN_ERR("Input Render handle is NULL!");
1711 return HDF_FAILURE;
1712 }
1713 if (handle->object == NULL || handleData == NULL) {
1714 return HDF_FAILURE;
1715 }
1716 int32_t ret;
1717 switch (cmdId) {
1718 case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
1719 ret = AudioOutputRenderHwParams(handle, cmdId, handleData);
1720 break;
1721 case AUDIO_DRV_PCM_IOCTL_WRITE:
1722 ret = AudioOutputRenderWrite(handle, cmdId, handleData);
1723 break;
1724 case AUDIO_DRV_PCM_IOCTRL_STOP:
1725 ret = AudioOutputRenderStop(handle, cmdId, handleData);
1726 break;
1727 case AUDIO_DRV_PCM_IOCTRL_START:
1728 case AUDIO_DRV_PCM_IOCTL_PREPARE:
1729 case AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE:
1730 ret = AudioOutputRenderStartPrepare(handle, cmdId, handleData);
1731 break;
1732 case AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN:
1733 ret = AudioOutputRenderOpen(handle, cmdId, handleData);
1734 break;
1735 case AUDIODRV_CTL_IOCTL_PAUSE_WRITE:
1736 ret = AudioCtlRenderSetPauseStu(handle, cmdId, handleData);
1737 break;
1738 case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER:
1739 ret = AudioOutputRenderReqMmapBuffer(handle, cmdId, handleData);
1740 break;
1741 case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION:
1742 ret = (AudioOutputRenderGetMmapPosition(handle, cmdId, handleData));
1743 break;
1744 default:
1745 LOG_FUN_ERR("Output Mode not support!");
1746 ret = HDF_FAILURE;
1747 break;
1748 }
1749 return ret;
1750 }
1751
AudioBindServiceRenderObject(struct DevHandle * handle,const char * name)1752 int32_t AudioBindServiceRenderObject(struct DevHandle *handle, const char *name)
1753 {
1754 if (handle == NULL || name == NULL) {
1755 LOG_FUN_ERR("service name or handle is NULL!");
1756 return HDF_FAILURE;
1757 }
1758 char *serviceName = (char *)calloc(1, NAME_LEN);
1759 if (serviceName == NULL) {
1760 LOG_FUN_ERR("Failed to OsalMemCalloc serviceName");
1761 return HDF_FAILURE;
1762 }
1763 int ret = snprintf_s(serviceName, NAME_LEN - 1, SERVIC_NAME_MAX_LEN + 1, "hdf_audio_%s", name);
1764 if (ret < 0) {
1765 LOG_FUN_ERR("Failed to snprintf_s");
1766 AudioMemFree((void **)&serviceName);
1767 return HDF_FAILURE;
1768 }
1769 struct HdfIoService *service = HdfIoServiceBindName(serviceName);
1770 if (service == NULL) {
1771 LOG_FUN_ERR("Failed to get service!");
1772 AudioMemFree((void **)&serviceName);
1773 return HDF_FAILURE;
1774 }
1775 AudioMemFree((void **)&serviceName);
1776 handle->object = service;
1777 return HDF_SUCCESS;
1778 }
1779
1780 /* CreatRender for Bind handle */
AudioBindServiceRender(const char * name)1781 struct DevHandle *AudioBindServiceRender(const char *name)
1782 {
1783 struct DevHandle *handle = NULL;
1784 if (name == NULL) {
1785 LOG_FUN_ERR("service name NULL!");
1786 return NULL;
1787 }
1788 handle = (struct DevHandle *)calloc(1, sizeof(struct DevHandle));
1789 if (handle == NULL) {
1790 LOG_FUN_ERR("Failed to OsalMemCalloc handle");
1791 return NULL;
1792 }
1793 int32_t ret = AudioBindServiceRenderObject(handle, name);
1794 if (ret != HDF_SUCCESS) {
1795 LOG_FUN_ERR("handle->object is NULL!");
1796 AudioMemFree((void **)&handle);
1797 return NULL;
1798 }
1799 LOG_PARA_INFO("BIND SERVICE SUCCESS!");
1800 return handle;
1801 }
1802
AudioCloseServiceRender(const struct DevHandle * handle)1803 void AudioCloseServiceRender(const struct DevHandle *handle)
1804 {
1805 #ifdef ALSA_MODE
1806 return;
1807 #endif
1808 if (handle == NULL || handle->object == NULL) {
1809 LOG_FUN_ERR("Render handle or handle->object is NULL");
1810 return;
1811 }
1812 struct HdfIoService *service = (struct HdfIoService *)handle->object;
1813 HdfIoServiceRecycle(service);
1814 AudioMemFree((void **)&handle);
1815 return;
1816 }
1817
AudioInterfaceLibModeRender(const struct DevHandle * handle,struct AudioHwRenderParam * handleData,int cmdId)1818 int32_t AudioInterfaceLibModeRender(const struct DevHandle *handle,
1819 struct AudioHwRenderParam *handleData, int cmdId)
1820 {
1821 if (handle == NULL || handle->object == NULL || handleData == NULL) {
1822 LOG_FUN_ERR("paras is NULL!");
1823 return HDF_FAILURE;
1824 }
1825 switch (cmdId) {
1826 case AUDIO_DRV_PCM_IOCTL_HW_PARAMS:
1827 case AUDIO_DRV_PCM_IOCTL_WRITE:
1828 case AUDIO_DRV_PCM_IOCTRL_STOP:
1829 case AUDIO_DRV_PCM_IOCTRL_START:
1830 case AUDIO_DRV_PCM_IOCTL_PREPARE:
1831 case AUDIODRV_CTL_IOCTL_PAUSE_WRITE:
1832 case AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER:
1833 case AUDIO_DRV_PCM_IOCTL_MMAP_POSITION:
1834 case AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN:
1835 case AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE:
1836 return (AudioInterfaceLibOutputRender(handle, cmdId, handleData));
1837 case AUDIODRV_CTL_IOCTL_ELEM_WRITE:
1838 case AUDIODRV_CTL_IOCTL_ELEM_READ:
1839 case AUDIODRV_CTL_IOCTL_MUTE_WRITE:
1840 case AUDIODRV_CTL_IOCTL_MUTE_READ:
1841 case AUDIODRV_CTL_IOCTL_GAIN_WRITE:
1842 case AUDIODRV_CTL_IOCTL_GAIN_READ:
1843 case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE:
1844 case AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ:
1845 case AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE:
1846 case AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ:
1847 case AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_IN:
1848 case AUDIODRV_CTL_IOCTL_ACODEC_CHANGE_OUT:
1849 case AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ:
1850 return (AudioInterfaceLibCtlRender(handle, cmdId, handleData));
1851 default:
1852 LOG_FUN_ERR("Mode Error!");
1853 break;
1854 }
1855 return HDF_ERR_NOT_SUPPORT;
1856 }
1857
1858