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