1 /*
2 * Copyright (c) 2022-2023 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 <osal_mem.h>
19 #include <securec.h>
20 #include <unistd.h>
21 #include "codec_omx_ext.h"
22 #include "codec_log_wrapper.h"
23
BufferHandleMarshalling(struct HdfSBuf * data,BufferHandle * handle)24 static bool BufferHandleMarshalling(struct HdfSBuf *data, BufferHandle *handle)
25 {
26 if (handle == NULL) {
27 CODEC_LOGE("handle is NULL!");
28 return false;
29 }
30
31 uint8_t validFd = 0;
32 if (!HdfSbufWriteUint32(data, handle->reserveFds) || !HdfSbufWriteUint32(data, handle->reserveInts) ||
33 !HdfSbufWriteInt32(data, handle->width) || !HdfSbufWriteInt32(data, handle->stride) ||
34 !HdfSbufWriteInt32(data, handle->height) || !HdfSbufWriteInt32(data, handle->size) ||
35 !HdfSbufWriteInt32(data, handle->format) || !HdfSbufWriteInt64(data, handle->usage) ||
36 !HdfSbufWriteUint64(data, handle->phyAddr)) {
37 CODEC_LOGE("write handle failed!");
38 return false;
39 }
40 if (handle->fd >= 0) {
41 validFd = 1;
42 }
43 if (!HdfSbufWriteUint8(data, validFd)) {
44 CODEC_LOGE("write uint8_t failed!");
45 return false;
46 }
47 if ((validFd != 0) && !HdfSbufWriteFileDescriptor(data, handle->fd)) {
48 CODEC_LOGE("write fd failed!");
49 return false;
50 }
51
52 for (uint32_t i = 0; i < handle->reserveFds; i++) {
53 if (!HdfSbufWriteFileDescriptor(data, handle->reserve[i])) {
54 CODEC_LOGE("write handle->reserve[%{public}d] failed!", i);
55 return false;
56 }
57 }
58
59 for (uint32_t i = 0; i < handle->reserveInts; i++) {
60 if (!HdfSbufWriteInt32(data, handle->reserve[i + handle->reserveFds])) {
61 CODEC_LOGE("write handle->reserve[%{public}d] failed!", i + handle->reserveFds);
62 return false;
63 }
64 }
65
66 return true;
67 }
68
BufferHandleUnmarshalling(struct HdfSBuf * data,BufferHandle ** handle)69 static bool BufferHandleUnmarshalling(struct HdfSBuf *data, BufferHandle **handle)
70 {
71 uint8_t validFd = 0;
72 uint32_t reserveFds = 0;
73 uint32_t reserveInts = 0;
74 if (!HdfSbufReadUint32(data, &reserveFds) || !HdfSbufReadUint32(data, &reserveInts)) {
75 CODEC_LOGE("read reserveFds or reserveInts failed!");
76 return false;
77 }
78
79 BufferHandle *tmpHandle = AllocateBufferHandle(reserveFds, reserveInts);
80 if (tmpHandle == NULL) {
81 CODEC_LOGE("allocate buffer handle failed!");
82 return false;
83 }
84
85 if (!HdfSbufReadInt32(data, &tmpHandle->width) || !HdfSbufReadInt32(data, &tmpHandle->stride) ||
86 !HdfSbufReadInt32(data, &tmpHandle->height) || !HdfSbufReadInt32(data, &tmpHandle->size) ||
87 !HdfSbufReadInt32(data, &tmpHandle->format) || !HdfSbufReadUint64(data, &tmpHandle->usage) ||
88 !HdfSbufReadUint64(data, &tmpHandle->phyAddr)) {
89 CODEC_LOGE("read handle failed!");
90 FreeBufferHandle(tmpHandle);
91 return false;
92 }
93
94 if (!HdfSbufReadUint8(data, &validFd)) {
95 CODEC_LOGE("read handle bool value failed!");
96 FreeBufferHandle(tmpHandle);
97 return false;
98 }
99
100 if (validFd != 0) {
101 tmpHandle->fd = HdfSbufReadFileDescriptor(data);
102 }
103
104 for (uint32_t i = 0; i < tmpHandle->reserveFds; i++) {
105 tmpHandle->reserve[i] = HdfSbufReadFileDescriptor(data);
106 }
107
108 for (uint32_t i = 0; i < tmpHandle->reserveInts; i++) {
109 if (!HdfSbufReadInt32(data, &tmpHandle->reserve[tmpHandle->reserveFds + i])) {
110 CODEC_LOGE("read reserve bool value failed!");
111 FreeBufferHandle(tmpHandle);
112 return false;
113 }
114 }
115 *handle = tmpHandle;
116 return true;
117 }
118
OMX_TUNNELSETUPTYPEBlockMarshalling(struct HdfSBuf * data,const struct OMX_TUNNELSETUPTYPE * dataBlock)119 bool OMX_TUNNELSETUPTYPEBlockMarshalling(struct HdfSBuf *data, const struct OMX_TUNNELSETUPTYPE *dataBlock)
120 {
121 if (!HdfSbufWriteUint32(data, dataBlock->nTunnelFlags)) {
122 CODEC_LOGE("write dataBlock->nTunnelFlags failed!");
123 return false;
124 }
125
126 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->eSupplier)) {
127 CODEC_LOGE("write dataBlock->eSupplier failed!");
128 return false;
129 }
130
131 return true;
132 }
133
OMX_TUNNELSETUPTYPEBlockUnmarshalling(struct HdfSBuf * data,struct OMX_TUNNELSETUPTYPE * dataBlock)134 bool OMX_TUNNELSETUPTYPEBlockUnmarshalling(struct HdfSBuf *data, struct OMX_TUNNELSETUPTYPE *dataBlock)
135 {
136 if (dataBlock == NULL) {
137 return false;
138 }
139 if (!HdfSbufReadUint32(data, &dataBlock->nTunnelFlags)) {
140 CODEC_LOGE("read dataBlock->nTunnelFlags failed!");
141 return false;
142 }
143
144 if (!HdfSbufReadInt32(data, (int32_t *)&dataBlock->eSupplier)) {
145 CODEC_LOGE("read dataBlock->eSupplier failed!");
146 return false;
147 }
148
149 return true;
150 }
151
OMX_TUNNELSETUPTYPEFree(struct OMX_TUNNELSETUPTYPE * dataBlock,bool freeSelf)152 void OMX_TUNNELSETUPTYPEFree(struct OMX_TUNNELSETUPTYPE *dataBlock, bool freeSelf)
153 {
154 if (dataBlock == NULL) {
155 return;
156 }
157
158 if (freeSelf) {
159 OsalMemFree(dataBlock);
160 }
161 }
162
CodecBufferMarshalling(struct HdfSBuf * data,const struct OmxCodecBuffer * dataBlock)163 static bool CodecBufferMarshalling(struct HdfSBuf *data, const struct OmxCodecBuffer *dataBlock)
164 {
165 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->bufferType)) {
166 CODEC_LOGE("write dataBlock->bufferType failed!");
167 return false;
168 }
169
170 if (!HdfSbufWriteUint32(data, dataBlock->bufferLen)) {
171 CODEC_LOGE("write dataBlock->bufferLen failed!");
172 return false;
173 }
174 if (dataBlock->bufferLen <= 0) {
175 return true;
176 }
177
178 if (dataBlock->buffer == NULL) {
179 CODEC_LOGE("dataBlock->buffer is null");
180 return false;
181 }
182
183 if (dataBlock->bufferType == CODEC_BUFFER_TYPE_AVSHARE_MEM_FD) {
184 int fd = (int)(uintptr_t)dataBlock->buffer;
185 if (!HdfSbufWriteFileDescriptor(data, fd)) {
186 CODEC_LOGE("write fd failed!");
187 return false;
188 }
189 } else if (dataBlock->bufferType == CODEC_BUFFER_TYPE_HANDLE ||
190 dataBlock->bufferType == CODEC_BUFFER_TYPE_DYNAMIC_HANDLE) {
191 BufferHandle *handle = (BufferHandle *)dataBlock->buffer;
192 if (!BufferHandleMarshalling(data, handle)) {
193 CODEC_LOGE("write handle failed!");
194 return false;
195 }
196 } else {
197 CODEC_LOGE("unsupported bufferType %{public}d!", dataBlock->bufferType);
198 return false;
199 }
200 return true;
201 }
202
OmxCodecBufferBlockMarshalling(struct HdfSBuf * data,const struct OmxCodecBuffer * dataBlock)203 bool OmxCodecBufferBlockMarshalling(struct HdfSBuf *data, const struct OmxCodecBuffer *dataBlock)
204 {
205 uint8_t validFd = 0;
206 if (dataBlock == NULL) {
207 CODEC_LOGE("dataBlock is NULL!");
208 return false;
209 }
210
211 if (!HdfSbufWriteUint32(data, dataBlock->bufferId) || !HdfSbufWriteUint32(data, dataBlock->size)) {
212 CODEC_LOGE("write dataBlock:bufferId or size failed!");
213 return false;
214 }
215
216 if (!HdfSbufWriteUnpadBuffer(data, (const uint8_t *)&dataBlock->version, sizeof(union OMX_VERSIONTYPE))) {
217 CODEC_LOGE("write dataBlock->version failed!");
218 return false;
219 }
220
221 if (!CodecBufferMarshalling(data, dataBlock)) {
222 return false;
223 }
224
225 if (!HdfSbufWriteUint32(data, dataBlock->allocLen) || !HdfSbufWriteUint32(data, dataBlock->filledLen) ||
226 !HdfSbufWriteUint32(data, dataBlock->offset)) {
227 CODEC_LOGE("write dataBlock:allocLen, filledLen or offset failed!");
228 return false;
229 }
230
231 validFd = dataBlock->fenceFd >= 0;
232 if (!HdfSbufWriteUint8(data, validFd)) {
233 CODEC_LOGE("write validFd failed!");
234 return false;
235 }
236 if (validFd != 0 && !HdfSbufWriteFileDescriptor(data, dataBlock->fenceFd)) {
237 CODEC_LOGE("write dataBlock->fenceFd failed!");
238 return false;
239 }
240
241 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->type) || !HdfSbufWriteInt64(data, dataBlock->pts) ||
242 !HdfSbufWriteUint32(data, dataBlock->flag)) {
243 CODEC_LOGE("write dataBlock:type, pts or flag failed!");
244 return false;
245 }
246 return true;
247 }
248
CodecBufferUnmarshalling(struct HdfSBuf * data,struct OmxCodecBuffer * dataBlock)249 static bool CodecBufferUnmarshalling(struct HdfSBuf *data, struct OmxCodecBuffer *dataBlock)
250 {
251 if (dataBlock == NULL) {
252 CODEC_LOGE("dataBlock is NULL!");
253 return false;
254 }
255 if (!HdfSbufReadInt32(data, (int32_t *)&dataBlock->bufferType)) {
256 CODEC_LOGE("read dataBlock->bufferType failed!");
257 return false;
258 }
259
260 uint32_t bufferCpLen = 0;
261 if (!HdfSbufReadUint32(data, &bufferCpLen)) {
262 CODEC_LOGE("read bufferCpLen failed!");
263 return false;
264 }
265 dataBlock->bufferLen = bufferCpLen;
266 if (dataBlock->bufferLen <= 0) {
267 dataBlock->buffer = NULL;
268 return true;
269 }
270 if (dataBlock->bufferType == CODEC_BUFFER_TYPE_AVSHARE_MEM_FD) {
271 int fd = HdfSbufReadFileDescriptor(data);
272 if (fd < 0) {
273 CODEC_LOGE("read fd failed!");
274 return false;
275 }
276 dataBlock->buffer = (uint8_t *)(unsigned long)fd;
277 } else if (dataBlock->bufferType == CODEC_BUFFER_TYPE_HANDLE ||
278 dataBlock->bufferType == CODEC_BUFFER_TYPE_DYNAMIC_HANDLE) {
279 BufferHandle *handle = NULL;
280 if (!BufferHandleUnmarshalling(data, &handle)) {
281 CODEC_LOGE("read bufferhandle failed!");
282 return false;
283 }
284 dataBlock->buffer = (uint8_t *)handle;
285 } else {
286 CODEC_LOGE("unsupported bufferType %{public}d", dataBlock->bufferType);
287 return false;
288 }
289 return true;
290 }
291
ReleaseOmxCodecBuffer(struct OmxCodecBuffer * codecBuffer)292 void ReleaseOmxCodecBuffer(struct OmxCodecBuffer *codecBuffer)
293 {
294 if (codecBuffer == NULL) {
295 return;
296 }
297
298 if (codecBuffer->fenceFd >= 0) {
299 close(codecBuffer->fenceFd);
300 codecBuffer->fenceFd = -1;
301 }
302 if (codecBuffer->buffer == NULL || codecBuffer->bufferLen == 0) {
303 return;
304 }
305
306 if (codecBuffer->bufferType == CODEC_BUFFER_TYPE_DYNAMIC_HANDLE ||
307 codecBuffer->bufferType == CODEC_BUFFER_TYPE_HANDLE) {
308 FreeBufferHandle((BufferHandle *)codecBuffer->buffer);
309 } else if (codecBuffer->bufferType != CODEC_BUFFER_TYPE_AVSHARE_MEM_FD) {
310 OsalMemFree(codecBuffer->buffer);
311 } else {
312 int fd = (uintptr_t)codecBuffer->buffer;
313 close(fd);
314 }
315 codecBuffer->buffer = NULL;
316 codecBuffer->bufferLen = 0;
317 }
318
InitOmxCodecBuffer(struct OmxCodecBuffer * codecBuffer)319 void InitOmxCodecBuffer(struct OmxCodecBuffer *codecBuffer)
320 {
321 if (codecBuffer != NULL) {
322 int32_t ret = memset_s(codecBuffer, sizeof(struct OmxCodecBuffer), 0, sizeof(struct OmxCodecBuffer));
323 if (ret != EOK) {
324 CODEC_LOGE("memset_s codecBuffer err [%{public}d].", ret);
325 return;
326 }
327 codecBuffer->fenceFd = -1;
328 }
329 }
OmxCodecBufferBlockUnmarshalling(struct HdfSBuf * data,struct OmxCodecBuffer * dataBlock)330 bool OmxCodecBufferBlockUnmarshalling(struct HdfSBuf *data, struct OmxCodecBuffer *dataBlock)
331 {
332 uint8_t validFd = 0;
333 if (dataBlock == NULL || data == NULL) {
334 CODEC_LOGE("dataBlock or data is NULL!");
335 return false;
336 }
337 if (!HdfSbufReadUint32(data, &dataBlock->bufferId) || !HdfSbufReadUint32(data, &dataBlock->size)) {
338 CODEC_LOGE("read dataBlock:bufferId or size failed!");
339 return false;
340 }
341 const union OMX_VERSIONTYPE *versionCp =
342 (const union OMX_VERSIONTYPE *)HdfSbufReadUnpadBuffer(data, sizeof(union OMX_VERSIONTYPE));
343 if (versionCp == NULL) {
344 CODEC_LOGE("read versionCp failed!");
345 return false;
346 }
347 (void)memcpy_s(&dataBlock->version, sizeof(union OMX_VERSIONTYPE), versionCp, sizeof(union OMX_VERSIONTYPE));
348 if (!CodecBufferUnmarshalling(data, dataBlock)) {
349 return false;
350 }
351 if (!HdfSbufReadUint32(data, &dataBlock->allocLen) || !HdfSbufReadUint32(data, &dataBlock->filledLen) ||
352 !HdfSbufReadUint32(data, &dataBlock->offset)) {
353 CODEC_LOGE("read dataBlock:allocLen, filledLen or offset failed!");
354 return false;
355 }
356
357 if (!HdfSbufReadUint8(data, &validFd)) {
358 CODEC_LOGE("read validFd failed!");
359 return false;
360 }
361
362 if (validFd != 0) {
363 dataBlock->fenceFd = HdfSbufReadFileDescriptor(data);
364 }
365
366 if (!HdfSbufReadInt32(data, (int32_t *)&dataBlock->type) || !HdfSbufReadInt64(data, &dataBlock->pts) ||
367 !HdfSbufReadUint32(data, &dataBlock->flag)) {
368 CODEC_LOGE("read dataBlock:type, pts or flag failed!");
369 return false;
370 }
371 return true;
372 }
373
RangeValueBlockMarshalling(struct HdfSBuf * data,const RangeValue * dataBlock)374 bool RangeValueBlockMarshalling(struct HdfSBuf *data, const RangeValue *dataBlock)
375 {
376 if (!HdfSbufWriteInt32(data, dataBlock->min)) {
377 CODEC_LOGE("write dataBlock->min failed!");
378 return false;
379 }
380
381 if (!HdfSbufWriteInt32(data, dataBlock->max)) {
382 CODEC_LOGE("write dataBlock->max failed!");
383 return false;
384 }
385
386 return true;
387 }
388
RangeValueBlockUnmarshalling(struct HdfSBuf * data,RangeValue * dataBlock)389 bool RangeValueBlockUnmarshalling(struct HdfSBuf *data, RangeValue *dataBlock)
390 {
391 if (dataBlock == NULL) {
392 return false;
393 }
394 if (!HdfSbufReadInt32(data, &dataBlock->min)) {
395 CODEC_LOGE("read dataBlock->min failed!");
396 return false;
397 }
398
399 if (!HdfSbufReadInt32(data, &dataBlock->max)) {
400 CODEC_LOGE("read dataBlock->max failed!");
401 return false;
402 }
403
404 return true;
405 }
406
CodecCompCapabilityBlockMarshalling(struct HdfSBuf * data,const CodecCompCapability * dataBlock)407 bool CodecCompCapabilityBlockMarshalling(struct HdfSBuf *data, const CodecCompCapability *dataBlock)
408 {
409 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->role)) {
410 CODEC_LOGE("write dataBlock->role failed!");
411 return false;
412 }
413
414 if (!HdfSbufWriteInt32(data, (int32_t)dataBlock->type)) {
415 CODEC_LOGE("write dataBlock->type failed!");
416 return false;
417 }
418
419 for (uint32_t i = 0; i < NAME_LENGTH; i++) {
420 if (!HdfSbufWriteUint8(data, (uint8_t)(dataBlock->compName)[i])) {
421 CODEC_LOGE("write (dataBlock->compName)[i] failed!");
422 return false;
423 }
424 }
425
426 for (uint32_t i = 0; i < PROFILE_NUM; i++) {
427 if (!HdfSbufWriteInt32(data, (dataBlock->supportProfiles)[i])) {
428 CODEC_LOGE("write (dataBlock->supportProfiles)[i] failed!");
429 return false;
430 }
431 }
432
433 if (!HdfSbufWriteInt32(data, dataBlock->maxInst)) {
434 CODEC_LOGE("write dataBlock->maxInst failed!");
435 return false;
436 }
437
438 int8_t isSoftwareCodec = dataBlock->isSoftwareCodec ? 1 : 0;
439 bool ret = HdfSbufWriteInt8(data, isSoftwareCodec);
440 if (!ret) {
441 CODEC_LOGE("write dataBlock->isSoftwareCodec failed!");
442 return false;
443 }
444
445 if (!HdfSbufWriteInt32(data, dataBlock->processModeMask)) {
446 CODEC_LOGE("write dataBlock->processModeMask failed!");
447 return false;
448 }
449
450 if (!HdfSbufWriteUint32(data, dataBlock->capsMask)) {
451 CODEC_LOGE("write dataBlock->capsMask failed!");
452 return false;
453 }
454
455 if (!RangeValueBlockMarshalling(data, &dataBlock->bitRate)) {
456 CODEC_LOGE("write dataBlock->bitRate failed!");
457 return false;
458 }
459
460 if (!HdfSbufWriteUnpadBuffer(data, (const uint8_t *)&dataBlock->port, sizeof(PortCap))) {
461 CODEC_LOGE("write dataBlock->port failed!");
462 return false;
463 }
464 int8_t canSwapWidthHeight = dataBlock->canSwapWidthHeight ? 1 : 0;
465 ret = HdfSbufWriteInt8(data, canSwapWidthHeight);
466 if (!ret) {
467 CODEC_LOGE("write dataBlock->canSwapWidthHeight failed!");
468 return false;
469 }
470
471 return true;
472 }
473
CodecCompCapabilityBlockUnmarshalling(struct HdfSBuf * data,CodecCompCapability * dataBlock)474 bool CodecCompCapabilityBlockUnmarshalling(struct HdfSBuf *data, CodecCompCapability *dataBlock)
475 {
476 if (dataBlock == NULL) {
477 return false;
478 }
479
480 if (!HdfSbufReadInt32(data, (int32_t *)&dataBlock->role) ||
481 !HdfSbufReadInt32(data, (int32_t *)&dataBlock->type)) {
482 CODEC_LOGE("read dataBlock->role or dataBlock->type failed!");
483 return false;
484 }
485
486 for (uint32_t i = 0; i < NAME_LENGTH; i++) {
487 if (!HdfSbufReadUint8(data, (uint8_t *)&(dataBlock->compName)[i])) {
488 CODEC_LOGE("read compName[i] failed!");
489 return false;
490 }
491 }
492
493 for (uint32_t j = 0; j < PROFILE_NUM; j++) {
494 if (!HdfSbufReadInt32(data, &(dataBlock->supportProfiles)[j])) {
495 CODEC_LOGE("read supportProfiles[i] failed!");
496 return false;
497 }
498 }
499
500 if (!HdfSbufReadInt32(data, &dataBlock->maxInst)) {
501 CODEC_LOGE("read dataBlock->maxInst failed!");
502 return false;
503 }
504
505 if (!HdfSbufReadInt8(data, (int8_t *)&dataBlock->isSoftwareCodec)) {
506 CODEC_LOGE("read dataBlock->isSoftwareCodec failed!");
507 return false;
508 }
509
510 if (!HdfSbufReadInt32(data, &dataBlock->processModeMask)) {
511 CODEC_LOGE("read dataBlock->processModeMask failed!");
512 return false;
513 }
514
515 if (!HdfSbufReadUint32(data, &dataBlock->capsMask)) {
516 CODEC_LOGE("read dataBlock->capsMask failed!");
517 return false;
518 }
519
520 if (!RangeValueBlockUnmarshalling(data, &dataBlock->bitRate)) {
521 CODEC_LOGE("read &dataBlock->bitRate failed!");
522 return false;
523 }
524
525 const PortCap *portCp = (const PortCap *)HdfSbufReadUnpadBuffer(data, sizeof(PortCap));
526 if (portCp == NULL) {
527 CODEC_LOGE("read portCp failed!");
528 return false;
529 }
530
531 if (memcpy_s(&dataBlock->port, sizeof(PortCap), portCp, sizeof(PortCap)) != EOK) {
532 CODEC_LOGE("memcpy_s dataBlock->port failed!");
533 return false;
534 }
535
536 if (!HdfSbufReadInt8(data, (int8_t *)&dataBlock->canSwapWidthHeight)) {
537 CODEC_LOGE("read dataBlock->canSwapWidthHeight failed!");
538 return false;
539 }
540
541 return true;
542 }
543