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