1 /*
2 * Copyright (c) 2022 Shenzhen Kaihong DID 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 "codec_types.h"
16 #include <buffer_handle.h>
17 #include <buffer_handle_utils.h>
18 #include <hdf_log.h>
19 #include <osal_mem.h>
20 #include <securec.h>
21 #include <unistd.h>
22 #include "codec_omx_ext.h"
BufferHandleMarshalling(struct HdfSBuf * data,BufferHandle * handle)23 static bool BufferHandleMarshalling(struct HdfSBuf *data, BufferHandle *handle)
24 {
25 if (handle == NULL) {
26 HDF_LOGE("%{public}s: handle is NULL!", __func__);
27 return false;
28 }
29
30 uint8_t validFd = 0;
31 if (!HdfSbufWriteUint32(data, handle->reserveFds) || !HdfSbufWriteUint32(data, handle->reserveInts) ||
32 !HdfSbufWriteInt32(data, handle->width) || !HdfSbufWriteInt32(data, handle->stride) ||
33 !HdfSbufWriteInt32(data, handle->height) || !HdfSbufWriteInt32(data, handle->size) ||
34 !HdfSbufWriteInt32(data, handle->format) || !HdfSbufWriteInt64(data, handle->usage) ||
35 !HdfSbufWriteUint64(data, handle->phyAddr) || !HdfSbufWriteInt32(data, handle->key)) {
36 HDF_LOGE("%{public}s: write handle failed!", __func__);
37 return false;
38 }
39 if (handle->fd >= 0) {
40 validFd = 1;
41 }
42 if (!HdfSbufWriteUint8(data, validFd)) {
43 HDF_LOGE("%{public}s: write uint8_t failed!", __func__);
44 return false;
45 }
46 if ((validFd != 0) && !HdfSbufWriteFileDescriptor(data, handle->fd)) {
47 HDF_LOGE("%{public}s: write fd failed!", __func__);
48 return false;
49 }
50
51 for (uint32_t i = 0; i < handle->reserveFds; i++) {
52 if (!HdfSbufWriteFileDescriptor(data, handle->reserve[i])) {
53 HDF_LOGE("%{public}s: write handle->reserve[%{public}d] failed!", __func__, i);
54 return false;
55 }
56 }
57
58 for (uint32_t i = 0; i < handle->reserveInts; i++) {
59 if (!HdfSbufWriteInt32(data, handle->reserve[i + handle->reserveFds])) {
60 HDF_LOGE("%{public}s: write handle->reserve[%{public}d] failed!", __func__, i + handle->reserveFds);
61 return false;
62 }
63 }
64
65 return true;
66 }
67
BufferHandleUnmarshalling(struct HdfSBuf * data,BufferHandle ** handle)68 static bool BufferHandleUnmarshalling(struct HdfSBuf *data, BufferHandle **handle)
69 {
70 uint8_t validFd = 0;
71 uint32_t reserveFds = 0;
72 uint32_t reserveInts = 0;
73 if (!HdfSbufReadUint32(data, &reserveFds) || !HdfSbufReadUint32(data, &reserveInts)) {
74 HDF_LOGE("%{public}s: read reserveFds or reserveInts failed!", __func__);
75 return false;
76 }
77
78 BufferHandle *tmpHandle = AllocateBufferHandle(reserveFds, reserveInts);
79 if (tmpHandle == NULL) {
80 HDF_LOGE("%{public}s: allocate buffer handle failed!", __func__);
81 return false;
82 }
83
84 if (!HdfSbufReadInt32(data, &tmpHandle->width) || !HdfSbufReadInt32(data, &tmpHandle->stride) ||
85 !HdfSbufReadInt32(data, &tmpHandle->height) || !HdfSbufReadInt32(data, &tmpHandle->size) ||
86 !HdfSbufReadInt32(data, &tmpHandle->format) || !HdfSbufReadUint64(data, &tmpHandle->usage) ||
87 !HdfSbufReadUint64(data, &tmpHandle->phyAddr) || !HdfSbufReadInt32(data, &tmpHandle->key)) {
88 HDF_LOGE("%{public}s: read handle failed!", __func__);
89 FreeBufferHandle(tmpHandle);
90 return false;
91 }
92
93 if (!HdfSbufReadUint8(data, &validFd)) {
94 HDF_LOGE("%{public}s: read handle bool value failed!", __func__);
95 FreeBufferHandle(tmpHandle);
96 return false;
97 }
98
99 if (validFd != 0) {
100 tmpHandle->fd = HdfSbufReadFileDescriptor(data);
101 }
102
103 for (uint32_t i = 0; i < tmpHandle->reserveFds; i++) {
104 tmpHandle->reserve[i] = HdfSbufReadFileDescriptor(data);
105 }
106
107 for (uint32_t i = 0; i < tmpHandle->reserveInts; i++) {
108 if (!HdfSbufReadInt32(data, &tmpHandle->reserve[tmpHandle->reserveFds + i])) {
109 HDF_LOGE("%{public}s: read reserve bool value failed!", __func__);
110 FreeBufferHandle(tmpHandle);
111 return false;
112 }
113 }
114 *handle = tmpHandle;
115 return true;
116 }
117
OMX_TUNNELSETUPTYPEBlockMarshalling(struct HdfSBuf * data,const struct OMX_TUNNELSETUPTYPE * dataBlock)118 bool OMX_TUNNELSETUPTYPEBlockMarshalling(struct HdfSBuf *data, const struct OMX_TUNNELSETUPTYPE *dataBlock)
119 {
120 if (!HdfSbufWriteUint32(data, dataBlock->nTunnelFlags)) {
121 HDF_LOGE("%{public}s: write dataBlock->nTunnelFlags failed!", __func__);
122 return false;
123 }
124
125 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->eSupplier)) {
126 HDF_LOGE("%{public}s: write dataBlock->eSupplier failed!", __func__);
127 return false;
128 }
129
130 return true;
131 }
132
OMX_TUNNELSETUPTYPEBlockUnmarshalling(struct HdfSBuf * data,struct OMX_TUNNELSETUPTYPE * dataBlock)133 bool OMX_TUNNELSETUPTYPEBlockUnmarshalling(struct HdfSBuf *data, struct OMX_TUNNELSETUPTYPE *dataBlock)
134 {
135 if (dataBlock == NULL) {
136 return false;
137 }
138 if (!HdfSbufReadUint32(data, &dataBlock->nTunnelFlags)) {
139 HDF_LOGE("%{public}s: read dataBlock->nTunnelFlags failed!", __func__);
140 return false;
141 }
142
143 if (!HdfSbufReadInt32(data, (int32_t *)&dataBlock->eSupplier)) {
144 HDF_LOGE("%{public}s: read dataBlock->eSupplier failed!", __func__);
145 return false;
146 }
147
148 return true;
149 }
150
OMX_TUNNELSETUPTYPEFree(struct OMX_TUNNELSETUPTYPE * dataBlock,bool freeSelf)151 void OMX_TUNNELSETUPTYPEFree(struct OMX_TUNNELSETUPTYPE *dataBlock, bool freeSelf)
152 {
153 if (dataBlock == NULL) {
154 return;
155 }
156
157 if (freeSelf) {
158 OsalMemFree(dataBlock);
159 }
160 }
161
CodecBufferMarshalling(struct HdfSBuf * data,const struct OmxCodecBuffer * dataBlock)162 static bool CodecBufferMarshalling(struct HdfSBuf *data, const struct OmxCodecBuffer *dataBlock)
163 {
164 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->bufferType)) {
165 HDF_LOGE("%{public}s: write dataBlock->bufferType failed!", __func__);
166 return false;
167 }
168
169 if (!HdfSbufWriteUint32(data, dataBlock->bufferLen)) {
170 HDF_LOGE("%{public}s: write dataBlock->bufferLen failed!", __func__);
171 return false;
172 }
173 if (dataBlock->bufferLen <= 0) {
174 return true;
175 }
176
177 if (dataBlock->buffer == NULL) {
178 HDF_LOGE("%{public}s: dataBlock->buffer is null", __func__);
179 return false;
180 }
181
182 if (dataBlock->bufferType == CODEC_BUFFER_TYPE_AVSHARE_MEM_FD) {
183 int fd = (int)(uintptr_t)dataBlock->buffer;
184 if (!HdfSbufWriteFileDescriptor(data, fd)) {
185 HDF_LOGE("%{public}s: write fd failed!", __func__);
186 return false;
187 }
188 } else if (dataBlock->bufferType == CODEC_BUFFER_TYPE_HANDLE ||
189 dataBlock->bufferType == CODEC_BUFFER_TYPE_DYNAMIC_HANDLE) {
190 BufferHandle *handle = (BufferHandle *)dataBlock->buffer;
191 if (!BufferHandleMarshalling(data, handle)) {
192 HDF_LOGE("%{public}s: write handle failed!", __func__);
193 return false;
194 }
195 } else {
196 HDF_LOGE("%{public}s:unsupported bufferType %{public}d!", __func__, dataBlock->bufferType);
197 return false;
198 }
199 return true;
200 }
201
OmxCodecBufferBlockMarshalling(struct HdfSBuf * data,const struct OmxCodecBuffer * dataBlock)202 bool OmxCodecBufferBlockMarshalling(struct HdfSBuf *data, const struct OmxCodecBuffer *dataBlock)
203 {
204 uint8_t validFd = 0;
205 if (dataBlock == NULL) {
206 HDF_LOGE("%{public}s: dataBlock is NULL!", __func__);
207 return false;
208 }
209
210 if (!HdfSbufWriteUint32(data, dataBlock->bufferId) || !HdfSbufWriteUint32(data, dataBlock->size)) {
211 HDF_LOGE("%{public}s: write dataBlock:bufferId or size failed!", __func__);
212 return false;
213 }
214
215 if (!HdfSbufWriteUnpadBuffer(data, (const uint8_t *)&dataBlock->version, sizeof(union OMX_VERSIONTYPE))) {
216 HDF_LOGE("%{public}s: write dataBlock->version failed!", __func__);
217 return false;
218 }
219
220 if (!CodecBufferMarshalling(data, dataBlock)) {
221 return false;
222 }
223
224 if (!HdfSbufWriteUint32(data, dataBlock->allocLen) || !HdfSbufWriteUint32(data, dataBlock->filledLen) ||
225 !HdfSbufWriteUint32(data, dataBlock->offset)) {
226 HDF_LOGE("%{public}s: write dataBlock:allocLen, filledLen or offset failed!", __func__);
227 return false;
228 }
229
230 validFd = dataBlock->fenceFd >= 0;
231 if (!HdfSbufWriteUint8(data, validFd)) {
232 HDF_LOGE("%{public}s: write validFd failed!", __func__);
233 return false;
234 }
235 if (validFd != 0 && !HdfSbufWriteFileDescriptor(data, dataBlock->fenceFd)) {
236 HDF_LOGE("%{public}s: write dataBlock->fenceFd failed!", __func__);
237 return false;
238 }
239
240 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->type) || !HdfSbufWriteInt64(data, dataBlock->pts) ||
241 !HdfSbufWriteUint32(data, dataBlock->flag)) {
242 HDF_LOGE("%{public}s: write dataBlock:type, pts or flag failed!", __func__);
243 return false;
244 }
245 return true;
246 }
247
CodecBufferUnmarshalling(struct HdfSBuf * data,struct OmxCodecBuffer * dataBlock)248 static bool CodecBufferUnmarshalling(struct HdfSBuf *data, struct OmxCodecBuffer *dataBlock)
249 {
250 if (dataBlock == NULL) {
251 HDF_LOGE("%{public}s: dataBlock is NULL!", __func__);
252 return false;
253 }
254 if (!HdfSbufReadInt32(data, (int32_t *)&dataBlock->bufferType)) {
255 HDF_LOGE("%{public}s: read dataBlock->bufferType failed!", __func__);
256 return false;
257 }
258
259 uint32_t bufferCpLen = 0;
260 if (!HdfSbufReadUint32(data, &bufferCpLen)) {
261 HDF_LOGE("%{public}s: read bufferCpLen failed!", __func__);
262 return false;
263 }
264 dataBlock->bufferLen = bufferCpLen;
265 if (dataBlock->bufferLen <= 0) {
266 dataBlock->buffer = NULL;
267 return true;
268 }
269 if (dataBlock->bufferType == CODEC_BUFFER_TYPE_AVSHARE_MEM_FD) {
270 int fd = HdfSbufReadFileDescriptor(data);
271 if (fd < 0) {
272 HDF_LOGE("%{public}s: read fd failed!", __func__);
273 return false;
274 }
275 dataBlock->buffer = (uint8_t *)(unsigned long)fd;
276 } else if (dataBlock->bufferType == CODEC_BUFFER_TYPE_HANDLE ||
277 dataBlock->bufferType == CODEC_BUFFER_TYPE_DYNAMIC_HANDLE) {
278 BufferHandle *handle = NULL;
279 if (!BufferHandleUnmarshalling(data, &handle)) {
280 HDF_LOGE("%{public}s: read bufferhandle failed!", __func__);
281 return false;
282 }
283 dataBlock->buffer = (uint8_t *)handle;
284 } else {
285 HDF_LOGE("%{public}s: unsupported bufferType %{public}d", __func__, dataBlock->bufferType);
286 return false;
287 }
288 return true;
289 }
290
ReleaseOmxCodecBuffer(struct OmxCodecBuffer * codecBuffer)291 void ReleaseOmxCodecBuffer(struct OmxCodecBuffer *codecBuffer)
292 {
293 if (codecBuffer == NULL) {
294 return;
295 }
296
297 if (codecBuffer->fenceFd >= 0) {
298 close(codecBuffer->fenceFd);
299 codecBuffer->fenceFd = -1;
300 }
301 if (codecBuffer->buffer == NULL || codecBuffer->bufferLen == 0) {
302 return;
303 }
304
305 if (codecBuffer->bufferType == CODEC_BUFFER_TYPE_DYNAMIC_HANDLE ||
306 codecBuffer->bufferType == CODEC_BUFFER_TYPE_HANDLE) {
307 FreeBufferHandle((BufferHandle *)codecBuffer->buffer);
308 } else if (codecBuffer->bufferType != CODEC_BUFFER_TYPE_AVSHARE_MEM_FD) {
309 OsalMemFree(codecBuffer->buffer);
310 } else {
311 int fd = (uintptr_t)codecBuffer->buffer;
312 close(fd);
313 }
314 codecBuffer->buffer = NULL;
315 codecBuffer->bufferLen = 0;
316 }
317
InitOmxCodecBuffer(struct OmxCodecBuffer * codecBuffer)318 void InitOmxCodecBuffer(struct OmxCodecBuffer *codecBuffer)
319 {
320 if (codecBuffer != NULL) {
321 (void)memset_s(codecBuffer, sizeof(struct OmxCodecBuffer), 0, sizeof(struct OmxCodecBuffer));
322 codecBuffer->fenceFd = -1;
323 }
324 }
OmxCodecBufferBlockUnmarshalling(struct HdfSBuf * data,struct OmxCodecBuffer * dataBlock)325 bool OmxCodecBufferBlockUnmarshalling(struct HdfSBuf *data, struct OmxCodecBuffer *dataBlock)
326 {
327 uint8_t validFd = 0;
328 if (dataBlock == NULL || data == NULL) {
329 HDF_LOGE("%{public}s: dataBlock or data is NULL!", __func__);
330 return false;
331 }
332 if (!HdfSbufReadUint32(data, &dataBlock->bufferId) || !HdfSbufReadUint32(data, &dataBlock->size)) {
333 HDF_LOGE("%{public}s: read dataBlock:bufferId or size failed!", __func__);
334 return false;
335 }
336 const union OMX_VERSIONTYPE *versionCp =
337 (const union OMX_VERSIONTYPE *)HdfSbufReadUnpadBuffer(data, sizeof(union OMX_VERSIONTYPE));
338 if (versionCp == NULL) {
339 HDF_LOGE("%{public}s: read versionCp failed!", __func__);
340 return false;
341 }
342 (void)memcpy_s(&dataBlock->version, sizeof(union OMX_VERSIONTYPE), versionCp, sizeof(union OMX_VERSIONTYPE));
343 if (!CodecBufferUnmarshalling(data, dataBlock)) {
344 return false;
345 }
346 if (!HdfSbufReadUint32(data, &dataBlock->allocLen) || !HdfSbufReadUint32(data, &dataBlock->filledLen) ||
347 !HdfSbufReadUint32(data, &dataBlock->offset)) {
348 HDF_LOGE("%{public}s: read dataBlock:allocLen, filledLen or offset failed!", __func__);
349 return false;
350 }
351
352 if (!HdfSbufReadUint8(data, &validFd)) {
353 HDF_LOGE("%{public}s: read validFd failed!", __func__);
354 return false;
355 }
356
357 if (validFd != 0) {
358 dataBlock->fenceFd = HdfSbufReadFileDescriptor(data);
359 }
360
361 if (!HdfSbufReadInt32(data, (int32_t *)&dataBlock->type) || !HdfSbufReadInt64(data, &dataBlock->pts) ||
362 !HdfSbufReadUint32(data, &dataBlock->flag)) {
363 HDF_LOGE("%{public}s: read dataBlock:type, pts or flag failed!", __func__);
364 return false;
365 }
366 return true;
367 }
368
RangeValueBlockMarshalling(struct HdfSBuf * data,const RangeValue * dataBlock)369 bool RangeValueBlockMarshalling(struct HdfSBuf *data, const RangeValue *dataBlock)
370 {
371 if (!HdfSbufWriteInt32(data, dataBlock->min)) {
372 HDF_LOGE("%{public}s: write dataBlock->min failed!", __func__);
373 return false;
374 }
375
376 if (!HdfSbufWriteInt32(data, dataBlock->max)) {
377 HDF_LOGE("%{public}s: write dataBlock->max failed!", __func__);
378 return false;
379 }
380
381 return true;
382 }
383
RangeValueBlockUnmarshalling(struct HdfSBuf * data,RangeValue * dataBlock)384 bool RangeValueBlockUnmarshalling(struct HdfSBuf *data, RangeValue *dataBlock)
385 {
386 if (dataBlock == NULL) {
387 return false;
388 }
389 if (!HdfSbufReadInt32(data, &dataBlock->min)) {
390 HDF_LOGE("%{public}s: read dataBlock->min failed!", __func__);
391 return false;
392 }
393
394 if (!HdfSbufReadInt32(data, &dataBlock->max)) {
395 HDF_LOGE("%{public}s: read dataBlock->max failed!", __func__);
396 return false;
397 }
398
399 return true;
400 }
401
RangeValueFree(RangeValue * dataBlock,bool freeSelf)402 void RangeValueFree(RangeValue *dataBlock, bool freeSelf)
403 {
404 if (dataBlock == NULL) {
405 return;
406 }
407
408 if (freeSelf) {
409 OsalMemFree(dataBlock);
410 }
411 }
412
RectBlockMarshalling(struct HdfSBuf * data,const Rect * dataBlock)413 bool RectBlockMarshalling(struct HdfSBuf *data, const Rect *dataBlock)
414 {
415 if (!HdfSbufWriteInt32(data, dataBlock->width)) {
416 HDF_LOGE("%{public}s: write dataBlock->width failed!", __func__);
417 return false;
418 }
419
420 if (!HdfSbufWriteInt32(data, dataBlock->height)) {
421 HDF_LOGE("%{public}s: write dataBlock->height failed!", __func__);
422 return false;
423 }
424
425 return true;
426 }
427
RectBlockUnmarshalling(struct HdfSBuf * data,Rect * dataBlock)428 bool RectBlockUnmarshalling(struct HdfSBuf *data, Rect *dataBlock)
429 {
430 if (dataBlock == NULL) {
431 return false;
432 }
433 if (!HdfSbufReadInt32(data, &dataBlock->width)) {
434 HDF_LOGE("%{public}s: read dataBlock->width failed!", __func__);
435 return false;
436 }
437
438 if (!HdfSbufReadInt32(data, &dataBlock->height)) {
439 HDF_LOGE("%{public}s: read dataBlock->height failed!", __func__);
440 return false;
441 }
442
443 return true;
444 }
445
AlignmentBlockMarshalling(struct HdfSBuf * data,const Alignment * dataBlock)446 bool AlignmentBlockMarshalling(struct HdfSBuf *data, const Alignment *dataBlock)
447 {
448 if (!HdfSbufWriteInt32(data, dataBlock->widthAlignment)) {
449 HDF_LOGE("%{public}s: write dataBlock->widthAlignment failed!", __func__);
450 return false;
451 }
452
453 if (!HdfSbufWriteInt32(data, dataBlock->heightAlignment)) {
454 HDF_LOGE("%{public}s: write dataBlock->heightAlignment failed!", __func__);
455 return false;
456 }
457
458 return true;
459 }
460
AlignmentBlockUnmarshalling(struct HdfSBuf * data,Alignment * dataBlock)461 bool AlignmentBlockUnmarshalling(struct HdfSBuf *data, Alignment *dataBlock)
462 {
463 if (dataBlock == NULL) {
464 return false;
465 }
466 if (!HdfSbufReadInt32(data, &dataBlock->widthAlignment)) {
467 HDF_LOGE("%{public}s: read dataBlock->widthAlignment failed!", __func__);
468 return false;
469 }
470
471 if (!HdfSbufReadInt32(data, &dataBlock->heightAlignment)) {
472 HDF_LOGE("%{public}s: read dataBlock->heightAlignment failed!", __func__);
473 return false;
474 }
475
476 return true;
477 }
478
VideoPortCapBlockMarshalling(struct HdfSBuf * data,const CodecVideoPortCap * dataBlock)479 bool VideoPortCapBlockMarshalling(struct HdfSBuf *data, const CodecVideoPortCap *dataBlock)
480 {
481 if (!RectBlockMarshalling(data, &dataBlock->minSize)) {
482 HDF_LOGE("%{public}s: write dataBlock->minSize failed!", __func__);
483 return false;
484 }
485
486 if (!RectBlockMarshalling(data, &dataBlock->maxSize)) {
487 HDF_LOGE("%{public}s: write dataBlock->maxSize failed!", __func__);
488 return false;
489 }
490
491 if (!AlignmentBlockMarshalling(data, &dataBlock->whAlignment)) {
492 HDF_LOGE("%{public}s: write dataBlock->whAlignment failed!", __func__);
493 return false;
494 }
495
496 if (!RangeValueBlockMarshalling(data, &dataBlock->blockCount)) {
497 HDF_LOGE("%{public}s: write dataBlock->blockCount failed!", __func__);
498 return false;
499 }
500
501 if (!RangeValueBlockMarshalling(data, &dataBlock->blocksPerSecond)) {
502 HDF_LOGE("%{public}s: write dataBlock->blocksPerSecond failed!", __func__);
503 return false;
504 }
505
506 if (!RectBlockMarshalling(data, &dataBlock->blockSize)) {
507 HDF_LOGE("%{public}s: write dataBlock->blockSize failed!", __func__);
508 return false;
509 }
510
511 for (uint32_t i = 0; i < PIX_FORMAT_NUM; i++) {
512 if (!HdfSbufWriteInt32(data, (dataBlock->supportPixFmts)[i])) {
513 HDF_LOGE("%{public}s: write (dataBlock->supportPixFmts)[i] failed!", __func__);
514 return false;
515 }
516 }
517
518 return true;
519 }
520
VideoPortCapBlockUnmarshalling(struct HdfSBuf * data,CodecVideoPortCap * dataBlock)521 bool VideoPortCapBlockUnmarshalling(struct HdfSBuf *data, CodecVideoPortCap *dataBlock)
522 {
523 if (dataBlock == NULL) {
524 return false;
525 }
526 if (!RectBlockUnmarshalling(data, &dataBlock->minSize)) {
527 HDF_LOGE("%{public}s: read &dataBlock->minSize failed!", __func__);
528 return false;
529 }
530
531 if (!RectBlockUnmarshalling(data, &dataBlock->maxSize)) {
532 HDF_LOGE("%{public}s: read &dataBlock->maxSize failed!", __func__);
533 return false;
534 }
535
536 if (!AlignmentBlockUnmarshalling(data, &dataBlock->whAlignment)) {
537 HDF_LOGE("%{public}s: read &dataBlock->whAlignment failed!", __func__);
538 return false;
539 }
540
541 if (!RangeValueBlockUnmarshalling(data, &dataBlock->blockCount)) {
542 HDF_LOGE("%{public}s: read &dataBlock->blockCount failed!", __func__);
543 return false;
544 }
545
546 if (!RangeValueBlockUnmarshalling(data, &dataBlock->blocksPerSecond)) {
547 HDF_LOGE("%{public}s: read &dataBlock->blocksPerSecond failed!", __func__);
548 return false;
549 }
550
551 if (!RectBlockUnmarshalling(data, &dataBlock->blockSize)) {
552 HDF_LOGE("%{public}s: read &dataBlock->blockSize failed!", __func__);
553 return false;
554 }
555
556 for (uint32_t i = 0; i < PIX_FORMAT_NUM; i++) {
557 if (!HdfSbufReadInt32(data, &(dataBlock->supportPixFmts)[i])) {
558 HDF_LOGE("%{public}s: read supportPixFmts[i] failed!", __func__);
559 return false;
560 }
561 }
562
563 return true;
564 }
565
AudioPortCapBlockMarshalling(struct HdfSBuf * data,const CodecAudioPortCap * dataBlock)566 bool AudioPortCapBlockMarshalling(struct HdfSBuf *data, const CodecAudioPortCap *dataBlock)
567 {
568 for (uint32_t i = 0; i < SAMPLE_FORMAT_NUM; i++) {
569 if (!HdfSbufWriteInt32(data, (dataBlock->sampleFormats)[i])) {
570 HDF_LOGE("%{public}s: write (dataBlock->sampleFormats)[i] failed!", __func__);
571 return false;
572 }
573 }
574
575 for (uint32_t i = 0; i < SAMPLE_RATE_NUM; i++) {
576 if (!HdfSbufWriteInt32(data, (dataBlock->sampleRate)[i])) {
577 HDF_LOGE("%{public}s: write (dataBlock->sampleRate)[i] failed!", __func__);
578 return false;
579 }
580 }
581
582 for (uint32_t i = 0; i < CHANNEL_NUM; i++) {
583 if (!HdfSbufWriteInt32(data, (dataBlock->channelLayouts)[i])) {
584 HDF_LOGE("%{public}s: write (dataBlock->channelLayouts)[i] failed!", __func__);
585 return false;
586 }
587 }
588
589 for (uint32_t i = 0; i < CHANNEL_NUM; i++) {
590 if (!HdfSbufWriteInt32(data, (dataBlock->channelCount)[i])) {
591 HDF_LOGE("%{public}s: write (dataBlock->channelCount)[i] failed!", __func__);
592 return false;
593 }
594 }
595
596 return true;
597 }
598
AudioPortCapBlockUnmarshalling(struct HdfSBuf * data,CodecAudioPortCap * dataBlock)599 bool AudioPortCapBlockUnmarshalling(struct HdfSBuf *data, CodecAudioPortCap *dataBlock)
600 {
601 if (dataBlock == NULL) {
602 return false;
603 }
604
605 for (uint32_t i = 0; i < SAMPLE_FORMAT_NUM; i++) {
606 if (!HdfSbufReadInt32(data, &(dataBlock->sampleFormats)[i])) {
607 HDF_LOGE("%{public}s: read sampleFormats[i] failed!", __func__);
608 return false;
609 }
610 }
611
612 for (uint32_t i = 0; i < SAMPLE_RATE_NUM; i++) {
613 if (!HdfSbufReadInt32(data, &(dataBlock->sampleRate)[i])) {
614 HDF_LOGE("%{public}s: read sampleRate[i] failed!", __func__);
615 return false;
616 }
617 }
618
619 for (uint32_t i = 0; i < CHANNEL_NUM; i++) {
620 if (!HdfSbufReadInt32(data, &(dataBlock->channelLayouts)[i])) {
621 HDF_LOGE("%{public}s: read channelLayouts[i] failed!", __func__);
622 return false;
623 }
624 }
625
626 for (uint32_t i = 0; i < CHANNEL_NUM; i++) {
627 if (!HdfSbufReadInt32(data, &(dataBlock->channelCount)[i])) {
628 HDF_LOGE("%{public}s: read channelCount[i] failed!", __func__);
629 return false;
630 }
631 }
632
633 return true;
634 }
635
AudioPortCapFree(CodecAudioPortCap * dataBlock,bool freeSelf)636 void AudioPortCapFree(CodecAudioPortCap *dataBlock, bool freeSelf)
637 {
638 if (dataBlock == NULL) {
639 return;
640 }
641
642 if (freeSelf) {
643 OsalMemFree(dataBlock);
644 }
645 }
646
CodecCompCapabilityBlockMarshalling(struct HdfSBuf * data,const CodecCompCapability * dataBlock)647 bool CodecCompCapabilityBlockMarshalling(struct HdfSBuf *data, const CodecCompCapability *dataBlock)
648 {
649 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->role)) {
650 HDF_LOGE("%{public}s: write dataBlock->role failed!", __func__);
651 return false;
652 }
653
654 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->type)) {
655 HDF_LOGE("%{public}s: write dataBlock->type failed!", __func__);
656 return false;
657 }
658
659 for (uint32_t i = 0; i < NAME_LENGTH; i++) {
660 if (!HdfSbufWriteUint8(data, (uint8_t)(dataBlock->compName)[i])) {
661 HDF_LOGE("%{public}s: write (dataBlock->compName)[i] failed!", __func__);
662 return false;
663 }
664 }
665
666 for (uint32_t i = 0; i < PROFILE_NUM; i++) {
667 if (!HdfSbufWriteInt32(data, (dataBlock->supportProfiles)[i])) {
668 HDF_LOGE("%{public}s: write (dataBlock->supportProfiles)[i] failed!", __func__);
669 return false;
670 }
671 }
672
673 if (!HdfSbufWriteInt32(data, dataBlock->maxInst)) {
674 HDF_LOGE("%{public}s: write dataBlock->maxInst failed!", __func__);
675 return false;
676 }
677
678 if (!HdfSbufWriteInt8(data, dataBlock->isSoftwareCodec ? 1 : 0)) {
679 HDF_LOGE("%{public}s: write dataBlock->isSoftwareCodec failed!", __func__);
680 return false;
681 }
682
683 if (!HdfSbufWriteInt32(data, dataBlock->processModeMask)) {
684 HDF_LOGE("%{public}s: write dataBlock->processModeMask failed!", __func__);
685 return false;
686 }
687
688 if (!HdfSbufWriteUint32(data, dataBlock->capsMask)) {
689 HDF_LOGE("%{public}s: write dataBlock->capsMask failed!", __func__);
690 return false;
691 }
692
693 if (!RangeValueBlockMarshalling(data, &dataBlock->bitRate)) {
694 HDF_LOGE("%{public}s: write dataBlock->bitRate failed!", __func__);
695 return false;
696 }
697
698 if (!HdfSbufWriteUnpadBuffer(data, (const uint8_t *)&dataBlock->port, sizeof(PortCap))) {
699 HDF_LOGE("%{public}s: write dataBlock->port failed!", __func__);
700 return false;
701 }
702
703 return true;
704 }
705
CodecCompCapabilityBlockUnmarshalling(struct HdfSBuf * data,CodecCompCapability * dataBlock)706 bool CodecCompCapabilityBlockUnmarshalling(struct HdfSBuf *data, CodecCompCapability *dataBlock)
707 {
708 if (dataBlock == NULL) {
709 return false;
710 }
711
712 if (!HdfSbufReadInt32(data, (int32_t *)&dataBlock->role) ||
713 !HdfSbufReadInt32(data, (int32_t *)&dataBlock->type)) {
714 HDF_LOGE("%{public}s: read dataBlock->role or dataBlock->type failed!", __func__);
715 return false;
716 }
717
718 for (uint32_t i = 0; i < NAME_LENGTH; i++) {
719 if (!HdfSbufReadUint8(data, (uint8_t *)&(dataBlock->compName)[i])) {
720 HDF_LOGE("%{public}s: read compName[i] failed!", __func__);
721 return false;
722 }
723 }
724
725 for (uint32_t j = 0; j < PROFILE_NUM; j++) {
726 if (!HdfSbufReadInt32(data, &(dataBlock->supportProfiles)[j])) {
727 HDF_LOGE("%{public}s: read supportProfiles[i] failed!", __func__);
728 return false;
729 }
730 }
731
732 if (!HdfSbufReadInt32(data, &dataBlock->maxInst)) {
733 HDF_LOGE("%{public}s: read dataBlock->maxInst failed!", __func__);
734 return false;
735 }
736
737 if (!HdfSbufReadInt8(data, (int8_t *)&dataBlock->isSoftwareCodec)) {
738 HDF_LOGE("%{public}s: read dataBlock->isSoftwareCodec failed!", __func__);
739 return false;
740 }
741
742 if (!HdfSbufReadInt32(data, &dataBlock->processModeMask)) {
743 HDF_LOGE("%{public}s: read dataBlock->processModeMask failed!", __func__);
744 return false;
745 }
746
747 if (!HdfSbufReadUint32(data, &dataBlock->capsMask)) {
748 HDF_LOGE("%{public}s: read dataBlock->capsMask failed!", __func__);
749 return false;
750 }
751
752 if (!RangeValueBlockUnmarshalling(data, &dataBlock->bitRate)) {
753 HDF_LOGE("%{public}s: read &dataBlock->bitRate failed!", __func__);
754 return false;
755 }
756
757 const PortCap *portCp = (const PortCap *)HdfSbufReadUnpadBuffer(data, sizeof(PortCap));
758 if (portCp == NULL) {
759 HDF_LOGE("%{public}s: read portCp failed!", __func__);
760 return false;
761 }
762 (void)memcpy_s(&dataBlock->port, sizeof(PortCap), portCp, sizeof(PortCap));
763
764 return true;
765 }
766