3 * Copyright 2012 Samsung Electronics S.LSI Co. LTD
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
19 * @file Exynos_OMX_Mpeg4dec.c
21 * @author Yunji Kim (yunji.kim@samsung.com)
22 * @author SeungBeom Kim (sbcrux.kim@samsung.com)
33 #include "Exynos_OMX_Macros.h"
34 #include "Exynos_OMX_Basecomponent.h"
35 #include "Exynos_OMX_Baseport.h"
36 #include "Exynos_OMX_Vdec.h"
37 #include "Exynos_OSAL_ETC.h"
38 #include "Exynos_OSAL_Semaphore.h"
39 #include "Exynos_OSAL_Thread.h"
40 #include "library_register.h"
41 #include "Exynos_OMX_Mpeg4dec.h"
42 #include "ExynosVideoApi.h"
43 #include "Exynos_OSAL_SharedMemory.h"
44 #include "Exynos_OSAL_Event.h"
45 #include "Exynos_OMX_VdecControl.h"
48 #include "Exynos_OSAL_Platform_Specific.h"
51 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
52 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
56 #define EXYNOS_LOG_TAG "EXYNOS_MPEG4_DEC"
57 #define EXYNOS_LOG_OFF
58 //#define EXYNOS_TRACE_ON
59 #include "Exynos_OSAL_Log.h"
61 #define MPEG4_DEC_NUM_OF_EXTRA_BUFFERS 7
63 //#define FULL_FRAME_SEARCH
65 /* MPEG4 Decoder Supported Levels & profiles */
66 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedMPEG4ProfileLevels[] ={
67 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0},
68 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0b},
69 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level1},
70 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level2},
71 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level3},
72 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4},
73 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4a},
74 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level5},
75 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0},
76 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0b},
77 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level1},
78 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level2},
79 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level3},
80 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4},
81 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4a},
82 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level5}};
84 /* H.263 Decoder Supported Levels & profiles */
85 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedH263ProfileLevels[] = {
86 /* Baseline (Profile 0) */
87 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level10},
88 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level20},
89 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level30},
90 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level40},
91 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45},
92 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level50},
93 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level60},
94 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level70},
96 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level10},
97 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level20},
98 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level30},
99 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level40},
100 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level45},
101 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level50},
102 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level60},
103 {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level70},
105 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level10},
106 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level20},
107 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level30},
108 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level40},
109 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level45},
110 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level50},
111 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level60},
112 {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level70},
113 /* Profile 3, restricted up to SD resolution */
114 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level10},
115 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level20},
116 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level30},
117 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level40},
118 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level45},
119 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level50},
120 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level60},
121 {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level70}};
124 static OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, void *pVirtAddr, OMX_U32 *dataSize)
126 return OMX_ErrorNone;
129 static OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, OMX_PTR addr[], OMX_U32 size[])
131 OMX_ERRORTYPE ret = OMX_ErrorNone;
132 ExynosVideoBuffer *pCodecBuffer = NULL;
134 if (codecBuffer == NULL) {
135 ret = OMX_ErrorBadParameter;
139 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
142 addr[0] = pCodecBuffer->planes[0].addr;
143 addr[1] = pCodecBuffer->planes[1].addr;
144 addr[2] = pCodecBuffer->planes[2].addr;
148 size[0] = pCodecBuffer->planes[0].allocSize;
149 size[1] = pCodecBuffer->planes[1].allocSize;
150 size[2] = pCodecBuffer->planes[2].allocSize;
157 static OMX_BOOL gbFIMV1 = OMX_FALSE;
159 #ifndef TIZEN_FEATURE_E3250
160 static int Check_Mpeg4_Frame(
161 OMX_U8 *pInputStream,
164 OMX_BOOL bPreviousFrameEOF,
165 OMX_BOOL *pbEndOfFrame)
170 OMX_BOOL bFrameStart;
173 bFrameStart = OMX_FALSE;
175 if (flag & OMX_BUFFERFLAG_CODECCONFIG) {
176 if (*pInputStream == 0x03) { /* FIMV1 */
177 BitmapInfoHhr *pInfoHeader;
179 pInfoHeader = (BitmapInfoHhr *)(pInputStream + 1);
181 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "############## NOT SUPPORTED #################");
182 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "width(%d), height(%d)", pInfoHeader->BiWidth, pInfoHeader->BiHeight);
184 *pbEndOfFrame = OMX_TRUE;
190 *pbEndOfFrame = OMX_TRUE;
194 if (bPreviousFrameEOF == OMX_FALSE)
195 bFrameStart = OMX_TRUE;
197 startCode = 0xFFFFFFFF;
198 if (bFrameStart == OMX_FALSE) {
199 /* find VOP start code */
200 while(startCode != 0x1B6) {
201 readStream = *(pInputStream + len);
202 startCode = (startCode << 8) | readStream;
209 /* find next VOP start code */
210 startCode = 0xFFFFFFFF;
211 while ((startCode != 0x1B6)) {
212 readStream = *(pInputStream + len);
213 startCode = (startCode << 8) | readStream;
219 *pbEndOfFrame = OMX_TRUE;
221 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "1. Check_Mpeg4_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 4, buffSize);
226 *pbEndOfFrame = OMX_FALSE;
228 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "2. Check_Mpeg4_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 1, buffSize);
233 static int Check_H263_Frame(
234 OMX_U8 *pInputStream,
237 OMX_BOOL bPreviousFrameEOF,
238 OMX_BOOL *pbEndOfFrame)
243 OMX_BOOL bFrameStart = 0;
244 unsigned pTypeMask = 0x03;
248 bFrameStart = OMX_FALSE;
250 if (bPreviousFrameEOF == OMX_FALSE)
251 bFrameStart = OMX_TRUE;
253 startCode = 0xFFFFFFFF;
254 if (bFrameStart == OMX_FALSE) {
255 /* find PSC(Picture Start Code) : 0000 0000 0000 0000 1000 00 */
256 while (((startCode << 8 >> 10) != 0x20) || (pType != 0x02)) {
257 readStream = *(pInputStream + len);
258 startCode = (startCode << 8) | readStream;
260 readStream = *(pInputStream + len + 1);
261 pType = readStream & pTypeMask;
270 startCode = 0xFFFFFFFF;
272 while (((startCode << 8 >> 10) != 0x20) || (pType != 0x02)) {
273 readStream = *(pInputStream + len);
274 startCode = (startCode << 8) | readStream;
276 readStream = *(pInputStream + len + 1);
277 pType = readStream & pTypeMask;
284 *pbEndOfFrame = OMX_TRUE;
286 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "1. Check_H263_Frame returned EOF = %d, len = %d, iBuffSize = %d", *pbEndOfFrame, len - 3, buffSize);
292 *pbEndOfFrame = OMX_FALSE;
294 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "2. Check_H263_Frame returned EOF = %d, len = %d, iBuffSize = %d", *pbEndOfFrame, len - 1, buffSize);
300 static OMX_BOOL Check_Stream_StartCode(
301 OMX_U8 *pInputStream,
303 CODEC_TYPE codecType)
306 case CODEC_TYPE_MPEG4:
310 if (streamSize < 3) {
312 } else if ((pInputStream[0] == 0x00) &&
313 (pInputStream[1] == 0x00) &&
314 (pInputStream[2] == 0x01)) {
321 case CODEC_TYPE_H263:
322 if (streamSize > 0) {
323 unsigned startCode = 0xFFFFFFFF;
324 unsigned pTypeMask = 0x03;
328 /* Check PSC(Picture Start Code) : 0000 0000 0000 0000 1000 00 */
329 while (((startCode << 8 >> 10) != 0x20) || (pType != 0x02)) {
330 readStream = *(pInputStream + len);
331 startCode = (startCode << 8) | readStream;
333 readStream = *(pInputStream + len + 1);
334 pType = readStream & pTypeMask;
342 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "[%s] Picture Start Code Missing", __FUNCTION__);
351 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: undefined codec type (%d)", __FUNCTION__, codecType);
356 static void getAByte(OMX_U8 *buff, int *code)
360 *code = (*code << 8);
366 static int Check_IsPBPacked(
367 OMX_U8 *pInputStream,
370 OMX_U8 *pStrmBuf = NULL;
371 int startCode = 0xFFFFFFFF;
374 pStrmBuf = pInputStream;
377 while (startCode != USR_DATA_START_CODE) {
378 if ((startCode == VOP_START_CODE) || (leng_idx == streamSize)) {
379 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"isPBPacked] VOP START Found !! Non Packed PB.....return");
382 getAByte(pStrmBuf, &startCode);
386 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"isPBPacked] User Data Found !!");
389 if (*pStrmBuf == 'p') {
390 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"isPBPacked] Packed PB\n");
393 getAByte(pStrmBuf, &startCode);
394 pStrmBuf++; leng_idx++;
395 } while ((leng_idx <= streamSize) && ((startCode >> 8) != MP4_START_CODE));
397 if (leng_idx > streamSize)
401 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"isPBPacked] Non Packed PB");
406 OMX_ERRORTYPE Mpeg4CodecOpen(EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec)
408 OMX_ERRORTYPE ret = OMX_ErrorNone;
409 ExynosVideoDecOps *pDecOps = NULL;
410 ExynosVideoDecBufferOps *pInbufOps = NULL;
411 ExynosVideoDecBufferOps *pOutbufOps = NULL;
415 if (pMpeg4Dec == NULL) {
416 ret = OMX_ErrorBadParameter;
417 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
421 /* alloc ops structure */
422 pDecOps = (ExynosVideoDecOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecOps));
423 pInbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
424 pOutbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
426 if ((pDecOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
427 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate decoder ops buffer");
428 ret = OMX_ErrorInsufficientResources;
432 pMpeg4Dec->hMFCMpeg4Handle.pDecOps = pDecOps;
433 pMpeg4Dec->hMFCMpeg4Handle.pInbufOps = pInbufOps;
434 pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps = pOutbufOps;
436 /* function pointer mapping */
437 pDecOps->nSize = sizeof(ExynosVideoDecOps);
438 pInbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
439 pOutbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
441 Exynos_Video_Register_Decoder(pDecOps, pInbufOps, pOutbufOps);
443 /* check mandatory functions for decoder ops */
444 if ((pDecOps->Init == NULL) || (pDecOps->Finalize == NULL) ||
445 (pDecOps->Get_ActualBufferCount == NULL) || (pDecOps->Set_FrameTag == NULL) ||
446 (pDecOps->Get_FrameTag == NULL)) {
447 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
448 ret = OMX_ErrorInsufficientResources;
452 /* check mandatory functions for buffer ops */
453 if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
454 (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
455 (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
456 (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
457 (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
458 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
459 ret = OMX_ErrorInsufficientResources;
463 /* alloc context, open, querycap */
465 pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.pDecOps->Init(V4L2_MEMORY_DMABUF);
467 pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.pDecOps->Init(V4L2_MEMORY_USERPTR);
469 if (pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle == NULL) {
470 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
471 ret = OMX_ErrorInsufficientResources;
478 if (ret != OMX_ErrorNone) {
479 if (pDecOps != NULL) {
480 Exynos_OSAL_Free(pDecOps);
481 pMpeg4Dec->hMFCMpeg4Handle.pDecOps = NULL;
483 if (pInbufOps != NULL) {
484 Exynos_OSAL_Free(pInbufOps);
485 pMpeg4Dec->hMFCMpeg4Handle.pInbufOps = NULL;
487 if (pOutbufOps != NULL) {
488 Exynos_OSAL_Free(pOutbufOps);
489 pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps = NULL;
498 OMX_ERRORTYPE Mpeg4CodecClose(EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec)
500 OMX_ERRORTYPE ret = OMX_ErrorNone;
501 void *hMFCHandle = NULL;
502 ExynosVideoDecOps *pDecOps = NULL;
503 ExynosVideoDecBufferOps *pInbufOps = NULL;
504 ExynosVideoDecBufferOps *pOutbufOps = NULL;
508 if (pMpeg4Dec == NULL) {
509 ret = OMX_ErrorBadParameter;
513 hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
514 pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
515 pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
516 pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
518 if (hMFCHandle != NULL) {
519 pDecOps->Finalize(hMFCHandle);
520 pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = NULL;
522 if (pOutbufOps != NULL) {
523 Exynos_OSAL_Free(pOutbufOps);
524 pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps = NULL;
526 if (pInbufOps != NULL) {
527 Exynos_OSAL_Free(pInbufOps);
528 pMpeg4Dec->hMFCMpeg4Handle.pInbufOps = NULL;
530 if (pDecOps != NULL) {
531 Exynos_OSAL_Free(pDecOps);
532 pMpeg4Dec->hMFCMpeg4Handle.pDecOps = NULL;
543 OMX_ERRORTYPE Mpeg4CodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
545 OMX_ERRORTYPE ret = OMX_ErrorNone;
546 void *hMFCHandle = NULL;
547 ExynosVideoDecBufferOps *pInbufOps = NULL;
548 ExynosVideoDecBufferOps *pOutbufOps = NULL;
549 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
550 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
554 if (pOMXComponent == NULL) {
555 ret = OMX_ErrorBadParameter;
559 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
560 if (pVideoDec == NULL) {
561 ret = OMX_ErrorBadParameter;
565 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
566 if (pMpeg4Dec == NULL) {
567 ret = OMX_ErrorBadParameter;
571 hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
572 pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
573 pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
575 if (nPortIndex == INPUT_PORT_INDEX)
576 pInbufOps->Run(hMFCHandle);
577 else if (nPortIndex == OUTPUT_PORT_INDEX)
578 pOutbufOps->Run(hMFCHandle);
588 OMX_ERRORTYPE Mpeg4CodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
590 OMX_ERRORTYPE ret = OMX_ErrorNone;
591 void *hMFCHandle = NULL;
592 ExynosVideoDecBufferOps *pInbufOps = NULL;
593 ExynosVideoDecBufferOps *pOutbufOps = NULL;
594 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
595 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
599 if (pOMXComponent == NULL) {
600 ret = OMX_ErrorBadParameter;
604 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
605 if (pVideoDec == NULL) {
606 ret = OMX_ErrorBadParameter;
609 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
610 if (pMpeg4Dec == NULL) {
611 ret = OMX_ErrorBadParameter;
615 hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
616 pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
617 pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
619 if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
620 pInbufOps->Stop(hMFCHandle);
621 else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
622 pOutbufOps->Stop(hMFCHandle);
632 OMX_ERRORTYPE Mpeg4CodecSrcInit(OMX_COMPONENTTYPE *pOMXComponent)
634 OMX_ERRORTYPE ret = OMX_ErrorNone;
635 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
636 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
637 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
638 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
639 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
640 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
642 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
643 ExynosVideoDecBufferOps *pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
644 ExynosVideoGeometry bufferConf;
645 OMX_U32 inputBufferNumber = 0;
648 if (pVideoDec->bThumbnailMode == OMX_TRUE)
649 pDecOps->Set_DisplayDelay(hMFCHandle, 0);
651 /* input buffer info */
652 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
653 if (pMpeg4Dec->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
654 bufferConf.eCompressionFormat = VIDEO_CODING_MPEG4;
656 bufferConf.eCompressionFormat = VIDEO_CODING_H263;
658 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE
659 ||pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE)
660 pInbufOps->Set_Shareable(hMFCHandle);
662 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
663 bufferConf.nSizeImage = pExynosInputPort->portDefinition.format.video.nFrameWidth
664 * pExynosInputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
665 inputBufferNumber = MAX_VIDEO_INPUTBUFFER_NUM;
666 } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
667 bufferConf.nSizeImage = DEFAULT_MFC_INPUT_BUFFER_SIZE;
668 inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
671 /* should be done before prepare input buffer */
672 if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
673 ret = OMX_ErrorInsufficientResources;
677 /* set input buffer geometry */
678 if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
679 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
680 ret = OMX_ErrorInsufficientResources;
684 /* setup input buffer */
685 if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
686 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
687 ret = OMX_ErrorInsufficientResources;
691 if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
692 pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
693 /* Register input buffer */
694 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
695 ExynosVideoPlane plane;
696 plane.addr = pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0];
697 plane.allocSize = pVideoDec->pMFCDecInputBuffer[i]->bufferSize[0];
698 plane.fd = pVideoDec->pMFCDecInputBuffer[i]->fd[0];
699 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
700 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
701 ret = OMX_ErrorInsufficientResources;
705 } else if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
706 pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_FALSE) {
707 ExynosVideoBuffer *pBuffer = NULL;
709 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
710 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
711 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
712 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
713 /* get input buffer info */
714 if (pInbufOps->Get_Buffer) {
715 if (pInbufOps->Get_Buffer(pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
716 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
717 ret = OMX_ErrorInsufficientResources;
722 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
723 /* Use ION Allocator */
724 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
725 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
726 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
727 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
728 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
731 #ifdef TIZEN_FEATURE_E3250
732 if (pExynosInputPort == NULL || pExynosOutputPort == NULL || pOMXComponent == NULL) {
733 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "invalid param: pExynosInputPort= %p pExynosOutputPort= %p pOMXComponent= %p", pExynosInputPort, pExynosOutputPort, pOMXComponent);
736 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
738 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
739 /* Register input buffer */
740 for (i = 0; i < pExynosInputPort->portDefinition.nBufferCountActual; i++) {
741 ExynosVideoPlane plane;
742 if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
743 plane.addr = Exynos_OSAL_SharedMemory_IONToVirt(pVideoDec->hSharedMemory, (int)pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer);
745 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
747 plane.allocSize = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
748 plane.fd = pExynosInputPort->extendBufferHeader[i].buf_fd[0];
749 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
750 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
751 ret = OMX_ErrorInsufficientResources;
765 OMX_ERRORTYPE Mpeg4CodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
767 OMX_ERRORTYPE ret = OMX_ErrorNone;
768 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
769 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
773 if (pOMXComponent == NULL) {
774 ret = OMX_ErrorBadParameter;
778 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
779 if (pVideoDec == NULL) {
780 ret = OMX_ErrorBadParameter;
783 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
784 if (pMpeg4Dec == NULL) {
785 ret = OMX_ErrorBadParameter;
789 if (nPortIndex == INPUT_PORT_INDEX) {
790 if (pMpeg4Dec->bSourceStart == OMX_FALSE) {
791 Exynos_OSAL_SignalSet(pMpeg4Dec->hSourceStartEvent);
792 Exynos_OSAL_SleepMillisec(0);
796 if (nPortIndex == OUTPUT_PORT_INDEX) {
797 if (pMpeg4Dec->bDestinationStart == OMX_FALSE) {
798 Exynos_OSAL_SignalSet(pMpeg4Dec->hDestinationStartEvent);
799 Exynos_OSAL_SleepMillisec(0);
811 OMX_ERRORTYPE Mpeg4CodecEnQueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
813 OMX_ERRORTYPE ret = OMX_ErrorNone;
814 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
815 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
816 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
817 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
820 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
821 ExynosVideoDecBufferOps *pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
822 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
826 if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
827 ret = OMX_ErrorBadPortIndex;
831 if ((nPortIndex == INPUT_PORT_INDEX) &&
832 (pMpeg4Dec->bSourceStart == OMX_TRUE)) {
833 Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
835 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
836 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
837 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]);
839 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
842 pInbufOps->Clear_Queue(hMFCHandle);
843 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
844 (pMpeg4Dec->bDestinationStart == OMX_TRUE)) {
845 ExynosVideoBuffer *pBuffer = NULL;
847 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
849 nOutbufs = pDecOps->Get_ActualBufferCount(hMFCHandle);
850 nOutbufs += EXTRA_DPB_NUM;
851 for (i = 0; i < nOutbufs; i++) {
852 pOutbufOps->Get_Buffer(hMFCHandle, i, &pBuffer);
853 Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR)pBuffer);
855 pOutbufOps->Clear_Queue(hMFCHandle);
865 OMX_ERRORTYPE Mpeg4CodecDstFreeCodecBuffers(
866 OMX_COMPONENTTYPE *pOMXComponent)
868 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
869 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
870 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
876 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
877 if (pVideoDec->pMFCDecOutputBuffer[i] != NULL) {
878 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
879 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] != NULL &&
880 pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE)
881 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
884 Exynos_OSAL_Free(pVideoDec->pMFCDecOutputBuffer[i]);
888 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer, 0, sizeof(pVideoDec->pMFCDecOutputBuffer));
892 return OMX_ErrorNone;
895 OMX_ERRORTYPE Mpeg4CodecDstAllocCodecBuffers(
896 OMX_COMPONENTTYPE *pOMXComponent,
899 OMX_ERRORTYPE ret = OMX_ErrorNone;
900 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
901 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
902 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
904 MEMORY_TYPE eMemoryType = NORMAL_MEMORY;
905 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
910 nAllocLen[0] = calc_yplane(pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth,
911 pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight);
912 nAllocLen[1] = calc_uvplane(pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth,
913 pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight >> 1);
915 for (i = 0; i < nOutbufs; i++) {
916 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
917 if (pVideoDec->pMFCDecOutputBuffer[i] == NULL) {
918 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc codec buffer");
919 ret = OMX_ErrorInsufficientResources;
922 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
924 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
925 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] =
926 (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, nAllocLen[j], eMemoryType);
927 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] == NULL) {
928 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc output buffer");
929 ret = OMX_ErrorInsufficientResources;
933 pVideoDec->pMFCDecOutputBuffer[i]->fd[j] =
934 Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory,
935 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
936 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j] = nAllocLen[j];
940 return OMX_ErrorNone;
943 Mpeg4CodecDstFreeCodecBuffers(pOMXComponent);
950 OMX_ERRORTYPE Mpeg4CodecDstRegistCodecBuffers(
951 OMX_COMPONENTTYPE *pOMXComponent,
954 OMX_ERRORTYPE ret = OMX_ErrorNone;
955 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
956 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
957 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
958 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
959 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
961 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
962 OMX_U32 nDataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
967 /* Register output buffer */
968 for (i = 0; i < nOutbufs; i++) {
969 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
970 planes[j].addr = pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j];
971 planes[j].fd = pVideoDec->pMFCDecOutputBuffer[i]->fd[j];
972 planes[j].allocSize = pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j];
975 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
976 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
977 ret = OMX_ErrorInsufficientResources;
981 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
982 (unsigned int *)nDataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
993 OMX_ERRORTYPE Mpeg4CodecResetupAllElement(
994 OMX_COMPONENTTYPE *pOMXComponent,
997 OMX_ERRORTYPE ret = OMX_ErrorNone;
998 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
999 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1000 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
1001 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1002 EXYNOS_OMX_BASEPORT *pOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1003 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1007 if ((nPortIndex == INPUT_PORT_INDEX) &&
1008 (pMpeg4Dec->bSourceStart == OMX_TRUE)) {
1009 ret = OMX_ErrorNotImplemented;
1011 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
1012 (pMpeg4Dec->bDestinationStart == OMX_TRUE)) {
1013 if (pOutputPort->bufferProcessType & BUFFER_COPY) {
1015 /**********************************/
1016 /* Codec Buffer Free & Unregister */
1017 /**********************************/
1018 Mpeg4CodecDstFreeCodecBuffers(pOMXComponent);
1019 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
1021 if (pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE)
1022 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
1024 pOutbufOps->Cleanup(hMFCHandle);
1025 /******************************************************/
1026 /* V4L2 Destnation Setup for DPB Buffer Number Change */
1027 /******************************************************/
1028 Mpeg4CodecDstSetup(pOMXComponent);
1030 pVideoDec->bDRCProcessing = OMX_FALSE;
1031 } else if (pOutputPort->bufferProcessType & BUFFER_SHARE) {
1033 /**********************************/
1034 /* Codec Buffer Unregister */
1035 /**********************************/
1036 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
1037 pOutbufOps->Cleanup(hMFCHandle);
1040 ret = OMX_ErrorBadParameter;
1051 OMX_ERRORTYPE Mpeg4CodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1053 OMX_ERRORTYPE ret = OMX_ErrorNone;
1054 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1055 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1056 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1057 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1058 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
1060 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1061 ExynosVideoDecBufferOps *pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
1062 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1063 ExynosVideoGeometry bufferConf;
1067 if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
1068 OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
1069 OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
1070 if (OMXBuffer == NULL) {
1071 ret = OMX_ErrorUndefined;
1075 OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
1076 OMXBuffer->nFlags = pSrcInputData->nFlags;
1077 Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
1079 ret = OMX_ErrorNone;
1083 if (!((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
1084 pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_FALSE)) {
1085 ret = Mpeg4CodecSrcInit(pOMXComponent);
1086 if (ret != OMX_ErrorNone)
1090 /*Check for PB Packed*/
1091 if (pMpeg4Dec->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4 &&
1092 Check_IsPBPacked(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize)) {
1093 if (pDecOps->Enable_PackedPB(hMFCHandle) != VIDEO_ERROR_NONE) {
1094 ret = OMX_ErrorInsufficientResources;
1097 pMpeg4Dec->hMFCMpeg4Handle.bPackedPB = OMX_TRUE;
1100 /* set output geometry */
1101 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
1102 pMpeg4Dec->hMFCMpeg4Handle.MFCOutputColorType = bufferConf.eColorFormat = VIDEO_COLORFORMAT_NV12;
1103 if (pOutbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
1104 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
1105 ret = OMX_ErrorInsufficientResources;
1109 /* input buffer enqueue for header parsing */
1110 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d", oneFrameSize);
1111 if (pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
1112 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader) != VIDEO_ERROR_NONE) {
1113 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to enqueue input buffer for header parsing");
1114 // ret = OMX_ErrorInsufficientResources;
1115 ret = (OMX_ERRORTYPE)OMX_ErrorCodecInit;
1119 /* start header parsing */
1120 if (pInbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1121 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run input buffer for header parsing");
1122 ret = OMX_ErrorCodecInit;
1126 ret = Mpeg4CodecCheckResolutionChange(pOMXComponent);
1127 if (ret != OMX_ErrorNone) {
1128 ret = OMX_ErrorCodecInit;
1132 Exynos_OSAL_SleepMillisec(0);
1133 ret = OMX_ErrorInputDataDecodeYet;
1135 #ifdef USE_IMMEDIATE_DISPLAY
1136 /* Set Immediately display for I Frame*/
1137 pDecOps->Set_ImmediateDisplay(hMFCHandle);
1140 Mpeg4CodecStop(pOMXComponent, INPUT_PORT_INDEX);
1146 OMX_ERRORTYPE Mpeg4CodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
1148 OMX_ERRORTYPE ret = OMX_ErrorNone;
1149 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1150 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1151 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1152 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1153 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1155 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1162 nOutbufs = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum;
1164 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1165 /* should be done before prepare output buffer */
1166 if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1167 ret = OMX_ErrorInsufficientResources;
1172 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE
1173 ||pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE)
1174 pOutbufOps->Set_Shareable(hMFCHandle);
1176 if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
1177 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1178 ret = OMX_ErrorInsufficientResources;
1182 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1183 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1184 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1187 nAllocLen[0] = calc_yplane(pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth,
1188 pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight);
1189 nAllocLen[1] = calc_uvplane(pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth,
1190 pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight >> 1);
1192 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1193 pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
1194 Mpeg4CodecDstAllocCodecBuffers(pOMXComponent, nOutbufs);
1195 Mpeg4CodecDstRegistCodecBuffers(pOMXComponent, nOutbufs);
1196 } else if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1197 pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_FALSE) {
1199 /* Register output buffer */
1200 for (i = 0; i < nOutbufs; i++) {
1202 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1203 ExynosVideoBuffer *pBuffer = NULL;
1204 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1205 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1207 if (pOutbufOps->Get_Buffer) {
1208 if (pOutbufOps->Get_Buffer(pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
1209 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get Output buffer info");
1210 ret = OMX_ErrorInsufficientResources;
1215 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1216 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
1217 pVideoDec->pMFCDecOutputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
1218 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
1221 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1222 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1224 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1226 if (pExynosOutputPort->bIsPBEnabled == OMX_TRUE) {
1227 for (i = 0; i < pExynosOutputPort->assignedBufferNum; i++) {
1228 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1229 planes[plane].fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[plane];
1230 planes[plane].addr = pExynosOutputPort->extendBufferHeader[i].pYUVBuf[plane];
1231 planes[plane].tbm_bo = pExynosOutputPort->extendBufferHeader[i].tbm_bo[plane];
1232 planes[plane].allocSize = nAllocLen[plane];
1235 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1236 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1237 ret = OMX_ErrorInsufficientResources;
1240 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
1241 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1244 ret = OMX_ErrorNotImplemented;
1248 ret = OMX_ErrorNotImplemented;
1253 if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1254 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1255 ret = OMX_ErrorInsufficientResources;
1259 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1260 Mpeg4CodecStop (pOMXComponent, OUTPUT_PORT_INDEX);
1262 pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_TRUE;
1264 ret = OMX_ErrorNone;
1272 OMX_ERRORTYPE Mpeg4CodecCheckResolutionChange(OMX_COMPONENTTYPE *pOMXComponent)
1274 OMX_ERRORTYPE ret = OMX_ErrorNone;
1275 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1276 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1277 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1278 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1279 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1280 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1282 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1283 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1287 /* get geometry for output */
1288 Exynos_OSAL_Memset(&pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
1289 if (pOutbufOps->Get_Geometry(hMFCHandle, &pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf) != VIDEO_ERROR_NONE) {
1290 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
1291 ret = OMX_ErrorInsufficientResources;
1296 pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
1297 if (pVideoDec->bThumbnailMode == OMX_FALSE)
1298 pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum += EXTRA_DPB_NUM;
1299 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Mpeg4CodecCheckResolutionChange Mpeg4CodecSetup nOutbufs: %d", pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum);
1301 pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_TRUE;
1303 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1304 if ((pVideoDec->bDRCProcessing) ||
1305 (pExynosInputPort->portDefinition.format.video.nFrameWidth != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth) ||
1306 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight)) {
1307 pExynosInputPort->portDefinition.format.video.nFrameWidth = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth;
1308 pExynosInputPort->portDefinition.format.video.nFrameHeight = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight;
1309 pExynosInputPort->portDefinition.format.video.nStride = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1310 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1312 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1313 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1315 Exynos_UpdateFrameSize(pOMXComponent);
1316 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1318 /** Send Port Settings changed call back **/
1319 (*(pExynosComponent->pCallbacks->EventHandler))
1321 pExynosComponent->callbackData,
1322 OMX_EventPortSettingsChanged, /* The command was completed */
1323 OMX_DirOutput, /* This is the port index */
1327 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1328 if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth) ||
1329 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight) ||
1330 (pExynosOutputPort->portDefinition.nBufferCountActual != pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum)) {
1331 pExynosInputPort->portDefinition.format.video.nFrameWidth = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth;
1332 pExynosInputPort->portDefinition.format.video.nFrameHeight = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight;
1333 pExynosInputPort->portDefinition.format.video.nStride = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1334 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1336 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1337 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1339 #ifdef TIZEN_FEATURE_E3250
1340 pExynosOutputPort->portDefinition.nBufferCountActual = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum;
1341 pExynosOutputPort->portDefinition.nBufferCountMin = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum;
1343 pExynosOutputPort->portDefinition.nBufferCountActual = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum - 4;
1344 pExynosOutputPort->portDefinition.nBufferCountMin = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum - 4;
1346 Exynos_UpdateFrameSize(pOMXComponent);
1347 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1349 /** Send Port Settings changed call back **/
1350 (*(pExynosComponent->pCallbacks->EventHandler))
1352 pExynosComponent->callbackData,
1353 OMX_EventPortSettingsChanged, /* The command was completed */
1354 OMX_DirOutput, /* This is the port index */
1360 ret = OMX_ErrorNone;
1369 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetParameter(
1370 OMX_IN OMX_HANDLETYPE hComponent,
1371 OMX_IN OMX_INDEXTYPE nParamIndex,
1372 OMX_INOUT OMX_PTR pComponentParameterStructure)
1374 OMX_ERRORTYPE ret = OMX_ErrorNone;
1375 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1376 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1380 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1381 ret = OMX_ErrorBadParameter;
1384 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1385 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1386 if (ret != OMX_ErrorNone) {
1389 if (pOMXComponent->pComponentPrivate == NULL) {
1390 ret = OMX_ErrorBadParameter;
1394 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1395 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1396 ret = OMX_ErrorInvalidState;
1400 switch (nParamIndex) {
1401 case OMX_IndexParamVideoMpeg4:
1403 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1404 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = NULL;
1405 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1407 ret = Exynos_OMX_Check_SizeVersion(pDstMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1408 if (ret != OMX_ErrorNone) {
1412 if (pDstMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
1413 ret = OMX_ErrorBadPortIndex;
1417 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1418 pSrcMpeg4Param = &pMpeg4Dec->mpeg4Component[pDstMpeg4Param->nPortIndex];
1420 Exynos_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1423 case OMX_IndexParamVideoH263:
1425 OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1426 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = NULL;
1427 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1429 ret = Exynos_OMX_Check_SizeVersion(pDstH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1430 if (ret != OMX_ErrorNone) {
1434 if (pDstH263Param->nPortIndex >= ALL_PORT_NUM) {
1435 ret = OMX_ErrorBadPortIndex;
1439 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1440 pSrcH263Param = &pMpeg4Dec->h263Component[pDstH263Param->nPortIndex];
1442 Exynos_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1445 case OMX_IndexParamStandardComponentRole:
1448 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1450 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1451 if (ret != OMX_ErrorNone) {
1455 codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1456 if (codecType == CODEC_TYPE_MPEG4)
1457 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE);
1459 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE);
1462 case OMX_IndexParamVideoProfileLevelQuerySupported:
1464 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1465 EXYNOS_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
1466 OMX_U32 maxProfileLevelNum = 0;
1469 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1470 if (ret != OMX_ErrorNone) {
1474 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1475 ret = OMX_ErrorBadPortIndex;
1479 codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1480 if (codecType == CODEC_TYPE_MPEG4) {
1481 pProfileLevel = supportedMPEG4ProfileLevels;
1482 maxProfileLevelNum = sizeof(supportedMPEG4ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1484 pProfileLevel = supportedH263ProfileLevels;
1485 maxProfileLevelNum = sizeof(supportedH263ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1488 if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
1489 ret = OMX_ErrorNoMore;
1493 pProfileLevel += pDstProfileLevel->nProfileIndex;
1494 pDstProfileLevel->eProfile = pProfileLevel->profile;
1495 pDstProfileLevel->eLevel = pProfileLevel->level;
1498 case OMX_IndexParamVideoProfileLevelCurrent:
1500 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1501 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = NULL;
1502 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = NULL;
1503 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1506 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1507 if (ret != OMX_ErrorNone) {
1511 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1512 ret = OMX_ErrorBadPortIndex;
1516 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1517 codecType = pMpeg4Dec->hMFCMpeg4Handle.codecType;
1518 if (codecType == CODEC_TYPE_MPEG4) {
1519 pSrcMpeg4Param = &pMpeg4Dec->mpeg4Component[pDstProfileLevel->nPortIndex];
1520 pDstProfileLevel->eProfile = pSrcMpeg4Param->eProfile;
1521 pDstProfileLevel->eLevel = pSrcMpeg4Param->eLevel;
1523 pSrcH263Param = &pMpeg4Dec->h263Component[pDstProfileLevel->nPortIndex];
1524 pDstProfileLevel->eProfile = pSrcH263Param->eProfile;
1525 pDstProfileLevel->eLevel = pSrcH263Param->eLevel;
1529 case OMX_IndexParamVideoErrorCorrection:
1531 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1532 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1533 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1535 ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1536 if (ret != OMX_ErrorNone) {
1540 if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1541 ret = OMX_ErrorBadPortIndex;
1545 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1546 pSrcErrorCorrectionType = &pMpeg4Dec->errorCorrectionType[INPUT_PORT_INDEX];
1548 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1549 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1550 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1551 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1552 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1556 ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1565 OMX_ERRORTYPE Exynos_Mpeg4Dec_SetParameter(
1566 OMX_IN OMX_HANDLETYPE hComponent,
1567 OMX_IN OMX_INDEXTYPE nIndex,
1568 OMX_IN OMX_PTR pComponentParameterStructure)
1570 OMX_ERRORTYPE ret = OMX_ErrorNone;
1571 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1572 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1576 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1577 ret = OMX_ErrorBadParameter;
1580 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1581 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1582 if (ret != OMX_ErrorNone) {
1585 if (pOMXComponent->pComponentPrivate == NULL) {
1586 ret = OMX_ErrorBadParameter;
1590 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1591 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1592 ret = OMX_ErrorInvalidState;
1597 case OMX_IndexParamVideoMpeg4:
1599 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = NULL;
1600 OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1601 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1603 ret = Exynos_OMX_Check_SizeVersion(pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1604 if (ret != OMX_ErrorNone) {
1608 if (pSrcMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
1609 ret = OMX_ErrorBadPortIndex;
1613 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1614 pDstMpeg4Param = &pMpeg4Dec->mpeg4Component[pSrcMpeg4Param->nPortIndex];
1616 Exynos_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1619 case OMX_IndexParamVideoH263:
1621 OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = NULL;
1622 OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1623 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1625 ret = Exynos_OMX_Check_SizeVersion(pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1626 if (ret != OMX_ErrorNone) {
1630 if (pSrcH263Param->nPortIndex >= ALL_PORT_NUM) {
1631 ret = OMX_ErrorBadPortIndex;
1635 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1636 pDstH263Param = &pMpeg4Dec->h263Component[pSrcH263Param->nPortIndex];
1638 Exynos_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1641 case OMX_IndexParamStandardComponentRole:
1643 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1645 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1646 if (ret != OMX_ErrorNone) {
1650 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1651 ret = OMX_ErrorIncorrectStateOperation;
1655 if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE)) {
1656 pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
1657 } else if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE)) {
1658 pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
1660 ret = OMX_ErrorBadParameter;
1665 case OMX_IndexParamPortDefinition:
1667 OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1668 OMX_U32 portIndex = pPortDefinition->nPortIndex;
1669 EXYNOS_OMX_BASEPORT *pExynosPort;
1670 OMX_U32 width, height, size;
1671 OMX_U32 realWidth, realHeight;
1672 OMX_PARAM_PORTDEFINITIONTYPE portDefinition_backup;
1674 if (portIndex >= pExynosComponent->portParam.nPorts) {
1675 ret = OMX_ErrorBadPortIndex;
1678 ret = Exynos_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1679 if (ret != OMX_ErrorNone) {
1683 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1685 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1686 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1687 ret = OMX_ErrorIncorrectStateOperation;
1691 if (pPortDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1692 ret = OMX_ErrorBadParameter;
1696 Exynos_OSAL_Memcpy(&portDefinition_backup, &pExynosPort->portDefinition, pPortDefinition->nSize);
1697 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
1698 RESTORE_READONLYPARAMETERS_OMX_PARAM_PORTDEFINITIONTYPE(&pExynosPort->portDefinition,&portDefinition_backup);
1700 realWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1701 realHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1702 width = ((realWidth + 15) & (~15));
1703 height = ((realHeight + 15) & (~15));
1704 size = (width * height * 3) / 2;
1705 pExynosPort->portDefinition.format.video.nStride = width;
1706 pExynosPort->portDefinition.format.video.nSliceHeight = height;
1707 pExynosPort->portDefinition.nBufferSize = (size > pExynosPort->portDefinition.nBufferSize) ? size : pExynosPort->portDefinition.nBufferSize;
1709 if (portIndex == INPUT_PORT_INDEX) {
1710 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1711 pExynosOutputPort->portDefinition.format.video.nFrameWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1712 pExynosOutputPort->portDefinition.format.video.nFrameHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1713 pExynosOutputPort->portDefinition.format.video.nStride = width;
1714 pExynosOutputPort->portDefinition.format.video.nSliceHeight = height;
1716 switch ((int)pExynosOutputPort->portDefinition.format.video.eColorFormat) {
1717 case OMX_COLOR_FormatYUV420Planar:
1718 case OMX_COLOR_FormatYUV420SemiPlanar:
1719 pExynosOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
1721 #ifdef TIZEN_FEATURE_E3250 /* NV12 fd */
1722 case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
1723 case OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd:
1724 pExynosOutputPort->portDefinition.nBufferSize = sizeof(MMVideoBuffer);
1727 case OMX_SEC_COLOR_FormatNV12Tiled:
1728 pExynosOutputPort->portDefinition.nBufferSize =
1729 calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1730 calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1733 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Color format is not support!! use default YUV size!!");
1734 ret = OMX_ErrorUnsupportedSetting;
1738 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1739 pExynosOutputPort->portDefinition.nBufferSize =
1740 calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1741 calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1746 case OMX_IndexParamVideoProfileLevelCurrent:
1748 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1749 OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = NULL;
1750 OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = NULL;
1751 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1754 ret = Exynos_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1755 if (ret != OMX_ErrorNone)
1758 if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1759 ret = OMX_ErrorBadPortIndex;
1763 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1764 codecType = pMpeg4Dec->hMFCMpeg4Handle.codecType;
1765 if (codecType == CODEC_TYPE_MPEG4) {
1767 * To do: Check validity of profile & level parameters
1770 pDstMpeg4Param = &pMpeg4Dec->mpeg4Component[pSrcProfileLevel->nPortIndex];
1771 pDstMpeg4Param->eProfile = pSrcProfileLevel->eProfile;
1772 pDstMpeg4Param->eLevel = pSrcProfileLevel->eLevel;
1775 * To do: Check validity of profile & level parameters
1778 pDstH263Param = &pMpeg4Dec->h263Component[pSrcProfileLevel->nPortIndex];
1779 pDstH263Param->eProfile = pSrcProfileLevel->eProfile;
1780 pDstH263Param->eLevel = pSrcProfileLevel->eLevel;
1784 case OMX_IndexParamVideoErrorCorrection:
1786 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1787 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1788 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
1790 ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1791 if (ret != OMX_ErrorNone) {
1795 if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1796 ret = OMX_ErrorBadPortIndex;
1800 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1801 pDstErrorCorrectionType = &pMpeg4Dec->errorCorrectionType[INPUT_PORT_INDEX];
1803 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1804 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1805 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1806 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1807 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1811 ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1820 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetConfig(
1821 OMX_IN OMX_HANDLETYPE hComponent,
1822 OMX_IN OMX_INDEXTYPE nIndex,
1823 OMX_IN OMX_PTR pComponentConfigStructure)
1825 OMX_ERRORTYPE ret = OMX_ErrorNone;
1826 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1827 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1831 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1832 ret = OMX_ErrorBadParameter;
1835 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1836 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1837 if (ret != OMX_ErrorNone) {
1840 if (pOMXComponent->pComponentPrivate == NULL) {
1841 ret = OMX_ErrorBadParameter;
1844 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1845 if (pExynosComponent->currentState == OMX_StateInvalid) {
1846 ret = OMX_ErrorInvalidState;
1852 ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1862 OMX_ERRORTYPE Exynos_Mpeg4Dec_SetConfig(
1863 OMX_IN OMX_HANDLETYPE hComponent,
1864 OMX_IN OMX_INDEXTYPE nIndex,
1865 OMX_IN OMX_PTR pComponentConfigStructure)
1867 OMX_ERRORTYPE ret = OMX_ErrorNone;
1868 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1869 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1873 if (hComponent == NULL || pComponentConfigStructure == NULL) {
1874 ret = OMX_ErrorBadParameter;
1877 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1878 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1879 if (ret != OMX_ErrorNone) {
1882 if (pOMXComponent->pComponentPrivate == NULL) {
1883 ret = OMX_ErrorBadParameter;
1886 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1887 if (pExynosComponent->currentState == OMX_StateInvalid) {
1888 ret = OMX_ErrorInvalidState;
1894 ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1904 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetExtensionIndex(
1905 OMX_IN OMX_HANDLETYPE hComponent,
1906 OMX_IN OMX_STRING cParameterName,
1907 OMX_OUT OMX_INDEXTYPE *pIndexType)
1909 OMX_ERRORTYPE ret = OMX_ErrorNone;
1910 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1911 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1915 if (hComponent == NULL) {
1916 ret = OMX_ErrorBadParameter;
1919 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1920 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1921 if (ret != OMX_ErrorNone) {
1924 if (pOMXComponent->pComponentPrivate == NULL) {
1925 ret = OMX_ErrorBadParameter;
1928 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1929 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1930 ret = OMX_ErrorBadParameter;
1933 if (pExynosComponent->currentState == OMX_StateInvalid) {
1934 ret = OMX_ErrorInvalidState;
1938 if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1939 *pIndexType = OMX_IndexVendorThumbnailMode;
1940 ret = OMX_ErrorNone;
1942 ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1951 OMX_ERRORTYPE Exynos_Mpeg4Dec_ComponentRoleEnum(
1952 OMX_IN OMX_HANDLETYPE hComponent,
1953 OMX_OUT OMX_U8 *cRole,
1954 OMX_IN OMX_U32 nIndex)
1956 OMX_ERRORTYPE ret = OMX_ErrorNone;
1957 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1958 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1963 if ((hComponent == NULL) || (cRole == NULL)) {
1964 ret = OMX_ErrorBadParameter;
1967 if (nIndex != (MAX_COMPONENT_ROLE_NUM - 1)) {
1968 ret = OMX_ErrorNoMore;
1971 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1972 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1973 if (ret != OMX_ErrorNone) {
1976 if (pOMXComponent->pComponentPrivate == NULL) {
1977 ret = OMX_ErrorBadParameter;
1980 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1981 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1982 ret = OMX_ErrorInvalidState;
1986 codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1987 if (codecType == CODEC_TYPE_MPEG4)
1988 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE);
1990 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE);
1999 OMX_ERRORTYPE Exynos_Mpeg4Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
2001 OMX_ERRORTYPE ret = OMX_ErrorNone;
2002 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2003 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2004 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2005 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2006 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
2008 CSC_METHOD csc_method = CSC_METHOD_SW;
2013 pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_FALSE;
2014 pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_FALSE;
2015 pExynosComponent->bUseFlagEOF = OMX_TRUE;
2016 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
2018 /* Mpeg4 Codec Open */
2019 ret = Mpeg4CodecOpen(pMpeg4Dec);
2020 if (ret != OMX_ErrorNone) {
2024 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2025 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
2026 Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
2028 if (pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
2029 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2030 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
2031 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
2032 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
2034 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2035 /* Use ION Allocator */
2036 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, DEFAULT_MFC_INPUT_BUFFER_SIZE, NORMAL_MEMORY);
2037 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2038 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = DEFAULT_MFC_INPUT_BUFFER_SIZE;
2039 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2040 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] == NULL) {
2041 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
2042 ret = OMX_ErrorInsufficientResources;
2045 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2048 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
2051 #ifdef TIZEN_FEATURE_E3250
2052 if (pOMXComponent == NULL) {
2053 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d: invalid parm: pOMXComponent = %p", __FUNCTION__, __LINE__, pOMXComponent);
2056 ret = Mpeg4CodecSrcInit(pOMXComponent);
2057 if (ret != OMX_ErrorNone)
2060 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2064 /* Does not require any actions. */
2067 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2068 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
2069 Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
2070 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2074 /* Does not require any actions. */
2077 pMpeg4Dec->bSourceStart = OMX_FALSE;
2078 Exynos_OSAL_SignalCreate(&pMpeg4Dec->hSourceStartEvent);
2079 pMpeg4Dec->bDestinationStart = OMX_FALSE;
2080 Exynos_OSAL_SignalCreate(&pMpeg4Dec->hDestinationStartEvent);
2082 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
2083 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
2084 pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp = 0;
2085 pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp = 0;
2087 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
2089 #if 0//defined(USE_CSC_GSCALER)
2090 csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
2092 pVideoDec->csc_handle = csc_init(csc_method);
2093 if (pVideoDec->csc_handle == NULL) {
2094 ret = OMX_ErrorInsufficientResources;
2097 pVideoDec->csc_set_format = OMX_FALSE;
2106 OMX_ERRORTYPE Exynos_Mpeg4Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
2108 OMX_ERRORTYPE ret = OMX_ErrorNone;
2109 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2110 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2111 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2112 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2113 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2119 if (pVideoDec->csc_handle != NULL) {
2120 csc_deinit(pVideoDec->csc_handle);
2121 pVideoDec->csc_handle = NULL;
2124 Exynos_OSAL_SignalTerminate(pMpeg4Dec->hDestinationStartEvent);
2125 pMpeg4Dec->hDestinationStartEvent = NULL;
2126 pMpeg4Dec->bDestinationStart = OMX_FALSE;
2127 Exynos_OSAL_SignalTerminate(pMpeg4Dec->hSourceStartEvent);
2128 pMpeg4Dec->hSourceStartEvent = NULL;
2129 pMpeg4Dec->bSourceStart = OMX_FALSE;
2131 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2132 Mpeg4CodecDstFreeCodecBuffers(pOMXComponent);
2134 Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
2135 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
2136 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2140 /* Does not require any actions. */
2143 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2144 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2145 if (pVideoDec->pMFCDecInputBuffer[i] != NULL) {
2146 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2148 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2149 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] != NULL)
2150 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2153 Exynos_OSAL_Free(pVideoDec->pMFCDecInputBuffer[i]);
2154 pVideoDec->pMFCDecInputBuffer[i] = NULL;
2158 Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
2159 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
2160 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2164 /* Does not require any actions. */
2166 Mpeg4CodecClose(pMpeg4Dec);
2173 OMX_ERRORTYPE Exynos_Mpeg4Dec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2175 OMX_ERRORTYPE ret = OMX_ErrorNone;
2176 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2177 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2178 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2179 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
2180 OMX_BOOL bInStartCode = OMX_FALSE;
2181 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2182 ExynosVideoDecBufferOps *pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
2183 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2187 if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc == OMX_FALSE) {
2188 ret = Mpeg4CodecSrcSetup(pOMXComponent, pSrcInputData);
2191 if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_FALSE) {
2192 ret = Mpeg4CodecDstSetup(pOMXComponent);
2195 if (((bInStartCode = Check_Stream_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize, pMpeg4Dec->hMFCMpeg4Handle.codecType)) == OMX_TRUE) ||
2196 ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)){
2197 pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->timeStamp;
2198 pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->nFlags;
2199 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "input timestamp %lld us (%.2f secs), Tag: %d, nFlags: 0x%x", pSrcInputData->timeStamp, pSrcInputData->timeStamp / 1E6, pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp, pSrcInputData->nFlags);
2200 pDecOps->Set_FrameTag(hMFCHandle, pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp);
2201 pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp++;
2202 pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp %= MAX_TIMESTAMP;
2204 #ifdef USE_IMMEDIATE_DISPLAY
2205 /* Set Immediately display for I Frame*/
2206 if (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
2207 if ( pExynosComponent->checkTimeStamp.bImmediateDisplay == OMX_FALSE) {
2208 /* Enable Immediately display After seek*/
2209 pDecOps->Set_ImmediateDisplay(hMFCHandle);
2210 pExynosComponent->checkTimeStamp.bImmediateDisplay = OMX_TRUE;
2214 /* queue work for input buffer */
2215 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
2216 codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
2217 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
2218 if (codecReturn != VIDEO_ERROR_NONE) {
2219 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2220 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2223 Mpeg4CodecStart(pOMXComponent, INPUT_PORT_INDEX);
2224 if (pMpeg4Dec->bSourceStart == OMX_FALSE) {
2225 pMpeg4Dec->bSourceStart = OMX_TRUE;
2226 Exynos_OSAL_SignalSet(pMpeg4Dec->hSourceStartEvent);
2227 Exynos_OSAL_SleepMillisec(0);
2229 if (pMpeg4Dec->bDestinationStart == OMX_FALSE) {
2230 pMpeg4Dec->bDestinationStart = OMX_TRUE;
2231 Exynos_OSAL_SignalSet(pMpeg4Dec->hDestinationStartEvent);
2232 Exynos_OSAL_SleepMillisec(0);
2234 } else if (bInStartCode == OMX_FALSE) {
2235 ret = OMX_ErrorCorruptedFrame;
2239 ret = OMX_ErrorNone;
2247 OMX_ERRORTYPE Exynos_Mpeg4Dec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2249 OMX_ERRORTYPE ret = OMX_ErrorNone;
2250 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2251 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2252 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2253 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2254 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2255 ExynosVideoDecBufferOps *pInbufOps = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
2256 ExynosVideoBuffer *pVideoBuffer;
2260 pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
2262 pSrcOutputData->dataLen = 0;
2263 pSrcOutputData->usedDataLen = 0;
2264 pSrcOutputData->remainDataLen = 0;
2265 pSrcOutputData->nFlags = 0;
2266 pSrcOutputData->timeStamp = 0;
2268 if (pVideoBuffer == NULL) {
2269 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
2270 pSrcOutputData->allocSize = 0;
2271 pSrcOutputData->pPrivate = NULL;
2272 pSrcOutputData->bufferHeader = NULL;
2274 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2275 pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2276 pSrcOutputData->allocSize = pVideoBuffer->planes[0].allocSize;
2278 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2280 while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
2282 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2283 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
2284 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2288 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2289 pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
2292 /* For Share Buffer */
2293 pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2296 ret = OMX_ErrorNone;
2304 OMX_ERRORTYPE Exynos_Mpeg4Dec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2306 OMX_ERRORTYPE ret = OMX_ErrorNone;
2307 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2308 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2309 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2310 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2311 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2312 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2313 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0,};
2314 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2318 if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
2319 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2320 ret = OMX_ErrorBadParameter;
2324 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
2325 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
2326 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
2328 if ((pVideoDec->bDRCProcessing == OMX_TRUE) &&
2329 (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) &&
2330 (pExynosOutputPort->exceptionFlag == GENERAL_STATE)) {
2331 ret = Mpeg4CodecDstSetup(pOMXComponent);
2332 if (ret != OMX_ErrorNone) {
2333 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "DRC Reconfig CodecDstSetup Failed");
2336 pVideoDec->bDRCProcessing = OMX_FALSE;
2339 codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
2340 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
2342 if (codecReturn != VIDEO_ERROR_NONE) {
2343 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2344 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2347 Mpeg4CodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2349 ret = OMX_ErrorNone;
2357 OMX_ERRORTYPE Exynos_Mpeg4Dec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2359 OMX_ERRORTYPE ret = OMX_ErrorNone;
2360 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2361 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2362 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2363 void *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2364 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2365 ExynosVideoDecOps *pDecOps = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2366 ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2367 ExynosVideoBuffer *pVideoBuffer;
2368 ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2369 ExynosVideoGeometry *bufferGeometry;
2370 DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
2371 OMX_S32 indexTimestamp = 0;
2376 if (pMpeg4Dec->bDestinationStart == OMX_FALSE) {
2377 ret = OMX_ErrorNone;
2382 pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle);
2383 if (pVideoBuffer == (ExynosVideoBuffer *)VIDEO_ERROR_DQBUF_EIO) {
2384 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "HW is not available");
2385 ret = OMX_ErrorHardware;
2389 if (pVideoBuffer == NULL) {
2390 ret = OMX_ErrorNone;
2393 displayStatus = pVideoBuffer->displayStatus;
2394 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
2396 if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
2397 (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
2398 (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2399 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2400 (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2401 if (pVideoBuffer != NULL) {
2402 ret = OMX_ErrorNone;
2405 ret = OMX_ErrorUndefined;
2411 if (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) {
2412 if (pVideoDec->bDRCProcessing != OMX_TRUE) {
2413 pExynosOutputPort->exceptionFlag = NEED_PORT_FLUSH;
2414 pVideoDec->bDRCProcessing = OMX_TRUE;
2415 Mpeg4CodecCheckResolutionChange(pOMXComponent);
2416 pVideoDec->csc_set_format = OMX_FALSE;
2418 ret = OMX_ErrorNone;
2422 pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp++;
2423 pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
2425 pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
2426 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
2427 pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2428 pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2429 pDstOutputData->buffer.multiPlaneBuffer.tbm_bo[plane] = pVideoBuffer->planes[plane].tbm_bo;
2430 pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
2431 pDstOutputData->dataLen += pVideoBuffer->planes[plane].dataSize;
2433 pDstOutputData->usedDataLen = 0;
2434 pDstOutputData->pPrivate = pVideoBuffer;
2435 /* For Share Buffer */
2436 pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2438 pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
2439 bufferGeometry = &pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf;
2440 pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
2441 pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
2442 switch (bufferGeometry->eColorFormat) {
2443 case VIDEO_COLORFORMAT_NV12:
2444 #ifdef TIZEN_FEATURE_E3250 /* NV12 fd */
2445 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
2447 pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2450 case VIDEO_COLORFORMAT_NV12_TILED:
2452 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
2456 indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
2457 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
2458 if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2459 if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
2460 (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
2461 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2462 pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2463 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
2465 pDstOutputData->timeStamp = 0x00;
2466 pDstOutputData->nFlags = 0x00;
2469 /* For timestamp correction. if mfc support frametype detect */
2470 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
2471 //#ifdef NEED_TIMESTAMP_REORDER
2472 if (pMpeg4Dec->hMFCMpeg4Handle.bPackedPB == OMX_TRUE ||
2473 pVideoDec->bNeedTimestampReorder == OMX_TRUE) { /* TIZEN_FEATURE_E3250 */
2474 if ((pVideoBuffer->frameType == VIDEO_FRAME_I)) {
2475 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2476 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2477 pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp = indexTimestamp;
2479 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2480 pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2484 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2485 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2488 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
2491 if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2492 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2493 ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2494 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
2495 pDstOutputData->remainDataLen = 0;
2497 pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
2500 ret = OMX_ErrorNone;
2508 OMX_ERRORTYPE Exynos_Mpeg4Dec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2510 OMX_ERRORTYPE ret = OMX_ErrorNone;
2511 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2512 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2516 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2517 ret = OMX_ErrorNone;
2520 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2521 ret = OMX_ErrorNone;
2525 ret = Exynos_Mpeg4Dec_SrcIn(pOMXComponent, pSrcInputData);
2526 if ((ret != OMX_ErrorNone) &&
2527 (ret != (OMX_ERRORTYPE)OMX_ErrorInputDataDecodeYet) &&
2528 (ret != (OMX_ERRORTYPE)OMX_ErrorCorruptedFrame)) {
2529 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2530 pExynosComponent->callbackData,
2531 OMX_EventError, ret, 0, NULL);
2540 OMX_ERRORTYPE Exynos_Mpeg4Dec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2542 OMX_ERRORTYPE ret = OMX_ErrorNone;
2543 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2544 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2545 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2549 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2550 ret = OMX_ErrorNone;
2554 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2555 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2556 ret = OMX_ErrorNone;
2560 if ((pMpeg4Dec->bSourceStart == OMX_FALSE) &&
2561 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2562 Exynos_OSAL_SignalWait(pMpeg4Dec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2563 Exynos_OSAL_SignalReset(pMpeg4Dec->hSourceStartEvent);
2566 ret = Exynos_Mpeg4Dec_SrcOut(pOMXComponent, pSrcOutputData);
2567 if ((ret != OMX_ErrorNone) &&
2568 (pExynosComponent->currentState == OMX_StateExecuting)) {
2569 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2570 pExynosComponent->callbackData,
2571 OMX_EventError, ret, 0, NULL);
2580 OMX_ERRORTYPE Exynos_Mpeg4Dec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2582 OMX_ERRORTYPE ret = OMX_ErrorNone;
2583 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2584 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2585 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2589 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2590 ret = OMX_ErrorNone;
2593 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2594 ret = OMX_ErrorNone;
2597 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2598 if ((pMpeg4Dec->bDestinationStart == OMX_FALSE) &&
2599 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2600 Exynos_OSAL_SignalWait(pMpeg4Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2601 Exynos_OSAL_SignalReset(pMpeg4Dec->hDestinationStartEvent);
2604 if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_TRUE) {
2605 ret = Exynos_Mpeg4Dec_DstIn(pOMXComponent, pDstInputData);
2606 if (ret != OMX_ErrorNone) {
2607 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2608 pExynosComponent->callbackData,
2609 OMX_EventError, ret, 0, NULL);
2619 OMX_ERRORTYPE Exynos_Mpeg4Dec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2621 OMX_ERRORTYPE ret = OMX_ErrorNone;
2622 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2623 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2624 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2628 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2629 ret = OMX_ErrorNone;
2632 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2633 ret = OMX_ErrorNone;
2637 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2638 if ((pMpeg4Dec->bDestinationStart == OMX_FALSE) &&
2639 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2640 Exynos_OSAL_SignalWait(pMpeg4Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2641 Exynos_OSAL_SignalReset(pMpeg4Dec->hDestinationStartEvent);
2644 ret = Exynos_Mpeg4Dec_DstOut(pOMXComponent, pDstOutputData);
2645 if ((ret != OMX_ErrorNone) &&
2646 (pExynosComponent->currentState == OMX_StateExecuting)) {
2647 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2648 pExynosComponent->callbackData,
2649 OMX_EventError, ret, 0, NULL);
2658 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
2660 OMX_ERRORTYPE ret = OMX_ErrorNone;
2661 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2662 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2663 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
2664 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2665 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
2667 OMX_S32 codecType = -1;
2671 if ((hComponent == NULL) || (componentName == NULL)) {
2672 ret = OMX_ErrorBadParameter;
2673 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2676 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_MPEG4_DEC, componentName) == 0) {
2677 codecType = CODEC_TYPE_MPEG4;
2678 } else if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H263_DEC, componentName) == 0) {
2679 codecType = CODEC_TYPE_H263;
2681 ret = OMX_ErrorBadParameter;
2682 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2686 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2687 ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
2688 if (ret != OMX_ErrorNone) {
2689 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2692 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2693 pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
2695 pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2696 if (pExynosComponent->componentName == NULL) {
2697 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2698 ret = OMX_ErrorInsufficientResources;
2699 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2702 Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2704 pMpeg4Dec = Exynos_OSAL_Malloc(sizeof(EXYNOS_MPEG4DEC_HANDLE));
2705 if (pMpeg4Dec == NULL) {
2706 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2707 ret = OMX_ErrorInsufficientResources;
2708 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2711 Exynos_OSAL_Memset(pMpeg4Dec, 0, sizeof(EXYNOS_MPEG4DEC_HANDLE));
2712 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2713 pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pMpeg4Dec;
2714 pMpeg4Dec->hMFCMpeg4Handle.codecType = codecType;
2716 if (codecType == CODEC_TYPE_MPEG4)
2717 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_MPEG4_DEC);
2719 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H263_DEC);
2721 /* In case of BUFFER_COPY mode
2722 bShareableBuf = TRUE means MemoryType is V4L2_MEMORY_USERPTR
2723 bShareableBuf = FALSE means MemoryType is V4L2_MEMORY_MMAP
2724 In case of BUFFER_SHARE
2725 bShareableBuf should be TRUE, FALSE is ignored
2727 pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf = OMX_FALSE;
2728 pMpeg4Dec->hMFCMpeg4Handle.bPackedPB = OMX_FALSE;
2730 /* Set componentVersion */
2731 pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2732 pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2733 pExynosComponent->componentVersion.s.nRevision = REVISION_NUMBER;
2734 pExynosComponent->componentVersion.s.nStep = STEP_NUMBER;
2735 /* Set specVersion */
2736 pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2737 pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2738 pExynosComponent->specVersion.s.nRevision = REVISION_NUMBER;
2739 pExynosComponent->specVersion.s.nStep = STEP_NUMBER;
2742 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2743 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2744 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2745 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2746 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2747 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2748 if (codecType == CODEC_TYPE_MPEG4) {
2749 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
2750 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2751 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/mpeg4");
2753 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
2754 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2755 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/h263");
2757 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2758 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2759 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2760 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2761 pExynosPort->bufferProcessType = BUFFER_COPY;
2762 pExynosPort->portWayType = WAY2_PORT;
2765 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2766 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2767 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2768 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2769 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2770 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2771 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2772 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2773 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2774 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2775 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2776 #ifdef TIZEN_FEATURE_E3250
2777 pExynosPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
2778 pExynosPort->bufferProcessType = BUFFER_SHARE;
2780 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2781 pExynosPort->bufferProcessType = BUFFER_COPY;
2783 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2784 pExynosPort->portWayType = WAY2_PORT;
2786 if (codecType == CODEC_TYPE_MPEG4) {
2787 for(i = 0; i < ALL_PORT_NUM; i++) {
2788 INIT_SET_SIZE_VERSION(&pMpeg4Dec->mpeg4Component[i], OMX_VIDEO_PARAM_MPEG4TYPE);
2789 pMpeg4Dec->mpeg4Component[i].nPortIndex = i;
2790 pMpeg4Dec->mpeg4Component[i].eProfile = OMX_VIDEO_MPEG4ProfileSimple;
2791 pMpeg4Dec->mpeg4Component[i].eLevel = OMX_VIDEO_MPEG4Level3;
2794 for(i = 0; i < ALL_PORT_NUM; i++) {
2795 INIT_SET_SIZE_VERSION(&pMpeg4Dec->h263Component[i], OMX_VIDEO_PARAM_H263TYPE);
2796 pMpeg4Dec->h263Component[i].nPortIndex = i;
2797 pMpeg4Dec->h263Component[i].eProfile = OMX_VIDEO_H263ProfileBaseline | OMX_VIDEO_H263ProfileISWV2;
2798 pMpeg4Dec->h263Component[i].eLevel = OMX_VIDEO_H263Level45;
2802 pOMXComponent->GetParameter = &Exynos_Mpeg4Dec_GetParameter;
2803 pOMXComponent->SetParameter = &Exynos_Mpeg4Dec_SetParameter;
2804 pOMXComponent->GetConfig = &Exynos_Mpeg4Dec_GetConfig;
2805 pOMXComponent->SetConfig = &Exynos_Mpeg4Dec_SetConfig;
2806 pOMXComponent->GetExtensionIndex = &Exynos_Mpeg4Dec_GetExtensionIndex;
2807 pOMXComponent->ComponentRoleEnum = &Exynos_Mpeg4Dec_ComponentRoleEnum;
2808 pOMXComponent->ComponentDeInit = &Exynos_OMX_ComponentDeinit;
2810 pExynosComponent->exynos_codec_componentInit = &Exynos_Mpeg4Dec_Init;
2811 pExynosComponent->exynos_codec_componentTerminate = &Exynos_Mpeg4Dec_Terminate;
2813 pVideoDec->exynos_codec_srcInputProcess = &Exynos_Mpeg4Dec_srcInputBufferProcess;
2814 pVideoDec->exynos_codec_srcOutputProcess = &Exynos_Mpeg4Dec_srcOutputBufferProcess;
2815 pVideoDec->exynos_codec_dstInputProcess = &Exynos_Mpeg4Dec_dstInputBufferProcess;
2816 pVideoDec->exynos_codec_dstOutputProcess = &Exynos_Mpeg4Dec_dstOutputBufferProcess;
2818 pVideoDec->exynos_codec_start = &Mpeg4CodecStart;
2819 pVideoDec->exynos_codec_stop = &Mpeg4CodecStop;
2820 pVideoDec->exynos_codec_bufferProcessRun = &Mpeg4CodecOutputBufferProcessRun;
2821 pVideoDec->exynos_codec_enqueueAllBuffer = &Mpeg4CodecEnQueueAllBuffer;
2822 pVideoDec->exynos_codec_resetupAllElement = &Mpeg4CodecResetupAllElement;
2824 pVideoDec->exynos_checkInputFrame = NULL;
2825 pVideoDec->exynos_codec_getCodecInputPrivateData = &GetCodecInputPrivateData;
2826 pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2828 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2829 pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2830 if (pVideoDec->hSharedMemory == NULL) {
2831 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2832 Exynos_OSAL_Free(pMpeg4Dec);
2833 pMpeg4Dec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2834 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2835 ret = OMX_ErrorInsufficientResources;
2839 pExynosComponent->currentState = OMX_StateLoaded;
2841 ret = OMX_ErrorNone;
2849 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
2851 OMX_ERRORTYPE ret = OMX_ErrorNone;
2852 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2853 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2854 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2855 EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = NULL;
2859 if (hComponent == NULL) {
2860 ret = OMX_ErrorBadParameter;
2863 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2864 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2865 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2866 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2867 Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2869 Exynos_OSAL_Free(pExynosComponent->componentName);
2870 pExynosComponent->componentName = NULL;
2872 pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
2873 if (pMpeg4Dec != NULL) {
2874 Exynos_OSAL_Free(pMpeg4Dec);
2875 pMpeg4Dec = pVideoDec->hCodecHandle = NULL;
2878 ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2879 if (ret != OMX_ErrorNone) {
2883 ret = OMX_ErrorNone;