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_H264dec.c
21 * @author SeungBeom Kim (sbcrux.kim@samsung.com)
32 #include "Exynos_OMX_Macros.h"
33 #include "Exynos_OMX_Basecomponent.h"
34 #include "Exynos_OMX_Baseport.h"
35 #include "Exynos_OMX_Vdec.h"
36 #include "Exynos_OSAL_ETC.h"
37 #include "Exynos_OSAL_Semaphore.h"
38 #include "Exynos_OSAL_Thread.h"
39 #include "library_register.h"
40 #include "Exynos_OMX_H264dec.h"
41 #include "ExynosVideoApi.h"
42 #include "Exynos_OSAL_SharedMemory.h"
43 #include "Exynos_OSAL_Event.h"
44 #include "Exynos_OMX_VdecControl.h"
49 #include "Exynos_OSAL_Platform_Specific.h"
52 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
53 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
57 #define EXYNOS_LOG_TAG "EXYNOS_H264_DEC"
58 #define EXYNOS_LOG_OFF
59 //#define EXYNOS_TRACE_ON
60 #include "Exynos_OSAL_Log.h"
62 #define H264_DEC_NUM_OF_EXTRA_BUFFERS 7
64 //#define ADD_SPS_PPS_I_FRAME
65 //#define FULL_FRAME_SEARCH
67 /* H.264 Decoder Supported Levels & profiles */
68 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedAVCProfileLevels[] ={
69 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1},
70 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1b},
71 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel11},
72 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel12},
73 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13},
74 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2},
75 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel21},
76 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel22},
77 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel3},
78 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel31},
79 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel32},
80 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel4},
81 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel41},
82 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel42},
84 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1},
85 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1b},
86 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel11},
87 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel12},
88 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel13},
89 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel2},
90 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel21},
91 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel22},
92 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel3},
93 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel31},
94 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel32},
95 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel4},
96 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel41},
97 {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel42},
99 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1},
100 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1b},
101 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel11},
102 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel12},
103 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel13},
104 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel2},
105 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel21},
106 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel22},
107 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel3},
108 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel31},
109 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel32},
110 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel4},
111 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel41},
112 {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel42}};
114 static OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, void *pVirtAddr, OMX_U32 *dataSize)
116 return OMX_ErrorNone;
119 static OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, OMX_PTR addr[], OMX_U32 size[])
121 OMX_ERRORTYPE ret = OMX_ErrorNone;
122 ExynosVideoBuffer *pCodecBuffer = NULL;
124 if (codecBuffer == NULL) {
125 ret = OMX_ErrorBadParameter;
129 pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
132 addr[0] = pCodecBuffer->planes[0].addr;
133 addr[1] = pCodecBuffer->planes[1].addr;
134 addr[2] = pCodecBuffer->planes[2].addr;
138 size[0] = pCodecBuffer->planes[0].allocSize;
139 size[1] = pCodecBuffer->planes[1].allocSize;
140 size[2] = pCodecBuffer->planes[2].allocSize;
147 #ifndef TIZEN_FEATURE_E3250
148 int Check_H264_Frame(
149 OMX_U8 *pInputStream,
152 OMX_BOOL bPreviousFrameEOF,
153 OMX_BOOL *pbEndOfFrame)
155 OMX_U32 preFourByte = (OMX_U32)-1;
156 int accessUnitSize = 0;
157 int frameTypeBoundary = 0;
158 int nextNaluSize = 0;
161 if (bPreviousFrameEOF == OMX_TRUE)
167 int inputOneByte = 0;
169 if (accessUnitSize == (int)buffSize)
172 inputOneByte = *(pInputStream++);
175 if (preFourByte == 0x00000001 || (preFourByte << 8) == 0x00000100) {
176 int naluType = inputOneByte & 0x1F;
178 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NaluType : %d", naluType);
179 if (naluStart == 0) {
180 #ifdef ADD_SPS_PPS_I_FRAME
181 if (naluType == 1 || naluType == 5)
183 if (naluType == 1 || naluType == 5 || naluType == 7 || naluType == 8)
188 frameTypeBoundary = (8 - naluType) & (naluType - 10); //AUD(9)
191 frameTypeBoundary = -2;
193 if (naluType == 1 || naluType == 5) {
194 if (accessUnitSize == (int)buffSize) {
198 inputOneByte = *pInputStream++;
201 if (inputOneByte >= 0x80)
202 frameTypeBoundary = -1;
204 if (frameTypeBoundary < 0) {
210 preFourByte = (preFourByte << 8) + inputOneByte;
213 *pbEndOfFrame = OMX_TRUE;
215 if (frameTypeBoundary == -1)
217 if (preFourByte != 0x00000001)
219 return (accessUnitSize + nextNaluSize);
222 *pbEndOfFrame = OMX_FALSE;
224 return accessUnitSize;
228 static OMX_BOOL Check_H264_StartCode(
229 OMX_U8 *pInputStream,
232 if (streamSize < 4) {
236 if ((pInputStream[0] == 0x00) &&
237 (pInputStream[1] == 0x00) &&
238 (pInputStream[2] == 0x00) &&
239 (pInputStream[3] != 0x00) &&
240 ((pInputStream[3] >> 3) == 0x00)) {
241 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NaluType : %d, 0x%x, 0x%x, 0x%x", (pInputStream[4] & 0x1F), pInputStream[3], pInputStream[4], pInputStream[5]);
243 } else if ((pInputStream[0] == 0x00) &&
244 (pInputStream[1] == 0x00) &&
245 (pInputStream[2] != 0x00) &&
246 ((pInputStream[2] >> 3) == 0x00)) {
247 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NaluType : %d, 0x%x, 0x%x, 0x%x", (pInputStream[3] & 0x1F), pInputStream[2], pInputStream[3], pInputStream[4]);
254 OMX_ERRORTYPE H264CodecOpen(EXYNOS_H264DEC_HANDLE *pH264Dec)
256 OMX_ERRORTYPE ret = OMX_ErrorNone;
257 ExynosVideoDecOps *pDecOps = NULL;
258 ExynosVideoDecBufferOps *pInbufOps = NULL;
259 ExynosVideoDecBufferOps *pOutbufOps = NULL;
263 if (pH264Dec == NULL) {
264 ret = OMX_ErrorBadParameter;
265 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
269 /* alloc ops structure */
270 pDecOps = (ExynosVideoDecOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecOps));
271 pInbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
272 pOutbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
274 if ((pDecOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
275 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate decoder ops buffer");
276 ret = OMX_ErrorInsufficientResources;
280 pH264Dec->hMFCH264Handle.pDecOps = pDecOps;
281 pH264Dec->hMFCH264Handle.pInbufOps = pInbufOps;
282 pH264Dec->hMFCH264Handle.pOutbufOps = pOutbufOps;
284 /* function pointer mapping */
285 pDecOps->nSize = sizeof(ExynosVideoDecOps);
286 pInbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
287 pOutbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
289 Exynos_Video_Register_Decoder(pDecOps, pInbufOps, pOutbufOps);
291 /* check mandatory functions for decoder ops */
292 if ((pDecOps->Init == NULL) || (pDecOps->Finalize == NULL) ||
293 (pDecOps->Get_ActualBufferCount == NULL) || (pDecOps->Set_FrameTag == NULL) ||
294 #ifdef USE_S3D_SUPPORT
295 (pDecOps->Enable_SEIParsing == NULL) || (pDecOps->Get_FramePackingInfo == NULL) ||
297 (pDecOps->Get_FrameTag == NULL)) {
298 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
299 ret = OMX_ErrorInsufficientResources;
303 /* check mandatory functions for buffer ops */
304 if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
305 (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
306 (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
307 (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
308 (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
309 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
310 ret = OMX_ErrorInsufficientResources;
314 /* alloc context, open, querycap */
315 if (pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
317 pH264Dec->hMFCH264Handle.hMFCHandle = pH264Dec->hMFCH264Handle.pDecOps->Init(V4L2_MEMORY_DMABUF);
319 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s :%d V4L2_MEMORY_USERPTR", __FUNCTION__, __LINE__);
320 pH264Dec->hMFCH264Handle.hMFCHandle = pH264Dec->hMFCH264Handle.pDecOps->Init(V4L2_MEMORY_USERPTR);
323 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s :%d V4L2_MEMORY_DMABUF", __FUNCTION__, __LINE__);
324 pH264Dec->hMFCH264Handle.hMFCHandle = pH264Dec->hMFCH264Handle.pDecOps->Init(V4L2_MEMORY_DMABUF);
326 if (pH264Dec->hMFCH264Handle.hMFCHandle == NULL) {
327 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
328 ret = OMX_ErrorInsufficientResources;
332 #ifdef USE_S3D_SUPPORT
333 /*S3D: Enable SEI parsing to check Frame Packing */
334 if (pDecOps->Enable_SEIParsing(pH264Dec->hMFCH264Handle.hMFCHandle) != VIDEO_ERROR_NONE) {
335 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Enable SEI Parsing");
336 ret = OMX_ErrorInsufficientResources;
344 if (ret != OMX_ErrorNone) {
345 if (pDecOps != NULL) {
346 Exynos_OSAL_Free(pDecOps);
347 pH264Dec->hMFCH264Handle.pDecOps = NULL;
349 if (pInbufOps != NULL) {
350 Exynos_OSAL_Free(pInbufOps);
351 pH264Dec->hMFCH264Handle.pInbufOps = NULL;
353 if (pOutbufOps != NULL) {
354 Exynos_OSAL_Free(pOutbufOps);
355 pH264Dec->hMFCH264Handle.pOutbufOps = NULL;
364 OMX_ERRORTYPE H264CodecClose(EXYNOS_H264DEC_HANDLE *pH264Dec)
366 OMX_ERRORTYPE ret = OMX_ErrorNone;
367 void *hMFCHandle = NULL;
368 ExynosVideoDecOps *pDecOps = NULL;
369 ExynosVideoDecBufferOps *pInbufOps = NULL;
370 ExynosVideoDecBufferOps *pOutbufOps = NULL;
374 if (pH264Dec == NULL) {
375 ret = OMX_ErrorBadParameter;
379 hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
380 pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
381 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
382 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
384 if (hMFCHandle != NULL) {
385 pDecOps->Finalize(hMFCHandle);
386 pH264Dec->hMFCH264Handle.hMFCHandle = NULL;
388 if (pOutbufOps != NULL) {
389 Exynos_OSAL_Free(pOutbufOps);
390 pH264Dec->hMFCH264Handle.pOutbufOps = NULL;
392 if (pInbufOps != NULL) {
393 Exynos_OSAL_Free(pInbufOps);
394 pH264Dec->hMFCH264Handle.pInbufOps = NULL;
396 if (pDecOps != NULL) {
397 Exynos_OSAL_Free(pDecOps);
398 pH264Dec->hMFCH264Handle.pDecOps = NULL;
409 OMX_ERRORTYPE H264CodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
411 OMX_ERRORTYPE ret = OMX_ErrorNone;
412 void *hMFCHandle = NULL;
413 ExynosVideoDecBufferOps *pInbufOps = NULL;
414 ExynosVideoDecBufferOps *pOutbufOps = NULL;
415 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
416 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
420 if (pOMXComponent == NULL) {
421 ret = OMX_ErrorBadParameter;
425 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
426 if (pVideoDec == NULL) {
427 ret = OMX_ErrorBadParameter;
431 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
432 if (pH264Dec == NULL) {
433 ret = OMX_ErrorBadParameter;
437 hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
438 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
439 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
441 if (nPortIndex == INPUT_PORT_INDEX)
442 pInbufOps->Run(hMFCHandle);
443 else if (nPortIndex == OUTPUT_PORT_INDEX)
444 pOutbufOps->Run(hMFCHandle);
454 OMX_ERRORTYPE H264CodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
456 OMX_ERRORTYPE ret = OMX_ErrorNone;
457 void *hMFCHandle = NULL;
458 ExynosVideoDecBufferOps *pInbufOps = NULL;
459 ExynosVideoDecBufferOps *pOutbufOps = NULL;
460 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
461 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
465 if (pOMXComponent == NULL) {
466 ret = OMX_ErrorBadParameter;
470 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
471 if (pVideoDec == NULL) {
472 ret = OMX_ErrorBadParameter;
475 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
476 if (pH264Dec == NULL) {
477 ret = OMX_ErrorBadParameter;
481 hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
482 pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
483 pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
485 if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
486 pInbufOps->Stop(hMFCHandle);
487 else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
488 pOutbufOps->Stop(hMFCHandle);
498 OMX_ERRORTYPE H264CodecSrcInit(OMX_COMPONENTTYPE *pOMXComponent)
500 OMX_ERRORTYPE ret = OMX_ErrorNone;
501 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
502 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
503 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
504 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
505 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
506 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
508 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
509 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
510 ExynosVideoGeometry bufferConf;
511 OMX_U32 inputBufferNumber = 0;
515 if (pVideoDec->bThumbnailMode == OMX_TRUE)
516 pDecOps->Set_DisplayDelay(hMFCHandle, 0);
518 /* input buffer info */
519 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
520 bufferConf.eCompressionFormat = VIDEO_CODING_AVC;
522 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE
523 ||pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
524 pInbufOps->Set_Shareable(hMFCHandle);
526 if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
527 bufferConf.nSizeImage = pExynosInputPort->portDefinition.format.video.nFrameWidth
528 * pExynosInputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
529 inputBufferNumber = MAX_VIDEO_INPUTBUFFER_NUM;
530 } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
531 bufferConf.nSizeImage = DEFAULT_MFC_INPUT_BUFFER_SIZE;
532 inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
535 /* should be done before prepare input buffer */
536 if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
537 ret = OMX_ErrorInsufficientResources;
541 /* set input buffer geometry */
542 if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
543 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
544 ret = OMX_ErrorInsufficientResources;
548 /* setup input buffer */
549 if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
550 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
551 ret = OMX_ErrorInsufficientResources;
555 if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
556 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
557 /* Register input buffer */
558 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
559 ExynosVideoPlane plane;
560 plane.addr = pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0];
561 plane.allocSize = pVideoDec->pMFCDecInputBuffer[i]->bufferSize[0];
562 plane.fd = pVideoDec->pMFCDecInputBuffer[i]->fd[0];
563 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
564 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
565 ret = OMX_ErrorInsufficientResources;
569 } else if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
570 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_FALSE) {
571 ExynosVideoBuffer *pBuffer = NULL;
573 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
574 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
575 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
576 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
577 /* get input buffer info */
578 if (pInbufOps->Get_Buffer) {
579 if (pInbufOps->Get_Buffer(pH264Dec->hMFCH264Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
580 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
581 ret = OMX_ErrorInsufficientResources;
586 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
587 /* Use ION Allocator */
588 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
589 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
590 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
591 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
592 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
595 #ifdef TIZEN_FEATURE_E3250
596 if (pExynosInputPort == NULL || pExynosOutputPort == NULL || pOMXComponent == NULL) {
597 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "invalid param: pExynosInputPort= %p pExynosOutputPort= %p pOMXComponent= %p", pExynosInputPort, pExynosOutputPort, pOMXComponent);
600 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
602 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
603 /* Register input buffer */
604 for (i = 0; i < pExynosInputPort->portDefinition.nBufferCountActual; i++) {
605 ExynosVideoPlane plane;
607 if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
609 #ifdef TIZEN_FEATURE_E54XX
610 /* IL Client assigns FD value in pBuffer */
611 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
613 plane.addr = Exynos_OSAL_SharedMemory_IONToVirt(pVideoDec->hSharedMemory, (int)pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer);
617 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
620 plane.allocSize = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
621 plane.fd = pExynosInputPort->extendBufferHeader[i].buf_fd[0];
622 if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
623 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
624 ret = OMX_ErrorInsufficientResources;
637 OMX_ERRORTYPE H264CodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
639 OMX_ERRORTYPE ret = OMX_ErrorNone;
640 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
641 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
645 if (pOMXComponent == NULL) {
646 ret = OMX_ErrorBadParameter;
650 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
651 if (pVideoDec == NULL) {
652 ret = OMX_ErrorBadParameter;
655 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
656 if (pH264Dec == NULL) {
657 ret = OMX_ErrorBadParameter;
662 if (nPortIndex == INPUT_PORT_INDEX) {
663 if (pH264Dec->bSourceStart == OMX_FALSE) {
664 Exynos_OSAL_SignalSet(pH264Dec->hSourceStartEvent);
665 Exynos_OSAL_SleepMillisec(0);
669 if (nPortIndex == OUTPUT_PORT_INDEX) {
670 if (pH264Dec->bDestinationStart == OMX_FALSE) {
671 Exynos_OSAL_SignalSet(pH264Dec->hDestinationStartEvent);
672 Exynos_OSAL_SleepMillisec(0);
684 OMX_ERRORTYPE H264CodecEnQueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
686 OMX_ERRORTYPE ret = OMX_ErrorNone;
687 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
688 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
689 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
690 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
693 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
694 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
695 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
699 if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
700 ret = OMX_ErrorBadPortIndex;
704 if ((nPortIndex == INPUT_PORT_INDEX) &&
705 (pH264Dec->bSourceStart == OMX_TRUE)) {
706 Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
708 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
709 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
710 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]);
712 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
715 pInbufOps->Clear_Queue(hMFCHandle);
716 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
717 (pH264Dec->bDestinationStart == OMX_TRUE)) {
718 ExynosVideoBuffer *pBuffer = NULL;
720 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
722 nOutbufs = pDecOps->Get_ActualBufferCount(hMFCHandle);
723 nOutbufs += EXTRA_DPB_NUM;
724 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "EXTRA_DPB_NUM = %d, nOutbufs =%d", EXTRA_DPB_NUM, nOutbufs);
725 for (i = 0; i < nOutbufs; i++) {
726 pOutbufOps->Get_Buffer(hMFCHandle, i, &pBuffer);
727 Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR)pBuffer);
729 pOutbufOps->Clear_Queue(hMFCHandle);
738 #ifdef USE_S3D_SUPPORT
739 OMX_BOOL H264CodecCheckFramePacking(OMX_COMPONENTTYPE *pOMXComponent)
741 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
742 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
743 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
744 ExynosVideoFramePacking framePacking;
745 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
746 OMX_BOOL ret = OMX_FALSE;
748 /* Get Frame packing information*/
749 if (pDecOps->Get_FramePackingInfo(pH264Dec->hMFCH264Handle.hMFCHandle, &framePacking) != VIDEO_ERROR_NONE) {
750 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Get Frame Packing Information");
755 if (framePacking.available) {
756 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "arrangement ID: 0x%08x", framePacking.arrangement_id);
757 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "arrangement_type: %d", framePacking.arrangement_type);
758 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "content_interpretation_type: %d", framePacking.content_interpretation_type);
759 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "current_frame_is_frame0_flag: %d", framePacking.current_frame_is_frame0_flag);
760 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "spatial_flipping_flag: %d", framePacking.spatial_flipping_flag);
761 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "fr0X:%d fr0Y:%d fr0X:%d fr0Y:%d", framePacking.frame0_grid_pos_x,
762 framePacking.frame0_grid_pos_y, framePacking.frame1_grid_pos_x, framePacking.frame1_grid_pos_y);
764 pH264Dec->hMFCH264Handle.S3DFPArgmtType = (EXYNOS_OMX_FPARGMT_TYPE) framePacking.arrangement_type;
765 /** Send Port Settings changed call back - output color format change */
766 (*(pExynosComponent->pCallbacks->EventHandler))
768 pExynosComponent->callbackData,
769 OMX_EventPortSettingsChanged, /* The command was completed */
770 OMX_DirOutput, /* This is the port index */
774 Exynos_OSAL_SleepMillisec(0);
783 OMX_ERRORTYPE H264CodecDstFreeCodecBuffers(
784 OMX_COMPONENTTYPE *pOMXComponent)
786 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
787 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
788 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
794 for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
795 if (pVideoDec->pMFCDecOutputBuffer[i] != NULL) {
796 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
797 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] != NULL &&
798 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
799 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
802 Exynos_OSAL_Free(pVideoDec->pMFCDecOutputBuffer[i]);
806 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer, 0, sizeof(pVideoDec->pMFCDecOutputBuffer));
810 return OMX_ErrorNone;
813 OMX_ERRORTYPE H264CodecDstAllocCodecBuffers(
814 OMX_COMPONENTTYPE *pOMXComponent,
817 OMX_ERRORTYPE ret = OMX_ErrorNone;
818 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
819 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
820 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
822 MEMORY_TYPE eMemoryType = NORMAL_MEMORY;
823 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
828 nAllocLen[0] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
829 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight);
830 nAllocLen[1] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
831 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight >> 1);
833 if (pVideoDec->bDRMPlayerMode == OMX_TRUE)
834 eMemoryType = SECURE_MEMORY;
836 for (i = 0; i < nOutbufs; i++) {
837 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
838 if (pVideoDec->pMFCDecOutputBuffer[i] == NULL) {
839 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc codec buffer");
840 ret = OMX_ErrorInsufficientResources;
843 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
845 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
846 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] =
847 (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, nAllocLen[j], eMemoryType);
848 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] == NULL) {
849 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc output buffer");
850 ret = OMX_ErrorInsufficientResources;
854 pVideoDec->pMFCDecOutputBuffer[i]->fd[j] =
855 Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory,
856 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
857 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j] = nAllocLen[j];
861 return OMX_ErrorNone;
864 H264CodecDstFreeCodecBuffers(pOMXComponent);
871 OMX_ERRORTYPE H264CodecDstRegistCodecBuffers(
872 OMX_COMPONENTTYPE *pOMXComponent,
875 OMX_ERRORTYPE ret = OMX_ErrorNone;
876 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
877 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
878 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
879 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
880 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
882 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
883 OMX_U32 nDataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
888 /* Register output buffer */
889 for (i = 0; i < nOutbufs; i++) {
890 for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
891 planes[j].addr = pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j];
892 planes[j].fd = pVideoDec->pMFCDecOutputBuffer[i]->fd[j];
893 planes[j].allocSize = pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j];
896 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
897 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
898 ret = OMX_ErrorInsufficientResources;
902 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
903 (unsigned int *)nDataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
914 OMX_ERRORTYPE H264CodecResetupAllElement(
915 OMX_COMPONENTTYPE *pOMXComponent,
918 OMX_ERRORTYPE ret = OMX_ErrorNone;
919 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
920 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
921 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
922 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
923 EXYNOS_OMX_BASEPORT *pOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
924 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
928 if ((nPortIndex == INPUT_PORT_INDEX) &&
929 (pH264Dec->bSourceStart == OMX_TRUE)) {
930 ret = OMX_ErrorNotImplemented;
932 } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
933 (pH264Dec->bDestinationStart == OMX_TRUE)) {
934 if (pOutputPort->bufferProcessType & BUFFER_COPY) {
936 /**********************************/
937 /* Codec Buffer Free & Unregister */
938 /**********************************/
939 H264CodecDstFreeCodecBuffers(pOMXComponent);
940 Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
942 if (pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
943 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
945 pOutbufOps->Cleanup(hMFCHandle);
946 /******************************************************/
947 /* V4L2 Destnation Setup for DPB Buffer Number Change */
948 /******************************************************/
949 H264CodecDstSetup(pOMXComponent);
951 pVideoDec->bDRCProcessing = OMX_FALSE;
952 } else if (pOutputPort->bufferProcessType & BUFFER_SHARE) {
954 /**********************************/
955 /* Codec Buffer Unregister */
956 /**********************************/
957 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
958 pOutbufOps->Cleanup(hMFCHandle);
961 ret = OMX_ErrorBadParameter;
971 OMX_ERRORTYPE H264CodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
973 OMX_ERRORTYPE ret = OMX_ErrorNone;
974 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
975 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
976 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
977 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
978 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
980 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
981 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
982 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
983 ExynosVideoGeometry bufferConf;
987 if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
988 OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
989 OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
990 if (OMXBuffer == NULL) {
991 ret = OMX_ErrorUndefined;
995 OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
996 OMXBuffer->nFlags = pSrcInputData->nFlags;
997 Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
1003 if (!((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
1004 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_FALSE)) {
1005 ret = H264CodecSrcInit(pOMXComponent);
1006 if (ret != OMX_ErrorNone)
1010 /* set output geometry */
1011 Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
1012 pH264Dec->hMFCH264Handle.MFCOutputColorType = bufferConf.eColorFormat = VIDEO_COLORFORMAT_NV12;
1013 if (pOutbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
1014 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
1015 ret = OMX_ErrorInsufficientResources;
1019 /* input buffer enqueue for header parsing */
1020 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d", oneFrameSize);
1021 if (pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
1022 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader) != VIDEO_ERROR_NONE) {
1023 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to enqueue input buffer for header parsing");
1024 // ret = OMX_ErrorInsufficientResources;
1025 ret = (OMX_ERRORTYPE)OMX_ErrorCodecInit;
1029 /* start header parsing */
1030 if (pInbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1031 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run input buffer for header parsing");
1032 ret = OMX_ErrorCodecInit;
1036 ret = H264CodecCheckResolutionChange(pOMXComponent);
1037 if (ret != OMX_ErrorNone) {
1038 ret = OMX_ErrorCodecInit;
1042 Exynos_OSAL_SleepMillisec(0);
1043 ret = OMX_ErrorInputDataDecodeYet;
1045 #ifdef USE_IMMEDIATE_DISPLAY
1046 /* Set Immediately display for I Frame*/
1047 pDecOps->Set_ImmediateDisplay(hMFCHandle);
1051 H264CodecStop(pOMXComponent, INPUT_PORT_INDEX);
1057 OMX_ERRORTYPE H264CodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
1059 OMX_ERRORTYPE ret = OMX_ErrorNone;
1060 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1061 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1062 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
1063 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
1064 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1066 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
1067 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
1074 nOutbufs = pH264Dec->hMFCH264Handle.maxDPBNum;
1076 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1077 /* should be done before prepare output buffer */
1078 if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1079 ret = OMX_ErrorInsufficientResources;
1084 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE
1085 ||pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE)
1086 pOutbufOps->Set_Shareable(hMFCHandle);
1088 if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
1089 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1090 ret = OMX_ErrorInsufficientResources;
1094 ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1095 OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1096 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1099 nAllocLen[0] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
1100 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight);
1101 nAllocLen[1] = calc_plane(pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth,
1102 pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight >> 1);
1104 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1105 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
1106 H264CodecDstAllocCodecBuffers(pOMXComponent, nOutbufs);
1107 H264CodecDstRegistCodecBuffers(pOMXComponent, nOutbufs);
1108 } else if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1109 pH264Dec->hMFCH264Handle.bShareableBuf == OMX_FALSE) {
1111 /* Register output buffer */
1112 for (i = 0; i < nOutbufs; i++) {
1114 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1115 ExynosVideoBuffer *pBuffer = NULL;
1116 pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1117 Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1119 if (pOutbufOps->Get_Buffer) {
1120 if (pOutbufOps->Get_Buffer(pH264Dec->hMFCH264Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
1121 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get Output buffer info");
1122 ret = OMX_ErrorInsufficientResources;
1127 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1128 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
1129 pVideoDec->pMFCDecOutputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
1130 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
1133 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1134 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1136 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1138 if (pExynosOutputPort->bIsPBEnabled == OMX_TRUE) {
1139 for (i = 0; i < pExynosOutputPort->assignedBufferNum; i++) {
1140 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1141 planes[plane].fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[plane];
1142 planes[plane].addr = pExynosOutputPort->extendBufferHeader[i].pYUVBuf[plane];
1143 planes[plane].tbm_bo = pExynosOutputPort->extendBufferHeader[i].tbm_bo[plane];
1144 planes[plane].allocSize = nAllocLen[plane];
1147 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1148 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1149 ret = OMX_ErrorInsufficientResources;
1152 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
1153 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1156 ret = OMX_ErrorNotImplemented;
1160 ret = OMX_ErrorNotImplemented;
1163 /* Waiting for DPB buffer setup to be completed,
1164 * valid only for share mode
1166 if (pDecOps->Enable_DecodeWait != NULL)
1167 pDecOps->Enable_DecodeWait(hMFCHandle);
1171 if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1172 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1173 ret = OMX_ErrorInsufficientResources;
1177 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1178 H264CodecStop(pOMXComponent, OUTPUT_PORT_INDEX);
1180 pH264Dec->hMFCH264Handle.bConfiguredMFCDst = OMX_TRUE;
1182 ret = OMX_ErrorNone;
1190 OMX_ERRORTYPE H264CodecCheckResolutionChange(OMX_COMPONENTTYPE *pOMXComponent)
1192 OMX_ERRORTYPE ret = OMX_ErrorNone;
1193 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1194 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1195 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1196 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
1197 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1198 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1200 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
1201 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
1205 /* get geometry for output */
1206 Exynos_OSAL_Memset(&pH264Dec->hMFCH264Handle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
1207 if (pOutbufOps->Get_Geometry(hMFCHandle, &pH264Dec->hMFCH264Handle.codecOutbufConf) != VIDEO_ERROR_NONE) {
1208 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
1209 ret = OMX_ErrorInsufficientResources;
1214 pH264Dec->hMFCH264Handle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
1215 if (pVideoDec->bThumbnailMode == OMX_FALSE)
1216 pH264Dec->hMFCH264Handle.maxDPBNum += EXTRA_DPB_NUM;
1217 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "H264CodecCheckResolutionChange H264CodecSetup nOutbufs: %d", pH264Dec->hMFCH264Handle.maxDPBNum);
1219 pH264Dec->hMFCH264Handle.bConfiguredMFCSrc = OMX_TRUE;
1221 pExynosOutputPort->cropRectangle.nTop = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nTop;
1222 pExynosOutputPort->cropRectangle.nLeft = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nLeft;
1223 pExynosOutputPort->cropRectangle.nWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nWidth;
1224 pExynosOutputPort->cropRectangle.nHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nHeight;
1226 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1227 if ((pVideoDec->bDRCProcessing) ||
1228 (pExynosInputPort->portDefinition.format.video.nFrameWidth != pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth) ||
1229 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight)) {
1230 pExynosInputPort->portDefinition.format.video.nFrameWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth;
1231 pExynosInputPort->portDefinition.format.video.nFrameHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight;
1232 pExynosInputPort->portDefinition.format.video.nStride = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1233 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1235 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1236 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1238 Exynos_UpdateFrameSize(pOMXComponent);
1239 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1241 /** Send Port Settings changed call back **/
1242 (*(pExynosComponent->pCallbacks->EventHandler))
1244 pExynosComponent->callbackData,
1245 OMX_EventPortSettingsChanged, /* The command was completed */
1246 OMX_DirOutput, /* This is the port index */
1250 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1251 #ifndef TIZEN_FEATURE_E3250
1252 /* The input port information has already been updated */
1253 if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth) ||
1254 (pExynosInputPort->portDefinition.format.video.nFrameHeight != pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight) ||
1255 (pExynosOutputPort->portDefinition.nBufferCountActual != pH264Dec->hMFCH264Handle.maxDPBNum)) {
1256 pExynosInputPort->portDefinition.format.video.nFrameWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth;
1257 pExynosInputPort->portDefinition.format.video.nFrameHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight;
1258 pExynosInputPort->portDefinition.format.video.nStride = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1259 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1261 if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1262 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1264 #ifdef TIZEN_FEATURE_E3250
1265 pExynosOutputPort->portDefinition.nBufferCountActual = pH264Dec->hMFCH264Handle.maxDPBNum;
1266 pExynosOutputPort->portDefinition.nBufferCountMin = pH264Dec->hMFCH264Handle.maxDPBNum;
1268 pExynosOutputPort->portDefinition.nBufferCountActual = pH264Dec->hMFCH264Handle.maxDPBNum - 4;
1269 pExynosOutputPort->portDefinition.nBufferCountMin = pH264Dec->hMFCH264Handle.maxDPBNum - 4;
1271 Exynos_UpdateFrameSize(pOMXComponent);
1272 pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1274 /** Send Port Settings changed call back **/
1275 (*(pExynosComponent->pCallbacks->EventHandler))
1277 pExynosComponent->callbackData,
1278 OMX_EventPortSettingsChanged, /* The command was completed */
1279 OMX_DirOutput, /* This is the port index */
1282 #ifndef TIZEN_FEATURE_E3250
1287 if (((pVideoDec->bDRCProcessing) && (pExynosOutputPort->bufferProcessType & BUFFER_COPY)) ||
1288 (pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth != pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nWidth) ||
1289 (pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight != pH264Dec->hMFCH264Handle.codecOutbufConf.cropRect.nHeight)) {
1291 pExynosInputPort->portDefinition.format.video.nFrameWidth = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth;
1292 pExynosInputPort->portDefinition.format.video.nFrameHeight = pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight;
1293 pExynosInputPort->portDefinition.format.video.nStride = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1294 pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pH264Dec->hMFCH264Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1295 Exynos_UpdateFrameSize(pOMXComponent);
1297 /** Send crop info call back **/
1298 (*(pExynosComponent->pCallbacks->EventHandler))
1300 pExynosComponent->callbackData,
1301 OMX_EventPortSettingsChanged, /* The command was completed */
1302 OMX_DirOutput, /* This is the port index */
1303 OMX_IndexConfigCommonOutputCrop,
1307 ret = OMX_ErrorNone;
1315 OMX_ERRORTYPE Exynos_H264Dec_GetParameter(
1316 OMX_IN OMX_HANDLETYPE hComponent,
1317 OMX_IN OMX_INDEXTYPE nParamIndex,
1318 OMX_INOUT OMX_PTR pComponentParameterStructure)
1320 OMX_ERRORTYPE ret = OMX_ErrorNone;
1321 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1322 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1326 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1327 ret = OMX_ErrorBadParameter;
1330 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1331 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1332 if (ret != OMX_ErrorNone) {
1335 if (pOMXComponent->pComponentPrivate == NULL) {
1336 ret = OMX_ErrorBadParameter;
1340 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1341 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1342 ret = OMX_ErrorInvalidState;
1346 switch (nParamIndex) {
1347 case OMX_IndexParamVideoAvc:
1349 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
1350 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
1351 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1353 ret = Exynos_OMX_Check_SizeVersion(pDstAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1354 if (ret != OMX_ErrorNone) {
1358 if (pDstAVCComponent->nPortIndex >= ALL_PORT_NUM) {
1359 ret = OMX_ErrorBadPortIndex;
1363 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1364 pSrcAVCComponent = &pH264Dec->AVCComponent[pDstAVCComponent->nPortIndex];
1366 Exynos_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1369 case OMX_IndexParamStandardComponentRole:
1371 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1372 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1373 if (ret != OMX_ErrorNone) {
1377 Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H264_DEC_ROLE);
1380 case OMX_IndexParamVideoProfileLevelQuerySupported:
1382 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
1383 EXYNOS_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
1384 OMX_U32 maxProfileLevelNum = 0;
1386 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1387 if (ret != OMX_ErrorNone) {
1391 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1392 ret = OMX_ErrorBadPortIndex;
1396 pProfileLevel = supportedAVCProfileLevels;
1397 maxProfileLevelNum = sizeof(supportedAVCProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1399 if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
1400 ret = OMX_ErrorNoMore;
1404 pProfileLevel += pDstProfileLevel->nProfileIndex;
1405 pDstProfileLevel->eProfile = pProfileLevel->profile;
1406 pDstProfileLevel->eLevel = pProfileLevel->level;
1409 case OMX_IndexParamVideoProfileLevelCurrent:
1411 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
1412 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
1413 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1415 ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1416 if (ret != OMX_ErrorNone) {
1420 if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1421 ret = OMX_ErrorBadPortIndex;
1425 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1426 pSrcAVCComponent = &pH264Dec->AVCComponent[pDstProfileLevel->nPortIndex];
1428 pDstProfileLevel->eProfile = pSrcAVCComponent->eProfile;
1429 pDstProfileLevel->eLevel = pSrcAVCComponent->eLevel;
1432 case OMX_IndexParamVideoErrorCorrection:
1434 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1435 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1436 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1438 ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1439 if (ret != OMX_ErrorNone) {
1443 if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1444 ret = OMX_ErrorBadPortIndex;
1448 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1449 pSrcErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX];
1451 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1452 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1453 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1454 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1455 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1459 ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1468 OMX_ERRORTYPE Exynos_H264Dec_SetParameter(
1469 OMX_IN OMX_HANDLETYPE hComponent,
1470 OMX_IN OMX_INDEXTYPE nIndex,
1471 OMX_IN OMX_PTR pComponentParameterStructure)
1473 OMX_ERRORTYPE ret = OMX_ErrorNone;
1474 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1475 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1479 if (hComponent == NULL || pComponentParameterStructure == NULL) {
1480 ret = OMX_ErrorBadParameter;
1483 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1484 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1485 if (ret != OMX_ErrorNone) {
1488 if (pOMXComponent->pComponentPrivate == NULL) {
1489 ret = OMX_ErrorBadParameter;
1493 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1494 if (pExynosComponent->currentState == OMX_StateInvalid ) {
1495 ret = OMX_ErrorInvalidState;
1500 case OMX_IndexParamVideoAvc:
1502 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
1503 OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
1504 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1506 ret = Exynos_OMX_Check_SizeVersion(pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1507 if (ret != OMX_ErrorNone) {
1511 if (pSrcAVCComponent->nPortIndex >= ALL_PORT_NUM) {
1512 ret = OMX_ErrorBadPortIndex;
1516 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1517 pDstAVCComponent = &pH264Dec->AVCComponent[pSrcAVCComponent->nPortIndex];
1519 Exynos_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1522 case OMX_IndexParamStandardComponentRole:
1524 OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1526 ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1527 if (ret != OMX_ErrorNone) {
1531 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1532 ret = OMX_ErrorIncorrectStateOperation;
1536 if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H264_DEC_ROLE)) {
1537 pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
1539 ret = OMX_ErrorBadParameter;
1544 case OMX_IndexParamPortDefinition:
1546 OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1547 OMX_U32 portIndex = pPortDefinition->nPortIndex;
1548 EXYNOS_OMX_BASEPORT *pExynosPort;
1549 OMX_U32 width, height, size;
1550 OMX_U32 realWidth, realHeight;
1551 OMX_PARAM_PORTDEFINITIONTYPE portDefinition_backup;
1553 if (portIndex >= pExynosComponent->portParam.nPorts) {
1554 ret = OMX_ErrorBadPortIndex;
1557 ret = Exynos_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1558 if (ret != OMX_ErrorNone) {
1562 pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1564 if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1565 if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1566 ret = OMX_ErrorIncorrectStateOperation;
1570 if (pPortDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1571 ret = OMX_ErrorBadParameter;
1575 Exynos_OSAL_Memcpy(&portDefinition_backup, &pExynosPort->portDefinition, pPortDefinition->nSize);
1576 Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
1577 RESTORE_READONLYPARAMETERS_OMX_PARAM_PORTDEFINITIONTYPE(&pExynosPort->portDefinition,&portDefinition_backup);
1579 realWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1580 realHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1581 width = ((realWidth + 15) & (~15));
1582 height = ((realHeight + 15) & (~15));
1583 size = (width * height * 3) / 2;
1584 pExynosPort->portDefinition.format.video.nStride = width;
1585 pExynosPort->portDefinition.format.video.nSliceHeight = height;
1586 pExynosPort->portDefinition.nBufferSize = (size > pExynosPort->portDefinition.nBufferSize) ? size : pExynosPort->portDefinition.nBufferSize;
1588 if (portIndex == INPUT_PORT_INDEX) {
1589 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1590 pExynosOutputPort->portDefinition.format.video.nFrameWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1591 pExynosOutputPort->portDefinition.format.video.nFrameHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1592 pExynosOutputPort->portDefinition.format.video.nStride = width;
1593 pExynosOutputPort->portDefinition.format.video.nSliceHeight = height;
1595 switch ((int)pExynosOutputPort->portDefinition.format.video.eColorFormat) {
1596 case OMX_COLOR_FormatYUV420Planar:
1597 case OMX_COLOR_FormatYUV420SemiPlanar:
1598 pExynosOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
1600 #ifdef TIZEN_FEATURE_E3250 /* NV12 fd */
1601 case OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd:
1602 case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
1603 pExynosOutputPort->portDefinition.nBufferSize = sizeof(MMVideoBuffer);
1606 case OMX_SEC_COLOR_FormatNV12Tiled:
1607 pExynosOutputPort->portDefinition.nBufferSize =
1608 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1609 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1612 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Color format is not support!! use default YUV size!!");
1613 ret = OMX_ErrorUnsupportedSetting;
1617 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1618 pExynosOutputPort->portDefinition.nBufferSize =
1619 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1620 calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1625 case OMX_IndexParamVideoProfileLevelCurrent:
1627 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1628 OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
1629 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1631 ret = Exynos_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1632 if (ret != OMX_ErrorNone)
1635 if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1636 ret = OMX_ErrorBadPortIndex;
1640 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1642 pDstAVCComponent = &pH264Dec->AVCComponent[pSrcProfileLevel->nPortIndex];
1643 pDstAVCComponent->eProfile = pSrcProfileLevel->eProfile;
1644 pDstAVCComponent->eLevel = pSrcProfileLevel->eLevel;
1647 case OMX_IndexParamVideoErrorCorrection:
1649 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1650 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1651 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1653 ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1654 if (ret != OMX_ErrorNone) {
1658 if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1659 ret = OMX_ErrorBadPortIndex;
1663 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1664 pDstErrorCorrectionType = &pH264Dec->errorCorrectionType[INPUT_PORT_INDEX];
1666 pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1667 pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1668 pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1669 pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1670 pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1674 ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1683 OMX_ERRORTYPE Exynos_H264Dec_GetConfig(
1684 OMX_HANDLETYPE hComponent,
1685 OMX_INDEXTYPE nIndex,
1686 OMX_PTR pComponentConfigStructure)
1688 OMX_ERRORTYPE ret = OMX_ErrorNone;
1689 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1690 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1694 if (hComponent == NULL) {
1695 ret = OMX_ErrorBadParameter;
1698 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1699 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1700 if (ret != OMX_ErrorNone) {
1703 if (pOMXComponent->pComponentPrivate == NULL) {
1704 ret = OMX_ErrorBadParameter;
1707 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1708 if (pComponentConfigStructure == NULL) {
1709 ret = OMX_ErrorBadParameter;
1712 if (pExynosComponent->currentState == OMX_StateInvalid) {
1713 ret = OMX_ErrorInvalidState;
1718 case OMX_IndexConfigCommonOutputCrop:
1720 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1721 OMX_CONFIG_RECTTYPE *pSrcRectType = NULL;
1722 OMX_CONFIG_RECTTYPE *pDstRectType = NULL;
1723 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1725 if (pH264Dec->hMFCH264Handle.bConfiguredMFCSrc == OMX_FALSE) {
1726 ret = OMX_ErrorNotReady;
1730 pDstRectType = (OMX_CONFIG_RECTTYPE *)pComponentConfigStructure;
1732 if ((pDstRectType->nPortIndex != INPUT_PORT_INDEX) &&
1733 (pDstRectType->nPortIndex != OUTPUT_PORT_INDEX)) {
1734 ret = OMX_ErrorBadPortIndex;
1738 EXYNOS_OMX_BASEPORT *pExynosPort = &pExynosComponent->pExynosPort[pDstRectType->nPortIndex];
1740 pSrcRectType = &(pExynosPort->cropRectangle);
1742 pDstRectType->nTop = pSrcRectType->nTop;
1743 pDstRectType->nLeft = pSrcRectType->nLeft;
1744 pDstRectType->nHeight = pSrcRectType->nHeight;
1745 pDstRectType->nWidth = pSrcRectType->nWidth;
1748 #ifdef USE_S3D_SUPPORT
1749 case OMX_IndexVendorS3DMode:
1751 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
1752 OMX_U32 *pS3DMode = NULL;
1753 pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1755 pS3DMode = (OMX_U32 *)pComponentConfigStructure;
1756 *pS3DMode = (OMX_U32) pH264Dec->hMFCH264Handle.S3DFPArgmtType;
1761 ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1771 OMX_ERRORTYPE Exynos_H264Dec_SetConfig(
1772 OMX_HANDLETYPE hComponent,
1773 OMX_INDEXTYPE nIndex,
1774 OMX_PTR pComponentConfigStructure)
1776 OMX_ERRORTYPE ret = OMX_ErrorNone;
1777 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1778 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1782 if (hComponent == NULL) {
1783 ret = OMX_ErrorBadParameter;
1786 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1787 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1788 if (ret != OMX_ErrorNone) {
1791 if (pOMXComponent->pComponentPrivate == NULL) {
1792 ret = OMX_ErrorBadParameter;
1795 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1796 if (pComponentConfigStructure == NULL) {
1797 ret = OMX_ErrorBadParameter;
1800 if (pExynosComponent->currentState == OMX_StateInvalid) {
1801 ret = OMX_ErrorInvalidState;
1807 ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1817 OMX_ERRORTYPE Exynos_H264Dec_GetExtensionIndex(
1818 OMX_IN OMX_HANDLETYPE hComponent,
1819 OMX_IN OMX_STRING cParameterName,
1820 OMX_OUT OMX_INDEXTYPE *pIndexType)
1822 OMX_ERRORTYPE ret = OMX_ErrorNone;
1823 OMX_COMPONENTTYPE *pOMXComponent = NULL;
1824 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1828 if (hComponent == NULL) {
1829 ret = OMX_ErrorBadParameter;
1832 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1833 ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1834 if (ret != OMX_ErrorNone) {
1837 if (pOMXComponent->pComponentPrivate == NULL) {
1838 ret = OMX_ErrorBadParameter;
1841 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1842 if ((cParameterName == NULL) || (pIndexType == NULL)) {
1843 ret = OMX_ErrorBadParameter;
1846 if (pExynosComponent->currentState == OMX_StateInvalid) {
1847 ret = OMX_ErrorInvalidState;
1851 if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1852 *pIndexType = OMX_IndexVendorThumbnailMode;
1853 ret = OMX_ErrorNone;
1855 #ifdef USE_S3D_SUPPORT
1856 else if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_GET_S3D) == 0) {
1857 *pIndexType = OMX_IndexVendorS3DMode;
1858 ret = OMX_ErrorNone;
1862 ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1871 OMX_ERRORTYPE Exynos_H264Dec_ComponentRoleEnum(
1872 OMX_HANDLETYPE hComponent,
1876 OMX_ERRORTYPE ret = OMX_ErrorNone;
1880 if ((hComponent == NULL) || (cRole == NULL)) {
1881 ret = OMX_ErrorBadParameter;
1884 if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
1885 Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_H264_DEC_ROLE);
1886 ret = OMX_ErrorNone;
1888 ret = OMX_ErrorNoMore;
1898 OMX_ERRORTYPE Exynos_H264Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
1900 OMX_ERRORTYPE ret = OMX_ErrorNone;
1901 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1902 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1903 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1904 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1905 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
1907 CSC_METHOD csc_method = CSC_METHOD_SW;
1912 pH264Dec->hMFCH264Handle.bConfiguredMFCSrc = OMX_FALSE;
1913 pH264Dec->hMFCH264Handle.bConfiguredMFCDst = OMX_FALSE;
1914 pExynosComponent->bUseFlagEOF = OMX_TRUE;
1915 pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1917 /* H.264 Codec Open */
1918 ret = H264CodecOpen(pH264Dec);
1919 if (ret != OMX_ErrorNone) {
1923 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1924 Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1925 Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1927 if (pH264Dec->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
1928 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1929 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1930 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1931 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
1933 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
1934 /* Use ION Allocator */
1935 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, DEFAULT_MFC_INPUT_BUFFER_SIZE, NORMAL_MEMORY);
1936 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1937 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = DEFAULT_MFC_INPUT_BUFFER_SIZE;
1938 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
1939 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] == NULL) {
1940 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
1941 ret = OMX_ErrorInsufficientResources;
1944 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1947 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
1950 #ifdef TIZEN_FEATURE_E3250
1951 if (pOMXComponent == NULL) {
1952 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d: invalid parm: pOMXComponent = %p", __FUNCTION__, __LINE__, pOMXComponent);
1955 ret = H264CodecSrcInit(pOMXComponent);
1956 if (ret != OMX_ErrorNone)
1959 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1963 /* Does not require any actions. */
1966 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1967 Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
1968 Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1969 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1973 /* Does not require any actions. */
1976 pH264Dec->bSourceStart = OMX_FALSE;
1977 Exynos_OSAL_SignalCreate(&pH264Dec->hSourceStartEvent);
1978 pH264Dec->bDestinationStart = OMX_FALSE;
1979 Exynos_OSAL_SignalCreate(&pH264Dec->hDestinationStartEvent);
1981 Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
1982 Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
1983 pH264Dec->hMFCH264Handle.indexTimestamp = 0;
1984 pH264Dec->hMFCH264Handle.outputIndexTimestamp = 0;
1986 pExynosComponent->getAllDelayBuffer = OMX_FALSE;
1988 #if 0//defined(USE_CSC_GSCALER)
1989 csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
1991 if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
1992 pVideoDec->csc_handle = csc_init(CSC_METHOD_HW);
1993 csc_set_hw_property(pVideoDec->csc_handle, CSC_HW_PROPERTY_FIXED_NODE, 2);
1994 csc_set_hw_property(pVideoDec->csc_handle, CSC_HW_PROPERTY_MODE_DRM, pVideoDec->bDRMPlayerMode);
1996 pVideoDec->csc_handle = csc_init(csc_method);
1999 if (pVideoDec->csc_handle == NULL) {
2000 ret = OMX_ErrorInsufficientResources;
2003 pVideoDec->csc_set_format = OMX_FALSE;
2012 OMX_ERRORTYPE Exynos_H264Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
2014 OMX_ERRORTYPE ret = OMX_ErrorNone;
2015 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2016 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2017 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2018 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2019 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2025 if (pVideoDec->csc_handle != NULL) {
2026 csc_deinit(pVideoDec->csc_handle);
2027 pVideoDec->csc_handle = NULL;
2030 Exynos_OSAL_SignalTerminate(pH264Dec->hDestinationStartEvent);
2031 pH264Dec->hDestinationStartEvent = NULL;
2032 pH264Dec->bDestinationStart = OMX_FALSE;
2033 Exynos_OSAL_SignalTerminate(pH264Dec->hSourceStartEvent);
2034 pH264Dec->hSourceStartEvent = NULL;
2035 pH264Dec->bSourceStart = OMX_FALSE;
2037 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2038 H264CodecDstFreeCodecBuffers(pOMXComponent);
2040 Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
2041 Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
2042 } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2046 /* Does not require any actions. */
2049 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2050 for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2051 if (pVideoDec->pMFCDecInputBuffer[i] != NULL) {
2052 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2053 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2054 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] != NULL)
2055 Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2058 Exynos_OSAL_Free(pVideoDec->pMFCDecInputBuffer[i]);
2059 pVideoDec->pMFCDecInputBuffer[i] = NULL;
2063 Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
2064 Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
2065 } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2069 /* Does not require any actions. */
2071 H264CodecClose(pH264Dec);
2079 OMX_ERRORTYPE Exynos_H264Dec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2081 OMX_ERRORTYPE ret = OMX_ErrorNone;
2082 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2083 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2084 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2085 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2086 OMX_U32 oneFrameSize = pSrcInputData->dataLen;
2087 OMX_BOOL bInStartCode = OMX_FALSE;
2088 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2089 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
2090 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2094 if (pH264Dec->hMFCH264Handle.bConfiguredMFCSrc == OMX_FALSE) {
2095 ret = H264CodecSrcSetup(pOMXComponent, pSrcInputData);
2098 if (pH264Dec->hMFCH264Handle.bConfiguredMFCDst == OMX_FALSE) {
2099 ret = H264CodecDstSetup(pOMXComponent);
2102 if (((pVideoDec->bDRMPlayerMode == OMX_TRUE) ||
2103 ((bInStartCode = Check_H264_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize)) == OMX_TRUE)) ||
2104 ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2105 pExynosComponent->timeStamp[pH264Dec->hMFCH264Handle.indexTimestamp] = pSrcInputData->timeStamp;
2106 pExynosComponent->nFlags[pH264Dec->hMFCH264Handle.indexTimestamp] = pSrcInputData->nFlags;
2107 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "input timestamp %lld us (%.2f secs), Tag: %d, nFlags: 0x%x", pSrcInputData->timeStamp, pSrcInputData->timeStamp / 1E6, pH264Dec->hMFCH264Handle.indexTimestamp, pSrcInputData->nFlags);
2108 pDecOps->Set_FrameTag(hMFCHandle, pH264Dec->hMFCH264Handle.indexTimestamp);
2109 pH264Dec->hMFCH264Handle.indexTimestamp++;
2110 pH264Dec->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP;
2112 #ifdef USE_IMMEDIATE_DISPLAY
2113 /* Set Immediately display for I Frame*/
2115 if (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
2116 if ( pExynosComponent->checkTimeStamp.bImmediateDisplay == OMX_FALSE) {
2117 /* Enable Immediately display After seek*/
2118 pDecOps->Set_ImmediateDisplay(hMFCHandle);
2119 pExynosComponent->checkTimeStamp.bImmediateDisplay = OMX_TRUE;
2124 /*Add First Frame check : */
2125 if((pSrcInputData->nFlags & OMX_BUFFERFLAG_CODECCONFIG) == OMX_BUFFERFLAG_CODECCONFIG)
2127 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"Video First Frame Coming");
2130 /* queue work for input buffer */
2131 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
2132 codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
2133 (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
2134 if (codecReturn != VIDEO_ERROR_NONE) {
2135 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2136 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2139 H264CodecStart(pOMXComponent, INPUT_PORT_INDEX);
2140 if (pH264Dec->bSourceStart == OMX_FALSE) {
2141 pH264Dec->bSourceStart = OMX_TRUE;
2142 Exynos_OSAL_SignalSet(pH264Dec->hSourceStartEvent);
2143 Exynos_OSAL_SleepMillisec(0);
2145 if (pH264Dec->bDestinationStart == OMX_FALSE) {
2146 pH264Dec->bDestinationStart = OMX_TRUE;
2147 Exynos_OSAL_SignalSet(pH264Dec->hDestinationStartEvent);
2148 Exynos_OSAL_SleepMillisec(0);
2150 } else if (bInStartCode == OMX_FALSE) {
2151 ret = OMX_ErrorCorruptedFrame;
2155 ret = OMX_ErrorNone;
2163 OMX_ERRORTYPE Exynos_H264Dec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2165 OMX_ERRORTYPE ret = OMX_ErrorNone;
2166 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2167 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2168 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2169 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2170 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2171 ExynosVideoDecBufferOps *pInbufOps = pH264Dec->hMFCH264Handle.pInbufOps;
2172 ExynosVideoBuffer *pVideoBuffer;
2176 pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
2178 pSrcOutputData->dataLen = 0;
2179 pSrcOutputData->usedDataLen = 0;
2180 pSrcOutputData->remainDataLen = 0;
2181 pSrcOutputData->nFlags = 0;
2182 pSrcOutputData->timeStamp = 0;
2184 if (pVideoBuffer == NULL) {
2185 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
2186 pSrcOutputData->allocSize = 0;
2187 pSrcOutputData->pPrivate = NULL;
2188 pSrcOutputData->bufferHeader = NULL;
2190 pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2191 pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2192 pSrcOutputData->allocSize = pVideoBuffer->planes[0].allocSize;
2194 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2196 while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
2198 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2199 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
2200 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2204 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2205 pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
2208 /* For Share Buffer */
2209 pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2212 ret = OMX_ErrorNone;
2220 OMX_ERRORTYPE Exynos_H264Dec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2222 OMX_ERRORTYPE ret = OMX_ErrorNone;
2223 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2224 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2225 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2226 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2227 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2228 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
2229 OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0,};
2230 ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2234 if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
2235 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2236 ret = OMX_ErrorBadParameter;
2240 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
2241 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
2242 pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
2244 if ((pVideoDec->bDRCProcessing == OMX_TRUE) &&
2245 (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) &&
2246 (pExynosOutputPort->exceptionFlag == GENERAL_STATE)) {
2247 ret = H264CodecDstSetup(pOMXComponent);
2248 if (ret != OMX_ErrorNone) {
2249 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "DRC Reconfig H264CodecDstSetup Failed");
2252 pVideoDec->bDRCProcessing = OMX_FALSE;
2255 codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
2256 (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
2258 if (codecReturn != VIDEO_ERROR_NONE) {
2259 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2260 ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2263 H264CodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2265 ret = OMX_ErrorNone;
2273 OMX_ERRORTYPE Exynos_H264Dec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2275 OMX_ERRORTYPE ret = OMX_ErrorNone;
2276 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2277 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2278 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
2279 void *hMFCHandle = pH264Dec->hMFCH264Handle.hMFCHandle;
2280 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2281 ExynosVideoDecOps *pDecOps = pH264Dec->hMFCH264Handle.pDecOps;
2282 ExynosVideoDecBufferOps *pOutbufOps = pH264Dec->hMFCH264Handle.pOutbufOps;
2283 ExynosVideoBuffer *pVideoBuffer;
2284 ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2285 ExynosVideoGeometry *bufferGeometry;
2286 DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
2287 OMX_S32 indexTimestamp = 0;
2292 if (pH264Dec->bDestinationStart == OMX_FALSE) {
2293 ret = OMX_ErrorNone;
2298 pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle);
2299 if (pVideoBuffer == (ExynosVideoBuffer *)VIDEO_ERROR_DQBUF_EIO) {
2300 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "HW is not available");
2301 ret = OMX_ErrorHardware;
2305 if (pVideoBuffer == NULL) {
2306 ret = OMX_ErrorNone;
2309 displayStatus = pVideoBuffer->displayStatus;
2310 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
2312 if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
2313 (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
2314 (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2315 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2316 (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2317 if (pVideoBuffer != NULL) {
2318 ret = OMX_ErrorNone;
2321 ret = OMX_ErrorUndefined;
2327 if (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) {
2328 if (pVideoDec->bDRCProcessing != OMX_TRUE) {
2329 pExynosOutputPort->exceptionFlag = NEED_PORT_FLUSH;
2330 pVideoDec->bDRCProcessing = OMX_TRUE;
2331 H264CodecCheckResolutionChange(pOMXComponent);
2332 pVideoDec->csc_set_format = OMX_FALSE;
2334 ret = OMX_ErrorNone;
2338 pH264Dec->hMFCH264Handle.outputIndexTimestamp++;
2339 pH264Dec->hMFCH264Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
2341 pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
2342 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
2343 pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2344 pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2345 pDstOutputData->buffer.multiPlaneBuffer.tbm_bo[plane] = pVideoBuffer->planes[plane].tbm_bo;
2346 pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
2347 pDstOutputData->dataLen += pVideoBuffer->planes[plane].dataSize;
2349 pDstOutputData->usedDataLen = 0;
2350 pDstOutputData->pPrivate = pVideoBuffer;
2351 /* For Share Buffer */
2352 pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2354 pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
2355 bufferGeometry = &pH264Dec->hMFCH264Handle.codecOutbufConf;
2356 pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
2357 pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
2358 switch (bufferGeometry->eColorFormat) {
2359 case VIDEO_COLORFORMAT_NV12:
2360 #ifdef TIZEN_FEATURE_E3250 /* NV12 fd */
2361 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
2363 pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2366 case VIDEO_COLORFORMAT_NV12_TILED:
2368 pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
2372 #ifdef USE_S3D_SUPPORT
2373 /* Check Whether frame packing information is available */
2374 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
2375 pVideoDec->bThumbnailMode == OMX_FALSE &&
2376 pH264Dec->hMFCH264Handle.S3DFPArgmtType == OMX_SEC_FPARGMT_NONE) {
2377 H264CodecCheckFramePacking(pOMXComponent);
2381 indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
2382 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
2383 if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2384 if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
2385 (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
2386 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2387 pDstOutputData->nFlags = pExynosComponent->nFlags[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2388 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
2390 pDstOutputData->timeStamp = 0x00;
2391 pDstOutputData->nFlags = 0x00;
2394 /* For timestamp correction. if mfc support frametype detect */
2395 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
2396 //#ifdef NEED_TIMESTAMP_REORDER
2397 /* TIZEN_FEATURE_E3250 */
2398 if (pVideoDec->bNeedTimestampReorder == OMX_TRUE) {
2399 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NEED_TIMESTAMP_REORDER ON");
2400 if ((pVideoBuffer->frameType == VIDEO_FRAME_I)) {
2401 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2402 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2403 pH264Dec->hMFCH264Handle.outputIndexTimestamp = indexTimestamp;
2405 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2406 pDstOutputData->nFlags = pExynosComponent->nFlags[pH264Dec->hMFCH264Handle.outputIndexTimestamp];
2410 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2411 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2414 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
2417 if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2418 (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2419 ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2420 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
2421 pDstOutputData->remainDataLen = 0;
2423 pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
2426 ret = OMX_ErrorNone;
2434 OMX_ERRORTYPE Exynos_H264Dec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2436 OMX_ERRORTYPE ret = OMX_ErrorNone;
2437 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2439 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2443 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2444 ret = OMX_ErrorNone;
2447 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2448 ret = OMX_ErrorNone;
2452 ret = Exynos_H264Dec_SrcIn(pOMXComponent, pSrcInputData);
2453 if ((ret != OMX_ErrorNone) &&
2454 (ret != (OMX_ERRORTYPE)OMX_ErrorInputDataDecodeYet) &&
2455 (ret != (OMX_ERRORTYPE)OMX_ErrorCorruptedFrame)) {
2456 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2457 pExynosComponent->callbackData,
2458 OMX_EventError, ret, 0, NULL);
2467 OMX_ERRORTYPE Exynos_H264Dec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2469 OMX_ERRORTYPE ret = OMX_ErrorNone;
2470 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2471 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2472 EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2476 if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2477 ret = OMX_ErrorNone;
2481 if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2482 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2483 ret = OMX_ErrorNone;
2487 if ((pH264Dec->bSourceStart == OMX_FALSE) &&
2488 (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2489 Exynos_OSAL_SignalWait(pH264Dec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2490 Exynos_OSAL_SignalReset(pH264Dec->hSourceStartEvent);
2493 ret = Exynos_H264Dec_SrcOut(pOMXComponent, pSrcOutputData);
2494 if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2495 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2496 pExynosComponent->callbackData,
2497 OMX_EventError, ret, 0, NULL);
2506 OMX_ERRORTYPE Exynos_H264Dec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2508 OMX_ERRORTYPE ret = OMX_ErrorNone;
2509 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2510 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2511 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2515 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2516 ret = OMX_ErrorNone;
2519 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2520 ret = OMX_ErrorNone;
2523 if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2524 if ((pH264Dec->bDestinationStart == OMX_FALSE) &&
2525 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2526 Exynos_OSAL_SignalWait(pH264Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2527 Exynos_OSAL_SignalReset(pH264Dec->hDestinationStartEvent);
2530 if (pH264Dec->hMFCH264Handle.bConfiguredMFCDst == OMX_TRUE) {
2531 ret = Exynos_H264Dec_DstIn(pOMXComponent, pDstInputData);
2532 if (ret != OMX_ErrorNone) {
2533 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2534 pExynosComponent->callbackData,
2535 OMX_EventError, ret, 0, NULL);
2545 OMX_ERRORTYPE Exynos_H264Dec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2547 OMX_ERRORTYPE ret = OMX_ErrorNone;
2548 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2549 EXYNOS_H264DEC_HANDLE *pH264Dec = (EXYNOS_H264DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2550 EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2554 if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2555 ret = OMX_ErrorNone;
2558 if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2559 ret = OMX_ErrorNone;
2563 if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2564 if ((pH264Dec->bDestinationStart == OMX_FALSE) &&
2565 (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2566 Exynos_OSAL_SignalWait(pH264Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2567 Exynos_OSAL_SignalReset(pH264Dec->hDestinationStartEvent);
2570 ret = Exynos_H264Dec_DstOut(pOMXComponent, pDstOutputData);
2571 if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2572 pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2573 pExynosComponent->callbackData,
2574 OMX_EventError, ret, 0, NULL);
2583 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
2585 OMX_ERRORTYPE ret = OMX_ErrorNone;
2586 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2587 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2588 EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
2589 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2590 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
2591 OMX_BOOL bDRMPlayerMode = OMX_FALSE;
2596 if ((hComponent == NULL) || (componentName == NULL)) {
2597 ret = OMX_ErrorBadParameter;
2598 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2601 if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H264_DEC, componentName) == 0) {
2602 bDRMPlayerMode = OMX_FALSE;
2603 } else if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H264_DRM_DEC, componentName) == 0) {
2604 bDRMPlayerMode = OMX_TRUE;
2606 ret = OMX_ErrorBadParameter;
2607 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2611 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2612 ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
2613 if (ret != OMX_ErrorNone) {
2614 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2617 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2618 pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
2620 pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2621 if (pExynosComponent->componentName == NULL) {
2622 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2623 ret = OMX_ErrorInsufficientResources;
2624 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2627 Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2629 pH264Dec = Exynos_OSAL_Malloc(sizeof(EXYNOS_H264DEC_HANDLE));
2630 if (pH264Dec == NULL) {
2631 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2632 ret = OMX_ErrorInsufficientResources;
2633 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2636 Exynos_OSAL_Memset(pH264Dec, 0, sizeof(EXYNOS_H264DEC_HANDLE));
2637 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2638 pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pH264Dec;
2640 if (bDRMPlayerMode == OMX_TRUE)
2641 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H264_DRM_DEC);
2643 Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H264_DEC);
2645 pVideoDec->bDRMPlayerMode = bDRMPlayerMode;
2646 /* In case of BUFFER_COPY mode
2647 bShareableBuf = TRUE means MemoryType is V4L2_MEMORY_USERPTR
2648 bShareableBuf = FALSE means MemoryType is V4L2_MEMORY_MMAP
2649 In case of BUFFER_SHARE
2650 bShareableBuf should be TRUE, FALSE is ignored
2652 pH264Dec->hMFCH264Handle.bShareableBuf = OMX_FALSE;
2653 #ifdef USE_S3D_SUPPORT
2654 pH264Dec->hMFCH264Handle.S3DFPArgmtType = OMX_SEC_FPARGMT_NONE;
2657 /* Set componentVersion */
2658 pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2659 pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2660 pExynosComponent->componentVersion.s.nRevision = REVISION_NUMBER;
2661 pExynosComponent->componentVersion.s.nStep = STEP_NUMBER;
2662 /* Set specVersion */
2663 pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2664 pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2665 pExynosComponent->specVersion.s.nRevision = REVISION_NUMBER;
2666 pExynosComponent->specVersion.s.nStep = STEP_NUMBER;
2669 pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2670 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2671 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2672 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2673 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2674 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2675 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
2676 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2677 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/avc");
2678 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2679 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2680 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2681 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2682 pExynosPort->bufferProcessType = BUFFER_COPY;
2683 if (bDRMPlayerMode == OMX_TRUE)
2684 pExynosPort->bufferProcessType = BUFFER_SHARE;
2685 pExynosPort->portWayType = WAY2_PORT;
2688 pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2689 pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2690 pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2691 pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2692 pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2693 pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2694 pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2695 Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2696 Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2697 pExynosPort->portDefinition.format.video.pNativeRender = 0;
2698 pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2699 #ifdef TIZEN_FEATURE_E3250
2700 pExynosPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
2702 pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2704 pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2705 #ifdef TIZEN_FEATURE_E3250
2706 pExynosPort->bufferProcessType = BUFFER_SHARE;
2708 pExynosPort->bufferProcessType = BUFFER_COPY;
2710 pExynosPort->portWayType = WAY2_PORT;
2712 for(i = 0; i < ALL_PORT_NUM; i++) {
2713 INIT_SET_SIZE_VERSION(&pH264Dec->AVCComponent[i], OMX_VIDEO_PARAM_AVCTYPE);
2714 pH264Dec->AVCComponent[i].nPortIndex = i;
2715 pH264Dec->AVCComponent[i].eProfile = OMX_VIDEO_AVCProfileBaseline;
2716 pH264Dec->AVCComponent[i].eLevel = OMX_VIDEO_AVCLevel4;
2719 pOMXComponent->GetParameter = &Exynos_H264Dec_GetParameter;
2720 pOMXComponent->SetParameter = &Exynos_H264Dec_SetParameter;
2721 pOMXComponent->GetConfig = &Exynos_H264Dec_GetConfig;
2722 pOMXComponent->SetConfig = &Exynos_H264Dec_SetConfig;
2723 pOMXComponent->GetExtensionIndex = &Exynos_H264Dec_GetExtensionIndex;
2724 pOMXComponent->ComponentRoleEnum = &Exynos_H264Dec_ComponentRoleEnum;
2725 pOMXComponent->ComponentDeInit = &Exynos_OMX_ComponentDeinit;
2727 pExynosComponent->exynos_codec_componentInit = &Exynos_H264Dec_Init;
2728 pExynosComponent->exynos_codec_componentTerminate = &Exynos_H264Dec_Terminate;
2730 pVideoDec->exynos_codec_srcInputProcess = &Exynos_H264Dec_srcInputBufferProcess;
2731 pVideoDec->exynos_codec_srcOutputProcess = &Exynos_H264Dec_srcOutputBufferProcess;
2732 pVideoDec->exynos_codec_dstInputProcess = &Exynos_H264Dec_dstInputBufferProcess;
2733 pVideoDec->exynos_codec_dstOutputProcess = &Exynos_H264Dec_dstOutputBufferProcess;
2735 pVideoDec->exynos_codec_start = &H264CodecStart;
2736 pVideoDec->exynos_codec_stop = &H264CodecStop;
2737 pVideoDec->exynos_codec_bufferProcessRun = &H264CodecOutputBufferProcessRun;
2738 pVideoDec->exynos_codec_enqueueAllBuffer = &H264CodecEnQueueAllBuffer;
2739 pVideoDec->exynos_codec_resetupAllElement = &H264CodecResetupAllElement;
2741 pVideoDec->exynos_checkInputFrame = NULL;
2742 pVideoDec->exynos_codec_getCodecInputPrivateData = &GetCodecInputPrivateData;
2743 pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2745 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2746 pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2747 if (pVideoDec->hSharedMemory == NULL) {
2748 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2749 Exynos_OSAL_Free(pH264Dec);
2750 pH264Dec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2751 Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2752 ret = OMX_ErrorInsufficientResources;
2756 pExynosComponent->currentState = OMX_StateLoaded;
2758 ret = OMX_ErrorNone;
2766 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
2768 OMX_ERRORTYPE ret = OMX_ErrorNone;
2769 OMX_COMPONENTTYPE *pOMXComponent = NULL;
2770 EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
2771 EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2772 EXYNOS_H264DEC_HANDLE *pH264Dec = NULL;
2776 if (hComponent == NULL) {
2777 ret = OMX_ErrorBadParameter;
2780 pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2781 pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2782 pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2784 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2785 Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2787 Exynos_OSAL_Free(pExynosComponent->componentName);
2788 pExynosComponent->componentName = NULL;
2790 pH264Dec = (EXYNOS_H264DEC_HANDLE *)pVideoDec->hCodecHandle;
2791 if (pH264Dec != NULL) {
2792 Exynos_OSAL_Free(pH264Dec);
2793 pH264Dec = pVideoDec->hCodecHandle = NULL;
2796 ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2797 if (ret != OMX_ErrorNone) {
2801 ret = OMX_ErrorNone;