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 #include <servmgr_hdi.h>
18 #include "audio_uhdf_log.h"
19
20 #define HDF_LOG_TAG HDF_AUDIO_HAL_PROXY
21
22 #define AUDIO_HDF_SBUF_IPC 1
23 #define PROXY_VOLUME_CHANGE 100
24
AudioProxyObtainHdfSBuf(void)25 struct HdfSBuf *AudioProxyObtainHdfSBuf(void)
26 {
27 enum HdfSbufType bufType;
28 #ifdef AUDIO_HDF_SBUF_IPC
29 bufType = SBUF_IPC;
30 #else
31 bufType = SBUF_RAW;
32 #endif
33 return HdfSbufTypedObtain(bufType);
34 }
35
AudioProxyDispatchCall(struct HdfRemoteService * self,int32_t id,struct HdfSBuf * data,struct HdfSBuf * reply)36 int32_t AudioProxyDispatchCall(struct HdfRemoteService *self,
37 int32_t id, struct HdfSBuf *data, struct HdfSBuf *reply)
38 {
39 if (data == NULL || reply == NULL || self == NULL) {
40 AUDIO_FUNC_LOGE("AudioProxyDispatchCall parameter is null");
41 return AUDIO_HAL_ERR_INVALID_PARAM;
42 }
43 if (self->dispatcher == NULL || self->dispatcher->Dispatch == NULL) {
44 AUDIO_FUNC_LOGE("AudioProxyDispatchCall Remote obj is null");
45 return AUDIO_HAL_ERR_INVALID_PARAM;
46 }
47 return self->dispatcher->Dispatch(self, id, data, reply);
48 }
49
AudioProxyAdapterGetRemoteHandle(struct AudioProxyManager * proxyManager,struct AudioHwAdapter * hwAdapter,const char * adapterName)50 int32_t AudioProxyAdapterGetRemoteHandle(struct AudioProxyManager *proxyManager, struct AudioHwAdapter *hwAdapter,
51 const char *adapterName)
52 {
53 if (proxyManager == NULL || hwAdapter == NULL || adapterName == NULL) {
54 AUDIO_FUNC_LOGE("AudioProxyAdapterGetRemoteHandle parameter is null");
55 return AUDIO_HAL_ERR_INVALID_PARAM;
56 }
57 if (strncmp(adapterName, PRIMARY, strlen(PRIMARY)) == 0) {
58 hwAdapter->proxyRemoteHandle = proxyManager->remote;
59 } else if (strncmp(adapterName, USB, strlen(USB)) == 0) {
60 hwAdapter->proxyRemoteHandle = proxyManager->usbRemote;
61 } else if (strncmp(adapterName, A2DP, strlen(A2DP)) == 0) {
62 hwAdapter->proxyRemoteHandle = proxyManager->a2dpRemote;
63 } else {
64 AUDIO_FUNC_LOGE("Remote not found!");
65 return AUDIO_HAL_ERR_INVALID_PARAM;
66 }
67 return HDF_SUCCESS;
68 }
69
AudioProxyBufReplyRecycle(struct HdfSBuf * data,struct HdfSBuf * reply)70 void AudioProxyBufReplyRecycle(struct HdfSBuf *data, struct HdfSBuf *reply)
71 {
72 if (data != NULL) {
73 HdfSbufRecycle(data);
74 }
75 if (reply != NULL) {
76 HdfSbufRecycle(reply);
77 }
78 return;
79 }
80
AudioProxyPreprocessSBuf(struct HdfSBuf ** data,struct HdfSBuf ** reply)81 int32_t AudioProxyPreprocessSBuf(struct HdfSBuf **data, struct HdfSBuf **reply)
82 {
83 if (data == NULL || reply == NULL) {
84 return HDF_FAILURE;
85 }
86 *data = AudioProxyObtainHdfSBuf();
87 if (*data == NULL) {
88 AUDIO_FUNC_LOGE("Failed to obtain data");
89 return HDF_FAILURE;
90 }
91 *reply = AudioProxyObtainHdfSBuf();
92 if (*reply == NULL) {
93 AUDIO_FUNC_LOGE("Failed to obtain reply");
94 HdfSbufRecycle(*data);
95 return HDF_FAILURE;
96 }
97 return HDF_SUCCESS;
98 }
99
AudioProxyPreprocessRender(struct AudioHwRender * render,struct HdfSBuf ** data,struct HdfSBuf ** reply)100 int32_t AudioProxyPreprocessRender(struct AudioHwRender *render, struct HdfSBuf **data, struct HdfSBuf **reply)
101 {
102 struct AudioHwRender *hwRender = render;
103 if (hwRender == NULL || data == NULL || reply == NULL) {
104 return HDF_FAILURE;
105 }
106 uint32_t renderPid = (uint32_t)getpid();
107 const char *adapterName = hwRender->renderParam.renderMode.hwInfo.adapterName;
108 if (adapterName == NULL) {
109 AUDIO_FUNC_LOGE("adapterName is NULL");
110 return HDF_FAILURE;
111 }
112 if (AudioProxyPreprocessSBuf(data, reply) < 0) {
113 return HDF_FAILURE;
114 }
115 if (!HdfRemoteServiceWriteInterfaceToken(render->proxyRemoteHandle, *data)) {
116 AUDIO_FUNC_LOGE("write interface token failed");
117 AudioProxyBufReplyRecycle(*data, *reply);
118 return AUDIO_HAL_ERR_INTERNAL;
119 }
120 if (!HdfSbufWriteString(*data, adapterName)) {
121 AUDIO_FUNC_LOGE("write adapterName failed");
122 AudioProxyBufReplyRecycle(*data, *reply);
123 return HDF_FAILURE;
124 }
125 if (!HdfSbufWriteUint32(*data, renderPid)) {
126 AUDIO_FUNC_LOGE("write renderPid failed");
127 AudioProxyBufReplyRecycle(*data, *reply);
128 return HDF_FAILURE;
129 }
130 return HDF_SUCCESS;
131 }
132
AudioProxyPreprocessCapture(struct AudioHwCapture * capture,struct HdfSBuf ** data,struct HdfSBuf ** reply)133 int32_t AudioProxyPreprocessCapture(struct AudioHwCapture *capture, struct HdfSBuf **data, struct HdfSBuf **reply)
134 {
135 struct AudioHwCapture *hwCapture = capture;
136 if (hwCapture == NULL || data == NULL || reply == NULL) {
137 return HDF_FAILURE;
138 }
139 uint32_t capturePid = (uint32_t)getpid();
140 const char *adapterName = hwCapture->captureParam.captureMode.hwInfo.adapterName;
141 if (adapterName == NULL) {
142 AUDIO_FUNC_LOGE("The pointer is null");
143 return HDF_FAILURE;
144 }
145 if (AudioProxyPreprocessSBuf(data, reply) < 0) {
146 return HDF_FAILURE;
147 }
148 if (!HdfRemoteServiceWriteInterfaceToken(capture->proxyRemoteHandle, *data)) {
149 AUDIO_FUNC_LOGE("write interface token failed");
150 AudioProxyBufReplyRecycle(*data, *reply);
151 return AUDIO_HAL_ERR_INTERNAL;
152 }
153 if (!HdfSbufWriteString(*data, adapterName)) {
154 AUDIO_FUNC_LOGE("write adapterName failed");
155 AudioProxyBufReplyRecycle(*data, *reply);
156 return HDF_FAILURE;
157 }
158 if (!HdfSbufWriteUint32(*data, capturePid)) {
159 AUDIO_FUNC_LOGE("write capturePid failed");
160 AudioProxyBufReplyRecycle(*data, *reply);
161 return HDF_FAILURE;
162 }
163 return HDF_SUCCESS;
164 }
165
AudioProxyWriteSampleAttributes(struct HdfSBuf * data,const struct AudioSampleAttributes * attrs)166 int32_t AudioProxyWriteSampleAttributes(struct HdfSBuf *data, const struct AudioSampleAttributes *attrs)
167 {
168 if (data == NULL || attrs == NULL) {
169 AUDIO_FUNC_LOGE("data or attrs is null!");
170 return HDF_FAILURE;
171 }
172 if (!HdfSbufWriteUint32(data, (uint32_t)attrs->type)) {
173 return HDF_FAILURE;
174 }
175 if (!HdfSbufWriteUint32(data, (uint32_t)attrs->interleaved)) {
176 return HDF_FAILURE;
177 }
178 if (!HdfSbufWriteUint32(data, (uint32_t)attrs->format)) {
179 return HDF_FAILURE;
180 }
181 if (!HdfSbufWriteUint32(data, attrs->sampleRate)) {
182 return HDF_FAILURE;
183 }
184 if (!HdfSbufWriteUint32(data, attrs->channelCount)) {
185 return HDF_FAILURE;
186 }
187 if (!HdfSbufWriteUint32(data, attrs->period)) {
188 return HDF_FAILURE;
189 }
190 if (!HdfSbufWriteUint32(data, attrs->frameSize)) {
191 return HDF_FAILURE;
192 }
193 if (!HdfSbufWriteUint32(data, (uint32_t)(attrs->isBigEndian))) {
194 return HDF_FAILURE;
195 }
196 if (!HdfSbufWriteUint32(data, (uint32_t)(attrs->isSignedData))) {
197 return HDF_FAILURE;
198 }
199 if (!HdfSbufWriteUint32(data, attrs->startThreshold)) {
200 AUDIO_FUNC_LOGE("write startThreshold failed");
201 return HDF_FAILURE;
202 }
203 if (!HdfSbufWriteUint32(data, attrs->stopThreshold)) {
204 AUDIO_FUNC_LOGE("write stopThreshold failed");
205 return HDF_FAILURE;
206 }
207 if (!HdfSbufWriteUint32(data, attrs->silenceThreshold)) {
208 return HDF_FAILURE;
209 }
210 return HDF_SUCCESS;
211 }
212
AudioProxyReadSapmleAttrbutes(struct HdfSBuf * reply,struct AudioSampleAttributes * attrs)213 int32_t AudioProxyReadSapmleAttrbutes(struct HdfSBuf *reply, struct AudioSampleAttributes *attrs)
214 {
215 if (reply == NULL || attrs == NULL) {
216 AUDIO_FUNC_LOGE("reply or attrs is null!");
217 return HDF_FAILURE;
218 }
219 uint32_t tempType = 0;
220 if (!HdfSbufReadUint32(reply, &tempType)) {
221 return HDF_FAILURE;
222 }
223 attrs->type = (enum AudioCategory)tempType;
224 uint32_t tempInterleaved = 0;
225 if (!HdfSbufReadUint32(reply, &tempInterleaved)) {
226 return HDF_FAILURE;
227 }
228 attrs->interleaved = (bool)tempInterleaved;
229 uint32_t tempFormat = 0;
230 if (!HdfSbufReadUint32(reply, &tempFormat)) {
231 return HDF_FAILURE;
232 }
233 attrs->format = (enum AudioFormat)tempFormat;
234 if (!HdfSbufReadUint32(reply, &attrs->sampleRate)) {
235 return HDF_FAILURE;
236 }
237 if (!HdfSbufReadUint32(reply, &attrs->channelCount)) {
238 return HDF_FAILURE;
239 }
240 if (!HdfSbufReadUint32(reply, &attrs->period)) {
241 return HDF_FAILURE;
242 }
243 if (!HdfSbufReadUint32(reply, &attrs->frameSize)) {
244 return HDF_FAILURE;
245 }
246 if (!HdfSbufReadUint32(reply, &tempInterleaved)) {
247 return HDF_FAILURE;
248 }
249 attrs->isBigEndian = (bool)tempInterleaved;
250 if (!HdfSbufReadUint32(reply, &tempInterleaved)) {
251 return HDF_FAILURE;
252 }
253 attrs->isSignedData = (bool)tempInterleaved;
254 if (!HdfSbufReadUint32(reply, &attrs->startThreshold) ||
255 !HdfSbufReadUint32(reply, &attrs->stopThreshold) ||
256 !HdfSbufReadUint32(reply, &attrs->silenceThreshold)) {
257 return HDF_FAILURE;
258 }
259 return HDF_SUCCESS;
260 }
261
AudioProxyCommonSetRenderCtrlParam(int cmId,AudioHandle handle,float param)262 int32_t AudioProxyCommonSetRenderCtrlParam(int cmId, AudioHandle handle, float param)
263 {
264 AUDIO_FUNC_LOGI();
265 struct HdfSBuf *data = NULL;
266 struct HdfSBuf *reply = NULL;
267 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
268 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
269 AUDIO_FUNC_LOGE("The hwRender parameter is null");
270 return AUDIO_HAL_ERR_INVALID_PARAM;
271 }
272 if (param < 0) {
273 AUDIO_FUNC_LOGE("Set param is invalid, Please check param!");
274 return AUDIO_HAL_ERR_INVALID_PARAM;
275 }
276 if (cmId == AUDIO_HDI_RENDER_SET_VOLUME) {
277 if (param > 1.0) {
278 AUDIO_FUNC_LOGE("volume param Is error!");
279 return AUDIO_HAL_ERR_INVALID_PARAM;
280 }
281 param = param * PROXY_VOLUME_CHANGE;
282 }
283 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
284 return AUDIO_HAL_ERR_INTERNAL;
285 }
286 uint32_t tempParam = (uint32_t)param;
287 if (!HdfSbufWriteUint32(data, tempParam)) {
288 AudioProxyBufReplyRecycle(data, reply);
289 return AUDIO_HAL_ERR_INTERNAL;
290 }
291 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, cmId, data, reply);
292 AudioProxyBufReplyRecycle(data, reply);
293 return ret;
294 }
295
AudioProxyCommonGetRenderCtrlParam(int cmId,AudioHandle handle,float * param)296 int32_t AudioProxyCommonGetRenderCtrlParam(int cmId, AudioHandle handle, float *param)
297 {
298 AUDIO_FUNC_LOGI();
299 if (param == NULL) {
300 return AUDIO_HAL_ERR_INVALID_PARAM;
301 }
302 struct HdfSBuf *data = NULL;
303 struct HdfSBuf *reply = NULL;
304 struct AudioHwRender *hwRender = (struct AudioHwRender *)handle;
305 if (hwRender == NULL || hwRender->proxyRemoteHandle == NULL) {
306 AUDIO_FUNC_LOGE("The pointer is empty");
307 return AUDIO_HAL_ERR_INVALID_PARAM;
308 }
309 if (AudioProxyPreprocessRender(hwRender, &data, &reply) < 0) {
310 return AUDIO_HAL_ERR_INTERNAL;
311 }
312 int32_t ret = AudioProxyDispatchCall(hwRender->proxyRemoteHandle, cmId, data, reply);
313 if (ret < 0) {
314 AudioProxyBufReplyRecycle(data, reply);
315 return ret;
316 }
317 uint32_t tempParam = 0;
318 if (!HdfSbufReadUint32(reply, &tempParam)) {
319 AudioProxyBufReplyRecycle(data, reply);
320 return AUDIO_HAL_ERR_INTERNAL;
321 }
322 if (cmId == AUDIO_HDI_RENDER_GET_VOLUME) {
323 *param = (float)tempParam / PROXY_VOLUME_CHANGE;
324 } else {
325 *param = (float)tempParam;
326 }
327 AudioProxyBufReplyRecycle(data, reply);
328 return AUDIO_HAL_SUCCESS;
329 }
330
AudioProxyCommonSetCaptureCtrlParam(int cmId,AudioHandle handle,float param)331 int32_t AudioProxyCommonSetCaptureCtrlParam(int cmId, AudioHandle handle, float param)
332 {
333 AUDIO_FUNC_LOGI();
334 struct HdfSBuf *data = NULL;
335 struct HdfSBuf *reply = NULL;
336 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
337 if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) {
338 AUDIO_FUNC_LOGE("The hwCapture parameter is null");
339 return AUDIO_HAL_ERR_INVALID_PARAM;
340 }
341 if (param < 0) {
342 AUDIO_FUNC_LOGE("Set param is invalid, Please check param!");
343 return AUDIO_HAL_ERR_INVALID_PARAM;
344 }
345 if (cmId == AUDIO_HDI_CAPTURE_SET_VOLUME) {
346 if (param > 1.0) {
347 AUDIO_FUNC_LOGE("volume param Is error!");
348 return AUDIO_HAL_ERR_INVALID_PARAM;
349 }
350 param = param * PROXY_VOLUME_CHANGE;
351 }
352 if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) {
353 return AUDIO_HAL_ERR_INTERNAL;
354 }
355 uint32_t tempParam = (uint32_t)param;
356 if (!HdfSbufWriteUint32(data, tempParam)) {
357 AudioProxyBufReplyRecycle(data, reply);
358 return AUDIO_HAL_ERR_INTERNAL;
359 }
360 int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, cmId, data, reply);
361 AudioProxyBufReplyRecycle(data, reply);
362 return ret;
363 }
364
AudioProxyCommonGetCaptureCtrlParam(int cmId,AudioHandle handle,float * param)365 int32_t AudioProxyCommonGetCaptureCtrlParam(int cmId, AudioHandle handle, float *param)
366 {
367 AUDIO_FUNC_LOGI();
368 if (param == NULL) {
369 return AUDIO_HAL_ERR_INVALID_PARAM;
370 }
371 struct HdfSBuf *data = NULL;
372 struct HdfSBuf *reply = NULL;
373 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)handle;
374 if (hwCapture == NULL || hwCapture->proxyRemoteHandle == NULL) {
375 AUDIO_FUNC_LOGE("The hwCapture parameter is invalid");
376 return AUDIO_HAL_ERR_INVALID_PARAM;
377 }
378 if (AudioProxyPreprocessCapture(hwCapture, &data, &reply) < 0) {
379 return AUDIO_HAL_ERR_INVALID_PARAM;
380 }
381 int32_t ret = AudioProxyDispatchCall(hwCapture->proxyRemoteHandle, cmId, data, reply);
382 if (ret < 0) {
383 AudioProxyBufReplyRecycle(data, reply);
384 return ret;
385 }
386 uint32_t tempParam = 0;
387 if (!HdfSbufReadUint32(reply, &tempParam)) {
388 AudioProxyBufReplyRecycle(data, reply);
389 return AUDIO_HAL_ERR_INTERNAL;
390 }
391 if (cmId == AUDIO_HDI_CAPTURE_GET_VOLUME) {
392 *param = (float)tempParam / PROXY_VOLUME_CHANGE;
393 } else {
394 *param = (float)tempParam;
395 }
396 AudioProxyBufReplyRecycle(data, reply);
397 return AUDIO_HAL_SUCCESS;
398 }
399
AudioProxyGetMmapPositionRead(struct HdfSBuf * reply,uint64_t * frames,struct AudioTimeStamp * time)400 int32_t AudioProxyGetMmapPositionRead(struct HdfSBuf *reply, uint64_t *frames, struct AudioTimeStamp *time)
401 {
402 if (reply == NULL || frames == NULL || time == NULL) {
403 return HDF_FAILURE;
404 }
405 if (!HdfSbufReadUint64(reply, frames)) {
406 return HDF_FAILURE;
407 }
408 if (!HdfSbufReadInt64(reply, &time->tvSec)) {
409 return HDF_FAILURE;
410 }
411 if (!HdfSbufReadInt64(reply, &time->tvNSec)) {
412 return HDF_FAILURE;
413 }
414 return HDF_SUCCESS;
415 }
416
AudioProxyReqMmapBufferWrite(struct HdfSBuf * data,int32_t reqSize,const struct AudioMmapBufferDescripter * desc)417 int32_t AudioProxyReqMmapBufferWrite(struct HdfSBuf *data, int32_t reqSize,
418 const struct AudioMmapBufferDescripter *desc)
419 {
420 if (data == NULL || desc == NULL) {
421 return HDF_FAILURE;
422 }
423 if (!HdfSbufWriteInt32(data, reqSize)) {
424 AUDIO_FUNC_LOGE("write reqSize failed");
425 return HDF_FAILURE;
426 }
427 uint64_t memAddr = (uint64_t)(uintptr_t)desc->memoryAddress;
428 if (!HdfSbufWriteUint64(data, memAddr)) {
429 AUDIO_FUNC_LOGE("write memoryAddress failed");
430 return HDF_FAILURE;
431 }
432 if (!HdfSbufWriteFileDescriptor(data, desc->memoryFd)) {
433 AUDIO_FUNC_LOGE("write memoryFd failed");
434 return HDF_FAILURE;
435 }
436 if (!HdfSbufWriteInt32(data, desc->totalBufferFrames)) {
437 AUDIO_FUNC_LOGE("write totalBufferFrames failed");
438 return HDF_FAILURE;
439 }
440 if (!HdfSbufWriteInt32(data, desc->transferFrameSize)) {
441 AUDIO_FUNC_LOGE("write transferFrameSize failed");
442 return HDF_FAILURE;
443 }
444 if (!HdfSbufWriteInt32(data, desc->isShareable)) {
445 AUDIO_FUNC_LOGE("write isShareable failed");
446 return HDF_FAILURE;
447 }
448 if (!HdfSbufWriteUint32(data, desc->offset)) {
449 AUDIO_FUNC_LOGE("write offset failed");
450 return HDF_FAILURE;
451 }
452 return HDF_SUCCESS;
453 }
454
AudioDevExtInfoBlockMarshalling(struct HdfSBuf * data,const struct AudioDevExtInfo * dataBlock)455 static bool AudioDevExtInfoBlockMarshalling(struct HdfSBuf *data, const struct AudioDevExtInfo *dataBlock)
456 {
457 if (dataBlock == NULL) {
458 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
459 return false;
460 }
461
462 if (!HdfSbufWriteInt32(data, dataBlock->moduleId)) {
463 HDF_LOGE("%{public}s: write dataBlock->moduleId failed!", __func__);
464 return false;
465 }
466
467 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->type)) {
468 HDF_LOGE("%{public}s: write dataBlock->type failed!", __func__);
469 return false;
470 }
471
472 if (!HdfSbufWriteString(data, dataBlock->desc)) {
473 HDF_LOGE("%{public}s: write dataBlock->desc failed!", __func__);
474 return false;
475 }
476
477 return true;
478 }
479
AudioMixExtInfoBlockMarshalling(struct HdfSBuf * data,const struct AudioMixExtInfo * dataBlock)480 static bool AudioMixExtInfoBlockMarshalling(struct HdfSBuf *data, const struct AudioMixExtInfo *dataBlock)
481 {
482 if (data == NULL || dataBlock == NULL) {
483 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
484 return false;
485 }
486
487 if (!HdfSbufWriteUnpadBuffer(data, (const uint8_t *)dataBlock, sizeof(struct AudioMixExtInfo))) {
488 HDF_LOGE("%{public}s: failed to write buffer data", __func__);
489 return false;
490 }
491 return true;
492 }
493
AudioSessionExtInfoBlockMarshalling(struct HdfSBuf * data,const struct AudioSessionExtInfo * dataBlock)494 static bool AudioSessionExtInfoBlockMarshalling(struct HdfSBuf *data, const struct AudioSessionExtInfo *dataBlock)
495 {
496 if (dataBlock == NULL) {
497 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
498 return false;
499 }
500
501 if (!HdfSbufWriteUnpadBuffer(data, (const uint8_t *)dataBlock, sizeof(struct AudioSessionExtInfo))) {
502 HDF_LOGE("%{public}s: failed to write buffer data", __func__);
503 return false;
504 }
505 return true;
506 }
507
AudioInfoBlockMarshalling(enum AudioPortType type,struct HdfSBuf * data,RouteExtInfo * dataBlock)508 static inline bool AudioInfoBlockMarshalling(enum AudioPortType type, struct HdfSBuf *data, RouteExtInfo *dataBlock)
509 {
510 if (data == NULL || dataBlock == NULL) {
511 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
512 return false;
513 }
514 bool ret = true;
515 switch (type) {
516 case AUDIO_PORT_DEVICE_TYPE:
517 if (!AudioDevExtInfoBlockMarshalling(data, &dataBlock->device)) {
518 HDF_LOGE("%{public}s: write dataBlock->device failed!", __func__);
519 ret = false;
520 }
521 break;
522 case AUDIO_PORT_MIX_TYPE:
523 if (!AudioMixExtInfoBlockMarshalling(data, &dataBlock->mix)) {
524 HDF_LOGE("%{public}s: write dataBlock->mix failed!", __func__);
525 ret = false;
526 }
527 break;
528 case AUDIO_PORT_SESSION_TYPE:
529 if (!AudioSessionExtInfoBlockMarshalling(data, &dataBlock->session)) {
530 HDF_LOGE("%{public}s: write dataBlock->session failed!", __func__);
531 ret = false;
532 }
533 break;
534 case AUDIO_PORT_UNASSIGNED_TYPE:
535 default:
536 ret = false;
537 break;
538 }
539
540 return ret;
541 }
542
AudioRouteNodeBlockMarshalling(struct HdfSBuf * data,const struct AudioRouteNode * dataBlock)543 static bool AudioRouteNodeBlockMarshalling(struct HdfSBuf *data, const struct AudioRouteNode *dataBlock)
544 {
545 if (data == NULL || dataBlock == NULL) {
546 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
547 return false;
548 }
549
550 if (!HdfSbufWriteInt32(data, dataBlock->portId)) {
551 HDF_LOGE("%{public}s: write dataBlock->portId failed!", __func__);
552 return false;
553 }
554
555 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->role)) {
556 HDF_LOGE("%{public}s: write dataBlock->role failed!", __func__);
557 return false;
558 }
559
560 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->type)) {
561 HDF_LOGE("%{public}s: write dataBlock->type failed!", __func__);
562 return false;
563 }
564
565 if (!AudioInfoBlockMarshalling(dataBlock->type, data, (RouteExtInfo*)&dataBlock->ext)) {
566 HDF_LOGE("%{public}s: write dataBlock->ext failed!", __func__);
567 return false;
568 }
569
570 return true;
571 }
572
AudioRouteBlockMarshalling(struct HdfSBuf * data,const struct AudioRoute * dataBlock)573 bool AudioRouteBlockMarshalling(struct HdfSBuf *data, const struct AudioRoute *dataBlock)
574 {
575 if (data == NULL || dataBlock == NULL) {
576 HDF_LOGE("%{public}s: invalid sbuf or data block", __func__);
577 return false;
578 }
579
580 if (!HdfSbufWriteUint32(data, dataBlock->sourcesNum)) {
581 HDF_LOGE("%{public}s: write dataBlock->sourcesLen failed!", __func__);
582 return false;
583 }
584 for (uint32_t i = 0; i < dataBlock->sourcesNum; i++) {
585 if (!AudioRouteNodeBlockMarshalling(data, &(dataBlock->sources)[i])) {
586 HDF_LOGE("%{public}s: write (dataBlock->sources)[i] failed!", __func__);
587 return false;
588 }
589 }
590
591 if (!HdfSbufWriteUint32(data, dataBlock->sinksNum)) {
592 HDF_LOGE("%{public}s: write dataBlock->sinksLen failed!", __func__);
593 return false;
594 }
595 for (uint32_t i = 0; i < dataBlock->sinksNum; i++) {
596 if (!AudioRouteNodeBlockMarshalling(data, &(dataBlock->sinks)[i])) {
597 HDF_LOGE("%{public}s: write (dataBlock->sinks)[i] failed!", __func__);
598 return false;
599 }
600 }
601 return true;
602 }