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_proxy_common.h"
17
AudioProxyRenderCtrl(int cmId,AudioHandle handle)18 int32_t AudioProxyRenderCtrl(int cmId, AudioHandle handle)
19 {
20 struct HdfSBuf *data = NULL;
21 struct HdfSBuf *reply = NULL;
22 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
23 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
24 LOG_FUN_ERR("The hwRender parameter is null");
25 return HDF_FAILURE;
26 }
27 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
28 return HDF_FAILURE;
29 }
30 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, cmId, data, reply);
31 AudioProxyBufReplyRecycle(data, reply);
32 return ret;
33 }
34
AudioProxyRenderStart(AudioHandle handle)35 int32_t AudioProxyRenderStart(AudioHandle handle)
36 {
37 LOG_FUN_INFO();
38 return AudioProxyRenderCtrl(AUDIO_HDI_RENDER_START, handle);
39 }
40
AudioProxyRenderStop(AudioHandle handle)41 int32_t AudioProxyRenderStop(AudioHandle handle)
42 {
43 LOG_FUN_INFO();
44 return AudioProxyRenderCtrl(AUDIO_HDI_RENDER_STOP, handle);
45 }
46
AudioProxyRenderPause(AudioHandle handle)47 int32_t AudioProxyRenderPause(AudioHandle handle)
48 {
49 LOG_FUN_INFO();
50 return AudioProxyRenderCtrl(AUDIO_HDI_RENDER_PAUSE, handle);
51 }
52
AudioProxyRenderResume(AudioHandle handle)53 int32_t AudioProxyRenderResume(AudioHandle handle)
54 {
55 LOG_FUN_INFO();
56 return AudioProxyRenderCtrl(AUDIO_HDI_RENDER_RESUME, handle);
57 }
58
AudioProxyRenderFlush(AudioHandle handle)59 int32_t AudioProxyRenderFlush(AudioHandle handle)
60 {
61 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
62 if (hwRender == NULL) {
63 return HDF_FAILURE;
64 }
65 return HDF_ERR_NOT_SUPPORT;
66 }
67
AudioProxyRenderGetFrameParameter(int cmId,const AudioHandle handle,uint64_t * param)68 int32_t AudioProxyRenderGetFrameParameter(int cmId, const AudioHandle handle, uint64_t *param)
69 {
70 if (param == NULL) {
71 return HDF_FAILURE;
72 }
73 int32_t ret;
74 struct HdfSBuf *data = NULL;
75 struct HdfSBuf *reply = NULL;
76 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
77 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
78 LOG_FUN_ERR("invalid pointer");
79 return HDF_FAILURE;
80 }
81 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
82 return HDF_FAILURE;
83 }
84 ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, cmId, data, reply);
85 if (ret < 0) {
86 AudioProxyBufReplyRecycle(data, reply);
87 return ret;
88 }
89 if (!HdfSbufReadUint64(reply, param)) {
90 AudioProxyBufReplyRecycle(data, reply);
91 return HDF_FAILURE;
92 }
93 AudioProxyBufReplyRecycle(data, reply);
94 return HDF_SUCCESS;
95 }
96
AudioProxyRenderGetFrameSize(const AudioHandle handle,uint64_t * size)97 int32_t AudioProxyRenderGetFrameSize(const AudioHandle handle, uint64_t *size)
98 {
99 return AudioProxyRenderGetFrameParameter(AUDIO_HDI_RENDER_GET_FRAME_SIZE, handle, size);
100 }
101
AudioProxyRenderGetFrameCount(const AudioHandle handle,uint64_t * count)102 int32_t AudioProxyRenderGetFrameCount(const AudioHandle handle, uint64_t *count)
103 {
104 return AudioProxyRenderGetFrameParameter(AUDIO_HDI_RENDER_GET_FRAME_COUNT, handle, count);
105 }
106
AudioProxyRenderSetSampleAttributes(const AudioHandle handle,const struct AudioSampleAttributes * attrs)107 int32_t AudioProxyRenderSetSampleAttributes(const AudioHandle handle, const struct AudioSampleAttributes *attrs)
108 {
109 if (handle == NULL || attrs == NULL) {
110 return HDF_FAILURE;
111 }
112 struct HdfSBuf *data = NULL;
113 struct HdfSBuf *reply = NULL;
114 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
115 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
116 LOG_FUN_ERR("pointer is invalid");
117 return HDF_FAILURE;
118 }
119 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
120 return HDF_FAILURE;
121 }
122 if (AudioProxyWriteSampleAttributes(data, attrs) < 0) {
123 AudioProxyBufReplyRecycle(data, reply);
124 return HDF_FAILURE;
125 }
126 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_SET_SAMPLE_ATTR, data, reply);
127 AudioProxyBufReplyRecycle(data, reply);
128 return ret;
129 }
130
AudioProxyRenderGetSampleAttributes(const AudioHandle handle,struct AudioSampleAttributes * attrs)131 int32_t AudioProxyRenderGetSampleAttributes(const AudioHandle handle,
132 struct AudioSampleAttributes *attrs)
133 {
134 if (attrs == NULL) {
135 return HDF_FAILURE;
136 }
137 struct HdfSBuf *data = NULL;
138 struct HdfSBuf *reply = NULL;
139 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
140 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
141 LOG_FUN_ERR("The hwRender parameter is empty");
142 return HDF_FAILURE;
143 }
144 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
145 return HDF_FAILURE;
146 }
147 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_SAMPLE_ATTR, data, reply);
148 if (ret < 0) {
149 LOG_FUN_ERR("AudioRenderGetSampleAttributes FAIL");
150 AudioProxyBufReplyRecycle(data, reply);
151 return ret;
152 }
153 if (AudioProxyReadSapmleAttrbutes(reply, attrs)) {
154 LOG_FUN_ERR("AudioProxyReadSapmleAttrbutes FAIL");
155 AudioProxyBufReplyRecycle(data, reply);
156 return HDF_FAILURE;
157 }
158 AudioProxyBufReplyRecycle(data, reply);
159 return HDF_SUCCESS;
160 }
161
AudioProxyRenderGetCurrentChannelId(const AudioHandle handle,uint32_t * channelId)162 int32_t AudioProxyRenderGetCurrentChannelId(const AudioHandle handle, uint32_t *channelId)
163 {
164 if (channelId == NULL) {
165 return HDF_FAILURE;
166 }
167 struct HdfSBuf *data = NULL;
168 struct HdfSBuf *reply = NULL;
169 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
170 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
171 LOG_FUN_ERR("pointer is null");
172 return HDF_FAILURE;
173 }
174 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
175 return HDF_FAILURE;
176 }
177 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_CUR_CHANNEL_ID, data, reply);
178 if (ret < 0) {
179 LOG_FUN_ERR("AudioRenderGetCurrentChannelId FAIL");
180 AudioProxyBufReplyRecycle(data, reply);
181 return ret;
182 }
183 if (!HdfSbufReadUint32(reply, channelId)) {
184 AudioProxyBufReplyRecycle(data, reply);
185 return HDF_FAILURE;
186 }
187 AudioProxyBufReplyRecycle(data, reply);
188 return HDF_SUCCESS;
189 }
190
AudioProxyRenderCheckSceneCapability(AudioHandle handle,const struct AudioSceneDescriptor * scene,bool * supported)191 int32_t AudioProxyRenderCheckSceneCapability(AudioHandle handle,
192 const struct AudioSceneDescriptor *scene, bool *supported)
193 {
194 if (scene == NULL || supported == NULL) {
195 return HDF_FAILURE;
196 }
197 uint32_t tempPins;
198 struct HdfSBuf *data = NULL;
199 struct HdfSBuf *reply = NULL;
200 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
201 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
202 LOG_FUN_ERR("The hwRender pointer is null");
203 return HDF_FAILURE;
204 }
205 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
206 LOG_FUN_ERR("AudioProxyPreprocessRender FAIL");
207 return HDF_FAILURE;
208 }
209 if (!HdfSbufWriteUint32(data, scene->scene.id)) {
210 LOG_FUN_ERR("scene->scene.id Write FAIL");
211 AudioProxyBufReplyRecycle(data, reply);
212 return HDF_FAILURE;
213 }
214 tempPins = (uint32_t)scene->desc.pins;
215 if (!HdfSbufWriteUint32(data, tempPins)) {
216 LOG_FUN_ERR("tempPins Write FAIL");
217 AudioProxyBufReplyRecycle(data, reply);
218 return HDF_FAILURE;
219 }
220 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle,
221 AUDIO_HDI_RENDER_CHECK_SCENE_CAPABILITY, data, reply);
222 if (ret < 0) {
223 LOG_FUN_ERR("AudioRenderCheckSceneCapability FAIL");
224 AudioProxyBufReplyRecycle(data, reply);
225 return ret;
226 }
227 uint32_t tempSupported = 0;
228 if (!HdfSbufReadUint32(reply, &tempSupported)) {
229 AudioProxyBufReplyRecycle(data, reply);
230 return HDF_FAILURE;
231 }
232 *supported = (bool)tempSupported;
233 AudioProxyBufReplyRecycle(data, reply);
234 return HDF_SUCCESS;
235 }
236
AudioProxyRenderSelectScene(AudioHandle handle,const struct AudioSceneDescriptor * scene)237 int32_t AudioProxyRenderSelectScene(AudioHandle handle, const struct AudioSceneDescriptor *scene)
238 {
239 if (scene == NULL) {
240 return HDF_FAILURE;
241 }
242 struct HdfSBuf *data = NULL;
243 struct HdfSBuf *reply = NULL;
244 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
245 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
246 LOG_FUN_ERR("parameter is null");
247 return HDF_FAILURE;
248 }
249 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
250 return HDF_FAILURE;
251 }
252 if (!HdfSbufWriteUint32(data, scene->scene.id)) {
253 AudioProxyBufReplyRecycle(data, reply);
254 return HDF_FAILURE;
255 }
256 uint32_t temporaryPins = scene->desc.pins;
257 if (!HdfSbufWriteUint32(data, temporaryPins)) {
258 AudioProxyBufReplyRecycle(data, reply);
259 return HDF_FAILURE;
260 }
261 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_SELECT_SCENE, data, reply);
262 AudioProxyBufReplyRecycle(data, reply);
263 return ret;
264 }
265
AudioProxyRenderSetMute(AudioHandle handle,bool mute)266 int32_t AudioProxyRenderSetMute(AudioHandle handle, bool mute)
267 {
268 struct HdfSBuf *data = NULL;
269 struct HdfSBuf *reply = NULL;
270 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
271 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
272 LOG_FUN_ERR("The pointer is null");
273 return HDF_FAILURE;
274 }
275 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
276 return HDF_FAILURE;
277 }
278 uint32_t tempMute = (uint32_t)mute;
279 if (!HdfSbufWriteUint32(data, tempMute)) {
280 AudioProxyBufReplyRecycle(data, reply);
281 return HDF_FAILURE;
282 }
283 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_SET_MUTE, data, reply);
284 AudioProxyBufReplyRecycle(data, reply);
285 return ret;
286 }
287
AudioProxyRenderGetMute(AudioHandle handle,bool * mute)288 int32_t AudioProxyRenderGetMute(AudioHandle handle, bool *mute)
289 {
290 if (mute == NULL) {
291 return HDF_FAILURE;
292 }
293 struct HdfSBuf *data = NULL;
294 struct HdfSBuf *reply = NULL;
295 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
296 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
297 LOG_FUN_ERR("The parameter is null");
298 return HDF_FAILURE;
299 }
300 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
301 return HDF_FAILURE;
302 }
303 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_MUTE, data, reply);
304 uint32_t tempMute = 0;
305 if (!HdfSbufReadUint32(reply, &tempMute)) {
306 AudioProxyBufReplyRecycle(data, reply);
307 return HDF_FAILURE;
308 }
309 *mute = (bool)tempMute;
310 AudioProxyBufReplyRecycle(data, reply);
311 LOG_PARA_INFO("GetMute SUCCESS!");
312 return ret;
313 }
314
AudioProxyRenderSetVolume(AudioHandle handle,float volume)315 int32_t AudioProxyRenderSetVolume(AudioHandle handle, float volume)
316 {
317 LOG_FUN_INFO();
318 return AudioProxyCommonSetRenderCtrlParam(AUDIO_HDI_RENDER_SET_VOLUME, handle, volume);
319 }
320
AudioProxyRenderGetVolume(AudioHandle handle,float * volume)321 int32_t AudioProxyRenderGetVolume(AudioHandle handle, float *volume)
322 {
323 LOG_FUN_INFO();
324 return AudioProxyCommonGetRenderCtrlParam(AUDIO_HDI_RENDER_GET_VOLUME, handle, volume);
325 }
326
AudioProxyRenderGetGainThreshold(AudioHandle handle,float * min,float * max)327 int32_t AudioProxyRenderGetGainThreshold(AudioHandle handle, float *min, float *max)
328 {
329 if (NULL == min || NULL == max) {
330 return HDF_FAILURE;
331 }
332 struct HdfSBuf *data = NULL;
333 struct HdfSBuf *reply = NULL;
334 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
335 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
336 LOG_FUN_ERR("The pointer is invalid");
337 return HDF_FAILURE;
338 }
339 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
340 return HDF_FAILURE;
341 }
342 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_GAIN_THRESHOLD, data, reply);
343 if (ret < 0) {
344 LOG_FUN_ERR("AudioRenderGetGainThreshold FAIL");
345 AudioProxyBufReplyRecycle(data, reply);
346 return ret;
347 }
348 uint32_t tempMin = 0;
349 uint32_t tempMax = 0;
350 if (!HdfSbufReadUint32(reply, &tempMin)) {
351 AudioProxyBufReplyRecycle(data, reply);
352 return HDF_FAILURE;
353 }
354 if (!HdfSbufReadUint32(reply, &tempMax)) {
355 AudioProxyBufReplyRecycle(data, reply);
356 return HDF_FAILURE;
357 }
358 *min = (float)tempMin;
359 *max = (float)tempMax;
360 AudioProxyBufReplyRecycle(data, reply);
361 return HDF_SUCCESS;
362 }
363
AudioProxyRenderGetGain(AudioHandle handle,float * gain)364 int32_t AudioProxyRenderGetGain(AudioHandle handle, float *gain)
365 {
366 return AudioProxyCommonGetRenderCtrlParam(AUDIO_HDI_RENDER_GET_GAIN, handle, gain);
367 }
368
AudioProxyRenderSetGain(AudioHandle handle,float gain)369 int32_t AudioProxyRenderSetGain(AudioHandle handle, float gain)
370 {
371 return AudioProxyCommonSetRenderCtrlParam(AUDIO_HDI_RENDER_SET_GAIN, handle, gain);
372 }
373
AudioProxyRenderGetLatency(struct AudioRender * render,uint32_t * ms)374 int32_t AudioProxyRenderGetLatency(struct AudioRender *render, uint32_t *ms)
375 {
376 struct HdfSBuf *data = NULL;
377 struct HdfSBuf *reply = NULL;
378 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
379 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
380 LOG_FUN_ERR("The pointer is empty");
381 return HDF_FAILURE;
382 }
383 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
384 return HDF_FAILURE;
385 }
386 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_LATENCY, data, reply);
387 if (ret < 0) {
388 LOG_FUN_ERR("AudioRenderGetLatency FAIL");
389 AudioProxyBufReplyRecycle(data, reply);
390 return ret;
391 }
392 if (!HdfSbufReadUint32(reply, ms)) {
393 AudioProxyBufReplyRecycle(data, reply);
394 return HDF_FAILURE;
395 }
396 AudioProxyBufReplyRecycle(data, reply);
397 return HDF_SUCCESS;
398 }
399
AudioProxyRenderRenderFrame(struct AudioRender * render,const void * frame,uint64_t requestBytes,uint64_t * replyBytes)400 int32_t AudioProxyRenderRenderFrame(struct AudioRender *render, const void *frame,
401 uint64_t requestBytes, uint64_t *replyBytes)
402 {
403 if (frame == NULL || replyBytes == NULL) {
404 LOG_FUN_ERR("Render Frame Paras is NULL!");
405 return HDF_FAILURE;
406 }
407 struct HdfSBuf *data = NULL;
408 struct HdfSBuf *reply = NULL;
409 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
410 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
411 LOG_FUN_ERR("The hwRender parameter is null");
412 return HDF_FAILURE;
413 }
414 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
415 LOG_FUN_ERR("AudioProxyPreprocessRender FAIL");
416 return HDF_FAILURE;
417 }
418 if (!HdfSbufWriteBuffer(data, frame, (uint32_t)requestBytes)) {
419 AudioProxyBufReplyRecycle(data, reply);
420 LOG_FUN_ERR("HdfSbufWriteBuffer FAIL");
421 return HDF_FAILURE;
422 }
423 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_RENDER_FRAME, data, reply);
424 if (ret < 0) {
425 if (ret != HDF_ERR_INVALID_OBJECT) {
426 LOG_FUN_ERR("AudioRenderRenderFrame FAIL");
427 }
428 AudioProxyBufReplyRecycle(data, reply);
429 return ret;
430 }
431 *replyBytes = requestBytes;
432 AudioProxyBufReplyRecycle(data, reply);
433 return HDF_SUCCESS;
434 }
435
AudioProxyRenderGetRenderPosition(struct AudioRender * render,uint64_t * frames,struct AudioTimeStamp * time)436 int32_t AudioProxyRenderGetRenderPosition(struct AudioRender *render, uint64_t *frames, struct AudioTimeStamp *time)
437 {
438 if (frames == NULL || time == NULL) {
439 return HDF_FAILURE;
440 }
441 struct HdfSBuf *data = NULL;
442 struct HdfSBuf *reply = NULL;
443 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
444 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
445 LOG_FUN_ERR("hwRender or hwRender->proxyRemoteHandle invalid");
446 return HDF_FAILURE;
447 }
448 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
449 LOG_FUN_ERR("AudioProxyPreprocessRender FAIL");
450 return HDF_FAILURE;
451 }
452 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle,
453 AUDIO_HDI_RENDER_GET_RENDER_POSITION, data, reply);
454 if (ret < 0) {
455 LOG_FUN_ERR("AudioRenderGetRenderPosition FAIL");
456 AudioProxyBufReplyRecycle(data, reply);
457 return ret;
458 }
459 if (AudioProxyGetMmapPositionRead(reply, frames, time) < 0) {
460 LOG_FUN_ERR("AudioProxyGetMmapPositionRead FAIL");
461 AudioProxyBufReplyRecycle(data, reply);
462 return HDF_FAILURE;
463 }
464 AudioProxyBufReplyRecycle(data, reply);
465 return HDF_SUCCESS;
466 }
467
AudioProxyRenderSetRenderSpeed(struct AudioRender * render,float speed)468 int32_t AudioProxyRenderSetRenderSpeed(struct AudioRender *render, float speed)
469 {
470 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
471 if (hwRender == NULL) {
472 return HDF_FAILURE;
473 }
474 return HDF_ERR_NOT_SUPPORT;
475 }
476
AudioProxyRenderGetRenderSpeed(struct AudioRender * render,float * speed)477 int32_t AudioProxyRenderGetRenderSpeed(struct AudioRender *render, float *speed)
478 {
479 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
480 if (hwRender == NULL || speed == NULL) {
481 return HDF_FAILURE;
482 }
483 return HDF_ERR_NOT_SUPPORT;
484 }
485
AudioProxyRenderSetChannelMode(struct AudioRender * render,enum AudioChannelMode mode)486 int32_t AudioProxyRenderSetChannelMode(struct AudioRender *render, enum AudioChannelMode mode)
487 {
488 struct HdfSBuf *data = NULL;
489 struct HdfSBuf *reply = NULL;
490 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
491 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
492 LOG_FUN_ERR("parameter is null");
493 return HDF_FAILURE;
494 }
495 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
496 LOG_FUN_ERR("AudioProxyPreprocessRender FAIL");
497 return HDF_FAILURE;
498 }
499 uint32_t tempMode = (uint32_t)mode;
500 if (!HdfSbufWriteUint32(data, tempMode)) {
501 AudioProxyBufReplyRecycle(data, reply);
502 return HDF_FAILURE;
503 }
504 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_SET_CHANNEL_MODE, data, reply);
505 AudioProxyBufReplyRecycle(data, reply);
506 return ret;
507 }
508
AudioProxyRenderGetChannelMode(struct AudioRender * render,enum AudioChannelMode * mode)509 int32_t AudioProxyRenderGetChannelMode(struct AudioRender *render, enum AudioChannelMode *mode)
510 {
511 if (mode == NULL || render == NULL) {
512 return HDF_FAILURE;
513 }
514 struct HdfSBuf *data = NULL;
515 struct HdfSBuf *reply = NULL;
516 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
517 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
518 LOG_FUN_ERR("hwRender or hwRender->proxyRemoteHandle is NULL");
519 return HDF_FAILURE;
520 }
521 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
522 LOG_FUN_ERR("AudioProxyPreprocessRender FAIL");
523 return HDF_FAILURE;
524 }
525 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_CHANNEL_MODE, data, reply);
526 if (ret < 0) {
527 LOG_FUN_ERR("AudioRenderGetChannelMode FAIL");
528 AudioProxyBufReplyRecycle(data, reply);
529 return ret;
530 }
531 uint32_t tempMode = 0;
532 if (!HdfSbufReadUint32(reply, &tempMode)) {
533 AudioProxyBufReplyRecycle(data, reply);
534 return HDF_FAILURE;
535 }
536 *mode = (enum AudioChannelMode)tempMode;
537 AudioProxyBufReplyRecycle(data, reply);
538 return HDF_SUCCESS;
539 }
540
AudioProxyRenderSetExtraParams(AudioHandle handle,const char * keyValueList)541 int32_t AudioProxyRenderSetExtraParams(AudioHandle handle, const char *keyValueList)
542 {
543 if (NULL == handle || NULL == keyValueList) {
544 LOG_FUN_ERR("The parameter is empty");
545 return HDF_FAILURE;
546 }
547 struct HdfSBuf *data = NULL;
548 struct HdfSBuf *reply = NULL;
549 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
550 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
551 LOG_FUN_ERR("The parameter is null");
552 return HDF_FAILURE;
553 }
554 if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) {
555 return HDF_FAILURE;
556 }
557 if (!HdfSbufWriteString(data, keyValueList)) {
558 AudioProxyBufReplyRecycle(data, reply);
559 return HDF_FAILURE;
560 }
561 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_SET_EXTRA_PARAMS, data, reply);
562 AudioProxyBufReplyRecycle(data, reply);
563 return ret;
564 }
AudioProxyRenderGetExtraParams(AudioHandle handle,char * keyValueList,int32_t listLenth)565 int32_t AudioProxyRenderGetExtraParams(AudioHandle handle, char *keyValueList, int32_t listLenth)
566 {
567 LOG_PARA_INFO("AudioProxyRenderGetExtraParams enter!");
568 if (NULL == handle || NULL == keyValueList || listLenth <= 0) {
569 return HDF_FAILURE;
570 }
571 struct HdfSBuf *data = NULL;
572 struct HdfSBuf *reply = NULL;
573 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
574 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
575 LOG_FUN_ERR("parameter is null");
576 return HDF_FAILURE;
577 }
578 if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) {
579 LOG_FUN_ERR("AudioProxyRenderGetExtraParams FAIL");
580 return HDF_FAILURE;
581 }
582 if (!HdfSbufWriteInt32(data, listLenth)) {
583 AudioProxyBufReplyRecycle(data, reply);
584 return HDF_FAILURE;
585 }
586 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_EXTRA_PARAMS, data, reply);
587 if (ret < 0) {
588 LOG_FUN_ERR("AudioProxyRenderGetExtraParams FAIL");
589 AudioProxyBufReplyRecycle(data, reply);
590 return ret;
591 }
592 const char *strKeyValueList = NULL;
593 if ((strKeyValueList = HdfSbufReadString(reply)) == NULL) {
594 LOG_FUN_ERR("keyValueList Is empty");
595 AudioProxyBufReplyRecycle(data, reply);
596 return HDF_FAILURE;
597 }
598 ret = strncpy_s(keyValueList, listLenth - 1, strKeyValueList, strlen(strKeyValueList) + 1);
599 if (ret != 0) {
600 LOG_FUN_ERR("Copy failed!");
601 AudioProxyBufReplyRecycle(data, reply);
602 return HDF_FAILURE;
603 }
604 AudioProxyBufReplyRecycle(data, reply);
605 return ret;
606 }
607
AudioProxyRenderReqMmapBuffer(AudioHandle handle,int32_t reqSize,struct AudioMmapBufferDescripter * desc)608 int32_t AudioProxyRenderReqMmapBuffer(AudioHandle handle, int32_t reqSize, struct AudioMmapBufferDescripter *desc)
609 {
610 if (NULL == handle || NULL == desc) {
611 return HDF_FAILURE;
612 }
613 struct HdfSBuf *data = NULL;
614 struct HdfSBuf *reply = NULL;
615 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
616 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
617 LOG_FUN_ERR("hwRender or hwRender->proxyRemoteHandle is NULL");
618 return HDF_FAILURE;
619 }
620
621 if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) {
622 LOG_FUN_ERR("AudioProxyRenderReqMmapBuffer FAIL");
623 return HDF_FAILURE;
624 }
625 if (AudioProxyReqMmapBufferWrite(data, reqSize, desc) < 0) {
626 AudioProxyBufReplyRecycle(data, reply);
627 return HDF_FAILURE;
628 }
629 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_REQ_MMAP_BUFFER, data, reply);
630 if (ret < 0) {
631 LOG_FUN_ERR("AudioProxyRenderReqMmapBuffer FAIL");
632 AudioProxyBufReplyRecycle(data, reply);
633 return ret;
634 }
635
636 AudioProxyBufReplyRecycle(data, reply);
637 return ret;
638 }
639
AudioProxyRenderGetMmapPosition(AudioHandle handle,uint64_t * frames,struct AudioTimeStamp * time)640 int32_t AudioProxyRenderGetMmapPosition(AudioHandle handle, uint64_t *frames, struct AudioTimeStamp *time)
641 {
642 if (NULL == handle || NULL == frames || NULL == time) {
643 return HDF_FAILURE;
644 }
645 struct HdfSBuf *data = NULL;
646 struct HdfSBuf *reply = NULL;
647 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
648 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
649 LOG_FUN_ERR("The parameter is empty");
650 return HDF_FAILURE;
651 }
652
653 if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) {
654 LOG_FUN_ERR("AudioProxyRenderGetMmapPosition FAIL");
655 return HDF_FAILURE;
656 }
657 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_GET_MMAP_POSITION, data, reply);
658 if (ret < 0) {
659 AudioProxyBufReplyRecycle(data, reply);
660 LOG_FUN_ERR("AudioProxyRenderGetMmapPosition FAIL");
661 return ret;
662 }
663 if (AudioProxyGetMmapPositionRead(reply, frames, time) < 0) {
664 AudioProxyBufReplyRecycle(data, reply);
665 return HDF_FAILURE;
666 }
667 AudioProxyBufReplyRecycle(data, reply);
668 return HDF_SUCCESS;
669 }
670
AudioProxyRenderTurnStandbyMode(AudioHandle handle)671 int32_t AudioProxyRenderTurnStandbyMode(AudioHandle handle)
672 {
673 if (NULL == handle) {
674 return HDF_FAILURE;
675 }
676 struct HdfSBuf *data = NULL;
677 struct HdfSBuf *reply = NULL;
678 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
679 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
680 LOG_FUN_ERR("parameter is empty");
681 return HDF_FAILURE;
682 }
683
684 if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) {
685 LOG_FUN_ERR("AudioProxyRenderTurnStandbyMode FAIL");
686 return HDF_FAILURE;
687 }
688 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_TURN_STAND_BY_MODE, data, reply);
689 if (ret < 0) {
690 LOG_FUN_ERR("AudioProxyRenderTurnStandbyMode FAIL");
691 AudioProxyBufReplyRecycle(data, reply);
692 return ret;
693 }
694 AudioProxyBufReplyRecycle(data, reply);
695 return ret;
696 }
AudioProxyRenderAudioDevDump(AudioHandle handle,int32_t range,int32_t fd)697 int32_t AudioProxyRenderAudioDevDump(AudioHandle handle, int32_t range, int32_t fd)
698 {
699 if (NULL == handle) {
700 return HDF_FAILURE;
701 }
702 struct HdfSBuf *data = NULL;
703 struct HdfSBuf *reply = NULL;
704 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
705 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
706 LOG_FUN_ERR("The hwRender parameter is empty");
707 return HDF_FAILURE;
708 }
709 if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) {
710 LOG_FUN_ERR("AudioProxyRenderAudioDevDump FAIL");
711 return HDF_FAILURE;
712 }
713 if (!HdfSbufWriteInt32(data, range)) {
714 AudioProxyBufReplyRecycle(data, reply);
715 LOG_FUN_ERR("Write FAIL");
716 return HDF_FAILURE;
717 }
718 if (!HdfSbufWriteInt32(data, fd)) {
719 AudioProxyBufReplyRecycle(data, reply);
720 return HDF_FAILURE;
721 }
722 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_DEV_DUMP, data, reply);
723 if (ret < 0) {
724 LOG_FUN_ERR("AudioProxyRenderAudioDevDump FAIL");
725 AudioProxyBufReplyRecycle(data, reply);
726 return ret;
727 }
728 AudioProxyBufReplyRecycle(data, reply);
729 return ret;
730 }
AudioProxyRenderRegCallback(struct AudioRender * render,RenderCallback callback,void * cookie)731 int32_t AudioProxyRenderRegCallback(struct AudioRender *render, RenderCallback callback, void *cookie)
732 {
733 if (NULL == render || NULL == callback || NULL == cookie) {
734 return HDF_FAILURE;
735 }
736 struct HdfSBuf *data = NULL;
737 struct HdfSBuf *reply = NULL;
738 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
739 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
740 LOG_FUN_ERR("The parameter is empty");
741 return HDF_FAILURE;
742 }
743 if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) {
744 LOG_FUN_ERR("AudioProxyRenderRegCallback FAIL");
745 return HDF_FAILURE;
746 }
747 uint64_t tempAddr = (uint64_t)cookie;
748 if (!HdfSbufWriteUint64(data, tempAddr)) {
749 AudioProxyBufReplyRecycle(data, reply);
750 return HDF_FAILURE;
751 }
752 tempAddr = (uint64_t)callback;
753 if (!HdfSbufWriteUint64(data, tempAddr)) {
754 AudioProxyBufReplyRecycle(data, reply);
755 return HDF_FAILURE;
756 }
757 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_REG_CALLBACK, data, reply);
758 if (ret < 0) {
759 LOG_FUN_ERR("AudioProxyRenderRegCallback FAIL");
760 AudioProxyBufReplyRecycle(data, reply);
761 return ret;
762 }
763 AudioProxyBufReplyRecycle(data, reply);
764 return ret;
765 }
AudioProxyRenderDrainBuffer(struct AudioRender * render,enum AudioDrainNotifyType * type)766 int32_t AudioProxyRenderDrainBuffer(struct AudioRender *render, enum AudioDrainNotifyType *type)
767 {
768 if (NULL == render) {
769 return HDF_FAILURE;
770 }
771 struct HdfSBuf *data = NULL;
772 struct HdfSBuf *reply = NULL;
773 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
774 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
775 LOG_FUN_ERR("The hwRender parameter is empty");
776 return HDF_FAILURE;
777 }
778 if (AudioProxyPreprocessRender((AudioHandle)hwRender, &data, &reply) < 0) {
779 LOG_FUN_ERR("AudioProxyRenderDrainBuffer FAIL");
780 return HDF_FAILURE;
781 }
782 uint32_t tempType = (uint32_t)type;
783 if (!HdfSbufWriteUint32(data, tempType)) {
784 AudioProxyBufReplyRecycle(data, reply);
785 return HDF_FAILURE;
786 }
787 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, AUDIO_HDI_RENDER_DRAIN_BUFFER, data, reply);
788 if (ret < 0) {
789 LOG_FUN_ERR("AudioProxyRenderDrainBuffer FAIL");
790 AudioProxyBufReplyRecycle(data, reply);
791 return ret;
792 }
793 AudioProxyBufReplyRecycle(data, reply);
794 return ret;
795 }
796
797