openmax/component/video/dec/mpeg4/Exynos_OMX_Mpeg4dec.c

   1 /*
   2  *
   3  * Copyright 2012 Samsung Electronics S.LSI Co. LTD
   4  *
   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
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  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.
  16  */
  17
  18 /*
  19  * @file      Exynos_OMX_Mpeg4dec.c
  20  * @brief
  21  * @author    Yunji Kim (yunji.kim@samsung.com)
  22  * @author    SeungBeom Kim (sbcrux.kim@samsung.com)
  23  * @version   2.0.0
  24  * @history
  25  *   2012.02.20 : Create
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <mm_types.h>
  32
  33 #include "Exynos_OMX_Macros.h"
  34 #include "Exynos_OMX_Basecomponent.h"
  35 #include "Exynos_OMX_Baseport.h"
  36 #include "Exynos_OMX_Vdec.h"
  37 #include "Exynos_OSAL_ETC.h"
  38 #include "Exynos_OSAL_Semaphore.h"
  39 #include "Exynos_OSAL_Thread.h"
  40 #include "library_register.h"
  41 #include "Exynos_OMX_Mpeg4dec.h"
  42 #include "ExynosVideoApi.h"
  43 #include "Exynos_OSAL_SharedMemory.h"
  44 #include "Exynos_OSAL_Event.h"
  45
  46 #ifdef USE_PB
  47 #include "Exynos_OSAL_Platform_Specific.h"
  48 #endif
  49
  50 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
  51 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
  52 #include "csc.h"
  53
  54 #undef  EXYNOS_LOG_TAG
  55 #define EXYNOS_LOG_TAG    "EXYNOS_MPEG4_DEC"
  56 #define EXYNOS_LOG_OFF
  57 //#define EXYNOS_TRACE_ON
  58 #include "Exynos_OSAL_Log.h"
  59
  60 #define MPEG4_DEC_NUM_OF_EXTRA_BUFFERS 7
  61
  62 //#define FULL_FRAME_SEARCH
  63
  64 /* MPEG4 Decoder Supported Levels & profiles */
  65 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedMPEG4ProfileLevels[] ={
  66     {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0},
  67     {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0b},
  68     {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level1},
  69     {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level2},
  70     {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level3},
  71     {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4},
  72     {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4a},
  73     {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level5},
  74     {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0},
  75     {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0b},
  76     {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level1},
  77     {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level2},
  78     {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level3},
  79     {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4},
  80     {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4a},
  81     {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level5}};
  82
  83 /* H.263 Decoder Supported Levels & profiles */
  84 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedH263ProfileLevels[] = {
  85     /* Baseline (Profile 0) */
  86     {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level10},
  87     {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level20},
  88     {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level30},
  89     {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level40},
  90     {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45},
  91     {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level50},
  92     {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level60},
  93     {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level70},
  94     /* Profile 1 */
  95     {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level10},
  96     {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level20},
  97     {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level30},
  98     {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level40},
  99     {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level45},
 100     {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level50},
 101     {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level60},
 102     {OMX_VIDEO_H263ProfileH320Coding, OMX_VIDEO_H263Level70},
 103     /* Profile 2 */
 104     {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level10},
 105     {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level20},
 106     {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level30},
 107     {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level40},
 108     {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level45},
 109     {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level50},
 110     {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level60},
 111     {OMX_VIDEO_H263ProfileBackwardCompatible, OMX_VIDEO_H263Level70},
 112     /* Profile 3, restricted up to SD resolution */
 113     {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level10},
 114     {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level20},
 115     {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level30},
 116     {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level40},
 117     {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level45},
 118     {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level50},
 119     {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level60},
 120     {OMX_VIDEO_H263ProfileISWV2, OMX_VIDEO_H263Level70}};
 121
 122
 123 static OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, void *pVirtAddr, OMX_U32 *dataSize)
 124 {
 125     OMX_ERRORTYPE       ret = OMX_ErrorNone;
 126
 127 EXIT:
 128     return ret;
 129 }
 130
 131 static OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, void *addr[], int size[])
 132 {
 133     OMX_ERRORTYPE       ret = OMX_ErrorNone;
 134     ExynosVideoBuffer  *pCodecBuffer;
 135
 136     if (codecBuffer == NULL) {
 137         ret = OMX_ErrorBadParameter;
 138         goto EXIT;
 139     }
 140
 141     pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
 142
 143     if (addr != NULL) {
 144         addr[0] = pCodecBuffer->planes[0].addr;
 145         addr[1] = pCodecBuffer->planes[1].addr;
 146         addr[2] = pCodecBuffer->planes[2].addr;
 147     }
 148
 149     if (size != NULL) {
 150         size[0] = pCodecBuffer->planes[0].allocSize;
 151         size[1] = pCodecBuffer->planes[1].allocSize;
 152         size[2] = pCodecBuffer->planes[2].allocSize;
 153     }
 154
 155 EXIT:
 156     return ret;
 157 }
 158
 159 static OMX_BOOL gbFIMV1 = OMX_FALSE;
 160
 161 static int Check_Mpeg4_Frame(
 162     OMX_U8   *pInputStream,
 163     OMX_U32   buffSize,
 164     OMX_U32   flag,
 165     OMX_BOOL  bPreviousFrameEOF,
 166     OMX_BOOL *pbEndOfFrame)
 167 {
 168     OMX_U32  len;
 169     int      readStream;
 170     unsigned startCode;
 171     OMX_BOOL bFrameStart;
 172
 173     len = 0;
 174     bFrameStart = OMX_FALSE;
 175
 176     if (flag & OMX_BUFFERFLAG_CODECCONFIG) {
 177         if (*pInputStream == 0x03) { /* FIMV1 */
 178             BitmapInfoHhr *pInfoHeader;
 179
 180             pInfoHeader = (BitmapInfoHhr *)(pInputStream + 1);
 181             /* FIXME */
 182             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "############## NOT SUPPORTED #################");
 183             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "width(%d), height(%d)", pInfoHeader->BiWidth, pInfoHeader->BiHeight);
 184             gbFIMV1 = OMX_TRUE;
 185             *pbEndOfFrame = OMX_TRUE;
 186             return buffSize;
 187         }
 188     }
 189
 190     if (gbFIMV1) {
 191         *pbEndOfFrame = OMX_TRUE;
 192         return buffSize;
 193     }
 194
 195     if (bPreviousFrameEOF == OMX_FALSE)
 196         bFrameStart = OMX_TRUE;
 197
 198     startCode = 0xFFFFFFFF;
 199     if (bFrameStart == OMX_FALSE) {
 200         /* find VOP start code */
 201         while(startCode != 0x1B6) {
 202             readStream = *(pInputStream + len);
 203             startCode = (startCode << 8) | readStream;
 204             len++;
 205             if (len > buffSize)
 206                 goto EXIT;
 207         }
 208     }
 209
 210     /* find next VOP start code */
 211     startCode = 0xFFFFFFFF;
 212     while ((startCode != 0x1B6)) {
 213         readStream = *(pInputStream + len);
 214         startCode = (startCode << 8) | readStream;
 215         len++;
 216         if (len > buffSize)
 217             goto EXIT;
 218     }
 219
 220     *pbEndOfFrame = OMX_TRUE;
 221
 222     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "1. Check_Mpeg4_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 4, buffSize);
 223
 224     return len - 4;
 225
 226 EXIT :
 227     *pbEndOfFrame = OMX_FALSE;
 228
 229     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "2. Check_Mpeg4_Frame returned EOF = %d, len = %d, buffSize = %d", *pbEndOfFrame, len - 1, buffSize);
 230
 231     return --len;
 232 }
 233
 234 static int Check_H263_Frame(
 235     OMX_U8   *pInputStream,
 236     OMX_U32   buffSize,
 237     OMX_U32   flag,
 238     OMX_BOOL  bPreviousFrameEOF,
 239     OMX_BOOL *pbEndOfFrame)
 240 {
 241     OMX_U32  len;
 242     int      readStream;
 243     unsigned startCode;
 244     OMX_BOOL bFrameStart = 0;
 245     unsigned pTypeMask   = 0x03;
 246     unsigned pType       = 0;
 247
 248     len = 0;
 249     bFrameStart = OMX_FALSE;
 250
 251     if (bPreviousFrameEOF == OMX_FALSE)
 252         bFrameStart = OMX_TRUE;
 253
 254     startCode = 0xFFFFFFFF;
 255     if (bFrameStart == OMX_FALSE) {
 256         /* find PSC(Picture Start Code) : 0000 0000 0000 0000 1000 00 */
 257         while (((startCode << 8 >> 10) != 0x20) || (pType != 0x02)) {
 258             readStream = *(pInputStream + len);
 259             startCode = (startCode << 8) | readStream;
 260
 261             readStream = *(pInputStream + len + 1);
 262             pType = readStream & pTypeMask;
 263
 264             len++;
 265             if (len > buffSize)
 266                 goto EXIT;
 267         }
 268     }
 269
 270     /* find next PSC */
 271     startCode = 0xFFFFFFFF;
 272     pType = 0;
 273     while (((startCode << 8 >> 10) != 0x20) || (pType != 0x02)) {
 274         readStream = *(pInputStream + len);
 275         startCode = (startCode << 8) | readStream;
 276
 277         readStream = *(pInputStream + len + 1);
 278         pType = readStream & pTypeMask;
 279
 280         len++;
 281         if (len > buffSize)
 282             goto EXIT;
 283     }
 284
 285     *pbEndOfFrame = OMX_TRUE;
 286
 287     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "1. Check_H263_Frame returned EOF = %d, len = %d, iBuffSize = %d", *pbEndOfFrame, len - 3, buffSize);
 288
 289     return len - 3;
 290
 291 EXIT :
 292
 293     *pbEndOfFrame = OMX_FALSE;
 294
 295     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "2. Check_H263_Frame returned EOF = %d, len = %d, iBuffSize = %d", *pbEndOfFrame, len - 1, buffSize);
 296
 297     return --len;
 298 }
 299
 300 static OMX_BOOL Check_Stream_StartCode(
 301     OMX_U8    *pInputStream,
 302     OMX_U32    streamSize,
 303     CODEC_TYPE codecType)
 304 {
 305     switch (codecType) {
 306     case CODEC_TYPE_MPEG4:
 307         if (gbFIMV1) {
 308             return OMX_TRUE;
 309         } else {
 310             if (streamSize < 3) {
 311                 return OMX_FALSE;
 312             } else if ((pInputStream[0] == 0x00) &&
 313                        (pInputStream[1] == 0x00) &&
 314                        (pInputStream[2] == 0x01)) {
 315                 return OMX_TRUE;
 316             } else {
 317                 return OMX_FALSE;
 318             }
 319         }
 320         break;
 321     case CODEC_TYPE_H263:
 322         if (streamSize > 0) {
 323             unsigned startCode = 0xFFFFFFFF;
 324             unsigned pTypeMask = 0x03;
 325             unsigned pType     = 0;
 326             OMX_U32  len       = 0;
 327             int      readStream;
 328             /* Check PSC(Picture Start Code) : 0000 0000 0000 0000 1000 00 */
 329             while (((startCode << 8 >> 10) != 0x20) || (pType != 0x02)) {
 330                 readStream = *(pInputStream + len);
 331                 startCode = (startCode << 8) | readStream;
 332
 333                 readStream = *(pInputStream + len + 1);
 334                 pType = readStream & pTypeMask;
 335
 336                 len++;
 337                 if (len > 0x3)
 338                     break;
 339             }
 340
 341             if (len > 0x3) {
 342                 Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "[%s] Picture Start Code Missing", __FUNCTION__);
 343                 return OMX_FALSE;
 344             } else {
 345                 return OMX_TRUE;
 346             }
 347         } else {
 348             return OMX_FALSE;
 349         }
 350     default:
 351         Exynos_OSAL_Log(EXYNOS_LOG_WARNING, "%s: undefined codec type (%d)", __FUNCTION__, codecType);
 352         return OMX_FALSE;
 353     }
 354 }
 355
 356 static void getAByte(char *buff, int *code)
 357 {
 358     int byte;
 359
 360     *code = (*code << 8);
 361     byte = (int)*buff;
 362     byte &= 0xFF;
 363     *code |= byte;
 364 }
 365
 366 static int Check_IsPBPacked(
 367     OMX_U8    *pInputStream,
 368     OMX_U32    streamSize)
 369 {
 370     OMX_U8 *pStrmBuf = NULL;
 371     int startCode = 0xFFFFFFFF;
 372     int leng_idx = 1;
 373
 374     pStrmBuf = pInputStream;
 375
 376     while (1) {
 377         while (startCode != USR_DATA_START_CODE) {
 378             if ((startCode == VOP_START_CODE) || (leng_idx == streamSize)) {
 379                 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"isPBPacked] VOP START Found !! Non Packed PB.....return");
 380                 return 0;
 381             }
 382             getAByte(pStrmBuf, &startCode);
 383             pStrmBuf++;
 384             leng_idx++;
 385         }
 386         Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"isPBPacked] User Data Found !!");
 387
 388         do {
 389             if (*pStrmBuf == 'p') {
 390                 Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"isPBPacked] Packed PB\n");
 391                 return 1;
 392             }
 393             getAByte(pStrmBuf, &startCode);
 394             pStrmBuf++; leng_idx++;
 395         } while ((leng_idx <= streamSize) && ((startCode >> 8) != MP4_START_CODE));
 396
 397         if (leng_idx > streamSize)
 398             break;
 399     }
 400
 401     Exynos_OSAL_Log(EXYNOS_LOG_TRACE,"isPBPacked] Non Packed PB");
 402
 403     return 0;
 404 }
 405
 406 OMX_ERRORTYPE Mpeg4CodecOpen(EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec)
 407 {
 408     OMX_ERRORTYPE            ret        = OMX_ErrorNone;
 409     ExynosVideoDecOps       *pDecOps    = NULL;
 410     ExynosVideoDecBufferOps *pInbufOps  = NULL;
 411     ExynosVideoDecBufferOps *pOutbufOps = NULL;
 412
 413     FunctionIn();
 414
 415     if (pMpeg4Dec == NULL) {
 416         ret = OMX_ErrorBadParameter;
 417         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
 418         goto EXIT;
 419     }
 420
 421     /* alloc ops structure */
 422     pDecOps    = (ExynosVideoDecOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecOps));
 423     pInbufOps  = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
 424     pOutbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
 425
 426     if ((pDecOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
 427         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate decoder ops buffer");
 428         ret = OMX_ErrorInsufficientResources;
 429         goto EXIT;
 430     }
 431
 432     pMpeg4Dec->hMFCMpeg4Handle.pDecOps    = pDecOps;
 433     pMpeg4Dec->hMFCMpeg4Handle.pInbufOps  = pInbufOps;
 434     pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps = pOutbufOps;
 435
 436     /* function pointer mapping */
 437     pDecOps->nSize    = sizeof(ExynosVideoDecOps);
 438     pInbufOps->nSize  = sizeof(ExynosVideoDecBufferOps);
 439     pOutbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
 440
 441     Exynos_Video_Register_Decoder(pDecOps, pInbufOps, pOutbufOps);
 442
 443     /* check mandatory functions for decoder ops */
 444     if ((pDecOps->Init == NULL) || (pDecOps->Finalize == NULL) ||
 445         (pDecOps->Get_ActualBufferCount == NULL) || (pDecOps->Set_FrameTag == NULL) ||
 446         (pDecOps->Get_FrameTag == NULL)) {
 447         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
 448         ret = OMX_ErrorInsufficientResources;
 449         goto EXIT;
 450     }
 451
 452     /* check mandatory functions for buffer ops */
 453     if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
 454         (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
 455         (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
 456         (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
 457         (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
 458         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
 459         ret = OMX_ErrorInsufficientResources;
 460         goto EXIT;
 461     }
 462
 463     /* alloc context, open, querycap */
 464     if (pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
 465 #ifdef USE_DMA_BUF
 466         pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.pDecOps->Init(V4L2_MEMORY_DMABUF);
 467 #else
 468         pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.pDecOps->Init(V4L2_MEMORY_USERPTR);
 469 #endif
 470     } else {
 471         pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.pDecOps->Init(V4L2_MEMORY_DMABUF);
 472     }
 473     if (pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle == NULL) {
 474         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
 475         ret = OMX_ErrorInsufficientResources;
 476         goto EXIT;
 477     }
 478
 479     ret = OMX_ErrorNone;
 480
 481 EXIT:
 482     if (ret != OMX_ErrorNone) {
 483         if (pDecOps != NULL) {
 484             Exynos_OSAL_Free(pDecOps);
 485             pMpeg4Dec->hMFCMpeg4Handle.pDecOps = NULL;
 486         }
 487         if (pInbufOps != NULL) {
 488             Exynos_OSAL_Free(pInbufOps);
 489             pMpeg4Dec->hMFCMpeg4Handle.pInbufOps = NULL;
 490         }
 491         if (pOutbufOps != NULL) {
 492             Exynos_OSAL_Free(pOutbufOps);
 493             pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps = NULL;
 494         }
 495     }
 496
 497     FunctionOut();
 498
 499     return ret;
 500 }
 501
 502 OMX_ERRORTYPE Mpeg4CodecClose(EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec)
 503 {
 504     OMX_ERRORTYPE            ret        = OMX_ErrorNone;
 505     void                    *hMFCHandle = NULL;
 506     ExynosVideoDecOps       *pDecOps    = NULL;
 507     ExynosVideoDecBufferOps *pInbufOps  = NULL;
 508     ExynosVideoDecBufferOps *pOutbufOps = NULL;
 509
 510     FunctionIn();
 511
 512     if (pMpeg4Dec == NULL) {
 513         ret = OMX_ErrorBadParameter;
 514         goto EXIT;
 515     }
 516
 517     hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
 518     pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
 519     pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
 520     pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
 521
 522     if (hMFCHandle != NULL) {
 523         pDecOps->Finalize(hMFCHandle);
 524         pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle = NULL;
 525     }
 526     if (pOutbufOps != NULL) {
 527         Exynos_OSAL_Free(pOutbufOps);
 528         pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps = NULL;
 529     }
 530     if (pInbufOps != NULL) {
 531         Exynos_OSAL_Free(pInbufOps);
 532         pMpeg4Dec->hMFCMpeg4Handle.pInbufOps = NULL;
 533     }
 534     if (pDecOps != NULL) {
 535         Exynos_OSAL_Free(pDecOps);
 536         pMpeg4Dec->hMFCMpeg4Handle.pDecOps = NULL;
 537     }
 538
 539     ret = OMX_ErrorNone;
 540
 541 EXIT:
 542     FunctionOut();
 543
 544     return ret;
 545 }
 546
 547 OMX_ERRORTYPE Mpeg4CodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 548 {
 549     OMX_ERRORTYPE            ret = OMX_ErrorNone;
 550     void                    *hMFCHandle = NULL;
 551     ExynosVideoDecOps       *pDecOps    = NULL;
 552     ExynosVideoDecBufferOps *pInbufOps  = NULL;
 553     ExynosVideoDecBufferOps *pOutbufOps = NULL;
 554     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
 555     EXYNOS_MPEG4DEC_HANDLE   *pMpeg4Dec = NULL;
 556
 557     FunctionIn();
 558
 559     if (pOMXComponent == NULL) {
 560         ret = OMX_ErrorBadParameter;
 561         goto EXIT;
 562     }
 563
 564     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
 565     if (pVideoDec == NULL) {
 566         ret = OMX_ErrorBadParameter;
 567         goto EXIT;
 568     }
 569
 570     pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
 571     if (pMpeg4Dec == NULL) {
 572         ret = OMX_ErrorBadParameter;
 573         goto EXIT;
 574     }
 575
 576     hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
 577     pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
 578     pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
 579     pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
 580
 581     if (nPortIndex == INPUT_PORT_INDEX)
 582         pInbufOps->Run(hMFCHandle);
 583     else if (nPortIndex == OUTPUT_PORT_INDEX)
 584         pOutbufOps->Run(hMFCHandle);
 585
 586     ret = OMX_ErrorNone;
 587
 588 EXIT:
 589     FunctionOut();
 590
 591     return ret;
 592 }
 593
 594 OMX_ERRORTYPE Mpeg4CodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 595 {
 596     OMX_ERRORTYPE            ret = OMX_ErrorNone;
 597     void                    *hMFCHandle = NULL;
 598     ExynosVideoDecOps       *pDecOps    = NULL;
 599     ExynosVideoDecBufferOps *pInbufOps  = NULL;
 600     ExynosVideoDecBufferOps *pOutbufOps = NULL;
 601     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
 602     EXYNOS_MPEG4DEC_HANDLE   *pMpeg4Dec = NULL;
 603
 604     FunctionIn();
 605
 606     if (pOMXComponent == NULL) {
 607         ret = OMX_ErrorBadParameter;
 608         goto EXIT;
 609     }
 610
 611     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
 612     if (pVideoDec == NULL) {
 613         ret = OMX_ErrorBadParameter;
 614         goto EXIT;
 615     }
 616     pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
 617     if (pMpeg4Dec == NULL) {
 618         ret = OMX_ErrorBadParameter;
 619         goto EXIT;
 620     }
 621
 622     hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
 623     pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
 624     pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
 625     pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
 626
 627     if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
 628         pInbufOps->Stop(hMFCHandle);
 629     else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
 630         pOutbufOps->Stop(hMFCHandle);
 631
 632     ret = OMX_ErrorNone;
 633
 634 EXIT:
 635     FunctionOut();
 636
 637     return ret;
 638 }
 639
 640 OMX_ERRORTYPE Mpeg4CodecSrcInit(OMX_COMPONENTTYPE *pOMXComponent)
 641 {
 642     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 643     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 644     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 645     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 646     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
 647     EXYNOS_OMX_BASEPORT           *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 648     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 649
 650     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
 651     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
 652     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
 653     ExynosVideoGeometry      bufferConf;
 654     OMX_U32                  inputBufferNumber = 0;
 655     int i, plane;
 656
 657     if (pVideoDec->bThumbnailMode == OMX_TRUE)
 658         pDecOps->Set_DisplayDelay(hMFCHandle, 0);
 659
 660     /* input buffer info */
 661     Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
 662     if (pMpeg4Dec->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4)
 663         bufferConf.eCompressionFormat = VIDEO_CODING_MPEG4;
 664     else
 665         bufferConf.eCompressionFormat = VIDEO_CODING_H263;
 666
 667     if (pExynosInputPort->bufferProcessType & BUFFER_SHARE
 668         ||pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE)
 669         pInbufOps->Set_Shareable(hMFCHandle);
 670
 671     if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
 672         bufferConf.nSizeImage = pExynosInputPort->portDefinition.format.video.nFrameWidth
 673                                 * pExynosInputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
 674         inputBufferNumber = MAX_VIDEO_INPUTBUFFER_NUM;
 675     } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
 676         bufferConf.nSizeImage = DEFAULT_MFC_INPUT_BUFFER_SIZE;
 677         inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
 678     }
 679
 680     /* should be done before prepare input buffer */
 681     if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
 682         ret = OMX_ErrorInsufficientResources;
 683         goto EXIT;
 684     }
 685
 686     /* set input buffer geometry */
 687     if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
 688         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
 689         ret = OMX_ErrorInsufficientResources;
 690         goto EXIT;
 691     }
 692
 693     /* setup input buffer */
 694     if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
 695         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
 696         ret = OMX_ErrorInsufficientResources;
 697         goto EXIT;
 698     }
 699
 700     if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
 701         pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
 702         /* Register input buffer */
 703         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
 704             ExynosVideoPlane plane;
 705             plane.addr = pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0];
 706             plane.allocSize = pVideoDec->pMFCDecInputBuffer[i]->bufferSize[0];
 707             plane.fd = pVideoDec->pMFCDecInputBuffer[i]->fd[0];
 708             if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
 709                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
 710                 ret = OMX_ErrorInsufficientResources;
 711                 goto EXIT;
 712             }
 713         }
 714     } else if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
 715         pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_FALSE) {
 716         ExynosVideoBuffer *pBuffer = NULL;
 717
 718         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
 719             pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
 720             Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
 721             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
 722             /* get input buffer info */
 723             if (pInbufOps->Get_Buffer) {
 724                 if (pInbufOps->Get_Buffer(pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
 725                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
 726                     ret = OMX_ErrorInsufficientResources;
 727                     goto EXIT;
 728                 }
 729             }
 730
 731             for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
 732                 /* Use ION Allocator */
 733                 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
 734                 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
 735                 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
 736                 pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
 737                 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "@pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
 738             }
 739
 740 #ifdef SLP_PLATFORM
 741             if (pExynosInputPort == NULL || pExynosOutputPort == NULL || pOMXComponent == NULL) {
 742                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "invalid param: pExynosInputPort= %p pExynosOutputPort= %p pOMXComponent= %p", pExynosInputPort, pExynosOutputPort, pOMXComponent);
 743             }
 744 #endif
 745             Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
 746         }
 747     } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
 748         /* Register input buffer */
 749         for (i = 0; i < pExynosInputPort->portDefinition.nBufferCountActual; i++) {
 750             ExynosVideoPlane plane;
 751             if (pVideoDec->bDRMPlayerMode == OMX_TRUE) {
 752                 plane.addr = Exynos_OSAL_SharedMemory_IONToVirt(pVideoDec->hSharedMemory, pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer);
 753             } else {
 754                 plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
 755             }
 756             plane.allocSize = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
 757             plane.fd = pExynosInputPort->extendBufferHeader[i].buf_fd[0];
 758             if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
 759                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
 760                 ret = OMX_ErrorInsufficientResources;
 761                 goto EXIT;
 762             }
 763         }
 764     }
 765
 766 EXIT:
 767     FunctionOut();
 768
 769     return ret;
 770 }
 771
 772
 773
 774 OMX_ERRORTYPE Mpeg4CodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 775 {
 776     OMX_ERRORTYPE            ret = OMX_ErrorNone;
 777     void                    *hMFCHandle = NULL;
 778     ExynosVideoDecOps       *pDecOps    = NULL;
 779     ExynosVideoDecBufferOps *pInbufOps  = NULL;
 780     ExynosVideoDecBufferOps *pOutbufOps = NULL;
 781     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
 782     EXYNOS_MPEG4DEC_HANDLE   *pMpeg4Dec = NULL;
 783
 784     FunctionIn();
 785
 786     if (pOMXComponent == NULL) {
 787         ret = OMX_ErrorBadParameter;
 788         goto EXIT;
 789     }
 790
 791     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
 792     if (pVideoDec == NULL) {
 793         ret = OMX_ErrorBadParameter;
 794         goto EXIT;
 795     }
 796     pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
 797     if (pMpeg4Dec == NULL) {
 798         ret = OMX_ErrorBadParameter;
 799         goto EXIT;
 800     }
 801
 802     hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
 803     pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
 804     pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
 805     pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
 806
 807     if (nPortIndex == INPUT_PORT_INDEX) {
 808         if (pMpeg4Dec->bSourceStart == OMX_FALSE) {
 809             Exynos_OSAL_SignalSet(pMpeg4Dec->hSourceStartEvent);
 810             Exynos_OSAL_SleepMillisec(0);
 811         }
 812     }
 813
 814     if (nPortIndex == OUTPUT_PORT_INDEX) {
 815         if (pMpeg4Dec->bDestinationStart == OMX_FALSE) {
 816             Exynos_OSAL_SignalSet(pMpeg4Dec->hDestinationStartEvent);
 817             Exynos_OSAL_SleepMillisec(0);
 818         }
 819     }
 820
 821     ret = OMX_ErrorNone;
 822
 823 EXIT:
 824     FunctionOut();
 825
 826     return ret;
 827 }
 828
 829 OMX_ERRORTYPE Mpeg4CodecEnQueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 830 {
 831     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 832     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 833     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 834     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
 835     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
 836     EXYNOS_OMX_BASEPORT           *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 837     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 838     int i, nOutbufs;
 839
 840     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
 841     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
 842     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
 843
 844     FunctionIn();
 845
 846     if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
 847         ret = OMX_ErrorBadPortIndex;
 848         goto EXIT;
 849     }
 850
 851     if ((nPortIndex == INPUT_PORT_INDEX) &&
 852         (pMpeg4Dec->bSourceStart == OMX_TRUE)) {
 853         Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
 854
 855         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
 856             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
 857             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]);
 858
 859             Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
 860         }
 861
 862         pInbufOps->Clear_Queue(hMFCHandle);
 863     } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
 864                (pMpeg4Dec->bDestinationStart == OMX_TRUE)) {
 865         OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
 866         ExynosVideoBuffer *pBuffer = NULL;
 867
 868         Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
 869
 870         nOutbufs = pDecOps->Get_ActualBufferCount(hMFCHandle);
 871         nOutbufs += EXTRA_DPB_NUM;
 872         for (i = 0; i < nOutbufs; i++) {
 873             pOutbufOps->Get_Buffer(hMFCHandle, i, &pBuffer);
 874             Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR)pBuffer);
 875         }
 876         pOutbufOps->Clear_Queue(hMFCHandle);
 877     }
 878
 879 EXIT:
 880     FunctionOut();
 881
 882     return ret;
 883 }
 884
 885
 886 OMX_ERRORTYPE Mpeg4CodecDstFreeCodecBuffers(
 887     OMX_COMPONENTTYPE *pOMXComponent)
 888 {
 889     OMX_ERRORTYPE                  ret              = OMX_ErrorNone;
 890     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 891     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec        = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 892     EXYNOS_MPEG4DEC_HANDLE        *pMpeg4Dec        = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
 893
 894     int i, j;
 895
 896     FunctionIn();
 897
 898     for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
 899         if (pVideoDec->pMFCDecOutputBuffer[i] != NULL) {
 900             for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
 901                 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] != NULL &&
 902                     pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE)
 903                     Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
 904             }
 905
 906             Exynos_OSAL_Free(pVideoDec->pMFCDecOutputBuffer[i]);
 907         }
 908     }
 909
 910     Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer, 0, sizeof(pVideoDec->pMFCDecOutputBuffer));
 911
 912     FunctionOut();
 913
 914     return OMX_ErrorNone;
 915 }
 916
 917 OMX_ERRORTYPE Mpeg4CodecDstAllocCodecBuffers(
 918     OMX_COMPONENTTYPE *pOMXComponent,
 919     OMX_U32            nOutbufs)
 920 {
 921     OMX_ERRORTYPE                  ret              = OMX_ErrorNone;
 922     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 923     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec        = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 924     EXYNOS_MPEG4DEC_HANDLE        *pMpeg4Dec        = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
 925
 926     MEMORY_TYPE eMemoryType                        = NORMAL_MEMORY;
 927     OMX_U32     nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
 928     int i, j;
 929
 930     FunctionIn();
 931
 932     nAllocLen[0] = calc_yplane(pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth,
 933                         pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight);
 934     nAllocLen[1] = calc_uvplane(pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth,
 935                         pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight >> 1);
 936
 937     for (i = 0; i < nOutbufs; i++) {
 938         pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
 939         if (pVideoDec->pMFCDecOutputBuffer[i] == NULL) {
 940             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc codec buffer");
 941             ret = OMX_ErrorInsufficientResources;
 942             goto EXIT;
 943         }
 944         Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
 945
 946         for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
 947             pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] =
 948                 (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, nAllocLen[j], eMemoryType);
 949             if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j] == NULL) {
 950                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc output buffer");
 951                 ret = OMX_ErrorInsufficientResources;
 952                 goto EXIT;
 953             }
 954
 955            pVideoDec->pMFCDecOutputBuffer[i]->fd[j] =
 956                 Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory,
 957                                                  pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j]);
 958            pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j] = nAllocLen[j];
 959         }
 960     }
 961
 962     return OMX_ErrorNone;
 963
 964 EXIT:
 965     Mpeg4CodecDstFreeCodecBuffers(pOMXComponent);
 966
 967     FunctionOut();
 968
 969     return ret;
 970 }
 971
 972 OMX_ERRORTYPE Mpeg4CodecDstRegistCodecBuffers(
 973     OMX_COMPONENTTYPE *pOMXComponent,
 974     OMX_U32            nOutbufs)
 975 {
 976     OMX_ERRORTYPE                  ret              = OMX_ErrorNone;
 977     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 978     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec        = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 979     EXYNOS_MPEG4DEC_HANDLE        *pMpeg4Dec        = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
 980     void                          *hMFCHandle       = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
 981     ExynosVideoDecBufferOps       *pOutbufOps       = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
 982
 983     ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
 984     OMX_U32          nDataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
 985     int i, j;
 986
 987     FunctionIn();
 988
 989     /* Register output buffer */
 990     for (i = 0; i < nOutbufs; i++) {
 991         for (j = 0; j < MFC_OUTPUT_BUFFER_PLANE; j++) {
 992             planes[j].addr      = pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[j];
 993             planes[j].fd        = pVideoDec->pMFCDecOutputBuffer[i]->fd[j];
 994             planes[j].allocSize = pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[j];
 995         }
 996
 997         if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
 998             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
 999             ret = OMX_ErrorInsufficientResources;
1000             goto EXIT;
1001         }
1002
1003         pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1004                         (unsigned int *)nDataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1005     }
1006
1007     ret = OMX_ErrorNone;
1008
1009 EXIT:
1010     FunctionOut();
1011
1012     return ret;
1013 }
1014
1015 OMX_ERRORTYPE Mpeg4CodecResetupAllElement(
1016     OMX_COMPONENTTYPE   *pOMXComponent,
1017     OMX_U32              nPortIndex)
1018 {
1019     OMX_ERRORTYPE                  ret              = OMX_ErrorNone;
1020     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1021     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec        = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1022     EXYNOS_MPEG4DEC_HANDLE        *pMpeg4Dec        = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
1023     void                          *hMFCHandle       = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1024     EXYNOS_OMX_BASEPORT           *pOutputPort      = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1025     ExynosVideoDecBufferOps       *pOutbufOps       = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1026
1027     int i, j, nOutbufs;
1028
1029     FunctionIn();
1030
1031     if ((nPortIndex == INPUT_PORT_INDEX) &&
1032         (pMpeg4Dec->bSourceStart == OMX_TRUE)) {
1033         ret = OMX_ErrorNotImplemented;
1034         goto EXIT;
1035     } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
1036                (pMpeg4Dec->bDestinationStart == OMX_TRUE)) {
1037         if (pOutputPort->bufferProcessType & BUFFER_COPY) {
1038
1039             /**********************************/
1040             /* Codec Buffer Free & Unregister */
1041             /**********************************/
1042             Mpeg4CodecDstFreeCodecBuffers(pOMXComponent);
1043             Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
1044
1045             if (pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE)
1046                 pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
1047
1048             pOutbufOps->Cleanup(hMFCHandle);
1049             /******************************************************/
1050             /* V4L2 Destnation Setup for DPB Buffer Number Change */
1051             /******************************************************/
1052             Mpeg4CodecDstSetup(pOMXComponent);
1053
1054             pVideoDec->bDRCProcessing = OMX_FALSE;
1055         } else if (pOutputPort->bufferProcessType & BUFFER_SHARE) {
1056
1057             /**********************************/
1058             /* Codec Buffer Unregister */
1059             /**********************************/
1060             pOutbufOps->Clear_RegisteredBuffer(hMFCHandle);
1061             pOutbufOps->Cleanup(hMFCHandle);
1062         }
1063     } else {
1064         ret = OMX_ErrorBadParameter;
1065         goto EXIT;
1066     }
1067
1068 EXIT:
1069     FunctionOut();
1070
1071     return ret;
1072 }
1073
1074
1075 OMX_ERRORTYPE Mpeg4CodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1076 {
1077     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
1078     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1079     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1080     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1081     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1082     EXYNOS_OMX_BASEPORT           *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1083     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1084     OMX_U32                     oneFrameSize = pSrcInputData->dataLen;
1085
1086     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1087     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
1088     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1089     ExynosVideoGeometry      bufferConf;
1090     OMX_U32                  inputBufferNumber = 0;
1091     int i;
1092
1093     FunctionIn();
1094
1095     if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
1096         OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
1097         OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
1098         if (OMXBuffer == NULL) {
1099             ret = OMX_ErrorUndefined;
1100             goto EXIT;
1101         }
1102
1103         OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
1104         OMXBuffer->nFlags = pSrcInputData->nFlags;
1105         Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
1106
1107         ret = OMX_ErrorNone;
1108         goto EXIT;
1109     }
1110
1111     if (!((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
1112         pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_FALSE)) {
1113         ret = Mpeg4CodecSrcInit(pOMXComponent);
1114         if (ret != OMX_ErrorNone)
1115             goto EXIT;
1116     }
1117
1118     /*Check for PB Packed*/
1119     if (pMpeg4Dec->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4 &&
1120         Check_IsPBPacked(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize)) {
1121         if (pDecOps->Enable_PackedPB(hMFCHandle) != VIDEO_ERROR_NONE) {
1122             ret = OMX_ErrorInsufficientResources;
1123             goto EXIT;
1124         }
1125         pMpeg4Dec->hMFCMpeg4Handle.bPackedPB = OMX_TRUE;
1126     }
1127
1128     /* set output geometry */
1129     Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
1130     pMpeg4Dec->hMFCMpeg4Handle.MFCOutputColorType = bufferConf.eColorFormat = VIDEO_COLORFORMAT_NV12_TILED;
1131     if (pOutbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
1132         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
1133         ret = OMX_ErrorInsufficientResources;
1134         goto EXIT;
1135     }
1136
1137     /* input buffer enqueue for header parsing */
1138     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d", oneFrameSize);
1139     if (pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
1140                         (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader) != VIDEO_ERROR_NONE) {
1141         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to enqueue input buffer for header parsing");
1142 //        ret = OMX_ErrorInsufficientResources;
1143         ret = (OMX_ERRORTYPE)OMX_ErrorCodecInit;
1144         goto EXIT;
1145     }
1146
1147     /* start header parsing */
1148     if (pInbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1149         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run input buffer for header parsing");
1150         ret = OMX_ErrorCodecInit;
1151         goto EXIT;
1152     }
1153
1154     ret = Mpeg4CodecCheckResolutionChange(pOMXComponent);
1155     if (ret != OMX_ErrorNone) {
1156         ret = OMX_ErrorCodecInit;
1157         goto EXIT;
1158     }
1159
1160     Exynos_OSAL_SleepMillisec(0);
1161     ret = OMX_ErrorInputDataDecodeYet;
1162
1163 #ifdef USE_IMMEDIATE_DISPLAY
1164     /* Set Immediately display for I Frame*/
1165     pDecOps->Set_ImmediateDisplay(hMFCHandle);
1166 #endif
1167 EXIT:
1168     Mpeg4CodecStop(pOMXComponent, INPUT_PORT_INDEX);
1169     FunctionOut();
1170
1171     return ret;
1172 }
1173
1174 OMX_ERRORTYPE Mpeg4CodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
1175 {
1176     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
1177     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1178     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1179     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1180     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1181     EXYNOS_OMX_BASEPORT           *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1182     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1183
1184     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1185     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
1186     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1187
1188     int i, nOutbufs;
1189
1190     FunctionIn();
1191
1192     /* get dpb count */
1193     nOutbufs = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum;
1194
1195     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1196         /* should be done before prepare output buffer */
1197         if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
1198             ret = OMX_ErrorInsufficientResources;
1199             goto EXIT;
1200         }
1201     }
1202
1203     if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE
1204         ||pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE)
1205         pOutbufOps->Set_Shareable(hMFCHandle);
1206
1207     if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
1208         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
1209         ret = OMX_ErrorInsufficientResources;
1210         goto EXIT;
1211     }
1212
1213     ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
1214     OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1215     OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1216     int plane;
1217
1218     nAllocLen[0] = calc_yplane(pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth,
1219                         pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight);
1220     nAllocLen[1] = calc_uvplane(pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth,
1221                         pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight >> 1);
1222
1223     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1224         pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
1225         Mpeg4CodecDstAllocCodecBuffers(pOMXComponent, nOutbufs);
1226         Mpeg4CodecDstRegistCodecBuffers(pOMXComponent, nOutbufs);
1227     } else if (pExynosOutputPort->bufferProcessType & BUFFER_COPY &&
1228         pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_FALSE) {
1229
1230         /* Register output buffer */
1231         for (i = 0; i < nOutbufs; i++) {
1232             int plane;
1233             OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
1234             ExynosVideoBuffer *pBuffer = NULL;
1235             pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1236             Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1237
1238             if (pOutbufOps->Get_Buffer) {
1239                  if (pOutbufOps->Get_Buffer(pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
1240                      Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get Output buffer info");
1241                      ret = OMX_ErrorInsufficientResources;
1242                      goto EXIT;
1243                  }
1244             }
1245
1246             for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1247                 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
1248                 pVideoDec->pMFCDecOutputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
1249                 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
1250             }
1251
1252             pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
1253                             (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1254         }
1255     } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1256 #ifdef USE_PB
1257         if (pExynosOutputPort->bIsPBEnabled == OMX_TRUE) {
1258         for (i = 0; i < pExynosOutputPort->assignedBufferNum; i++) {
1259                 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1260                     planes[plane].fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[plane];
1261                     planes[plane].addr = pExynosOutputPort->extendBufferHeader[i].pYUVBuf[plane];
1262                     planes[plane].tbm_bo = pExynosOutputPort->extendBufferHeader[i].tbm_bo[plane];
1263                     planes[plane].allocSize = nAllocLen[plane];
1264                 }
1265
1266                 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1267                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1268                 ret = OMX_ErrorInsufficientResources;
1269                 goto EXIT;
1270             }
1271                 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
1272                                (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1273             }
1274         } else {
1275             ret = OMX_ErrorNotImplemented;
1276             goto EXIT;
1277         }
1278 #else
1279         ret = OMX_ErrorNotImplemented;
1280         goto EXIT;
1281 #endif
1282     }
1283
1284     if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1285         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1286         ret = OMX_ErrorInsufficientResources;
1287         goto EXIT;
1288     }
1289
1290     if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1291         Mpeg4CodecStop (pOMXComponent, OUTPUT_PORT_INDEX);
1292     }
1293     pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_TRUE;
1294
1295     ret = OMX_ErrorNone;
1296
1297 EXIT:
1298     FunctionOut();
1299
1300     return ret;
1301 }
1302
1303 OMX_ERRORTYPE Mpeg4CodecCheckResolutionChange(OMX_COMPONENTTYPE *pOMXComponent)
1304 {
1305     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
1306     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1307     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1308     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1309     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1310     EXYNOS_OMX_BASEPORT           *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1311     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1312
1313     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1314     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
1315     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1316     ExynosVideoGeometry      bufferConf;
1317     int i;
1318
1319     FunctionIn();
1320
1321     /* get geometry for output */
1322     Exynos_OSAL_Memset(&pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
1323     if (pOutbufOps->Get_Geometry(hMFCHandle, &pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf) != VIDEO_ERROR_NONE) {
1324         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
1325         ret = OMX_ErrorInsufficientResources;
1326         goto EXIT;
1327     }
1328
1329     /* get dpb count */
1330     pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
1331     if (pVideoDec->bThumbnailMode == OMX_FALSE)
1332         pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum += EXTRA_DPB_NUM;
1333     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Mpeg4CodecCheckResolutionChange Mpeg4CodecSetup nOutbufs: %d", pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum);
1334
1335     pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_TRUE;
1336
1337     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1338         if ((pVideoDec->bDRCProcessing) ||
1339             (pExynosInputPort->portDefinition.format.video.nFrameWidth != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth) ||
1340             (pExynosInputPort->portDefinition.format.video.nFrameHeight != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight)) {
1341             pExynosInputPort->portDefinition.format.video.nFrameWidth = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth;
1342             pExynosInputPort->portDefinition.format.video.nFrameHeight = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight;
1343             pExynosInputPort->portDefinition.format.video.nStride = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1344             pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1345
1346             if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1347                 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1348             }
1349             Exynos_UpdateFrameSize(pOMXComponent);
1350             pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1351
1352             /** Send Port Settings changed call back **/
1353         (*(pExynosComponent->pCallbacks->EventHandler))
1354             (pOMXComponent,
1355              pExynosComponent->callbackData,
1356              OMX_EventPortSettingsChanged, /* The command was completed */
1357              OMX_DirOutput, /* This is the port index */
1358                  0,
1359              NULL);
1360     }
1361     } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1362         if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth) ||
1363             (pExynosInputPort->portDefinition.format.video.nFrameHeight != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight) ||
1364             (pExynosOutputPort->portDefinition.nBufferCountActual != pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum)) {
1365             pExynosInputPort->portDefinition.format.video.nFrameWidth = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth;
1366             pExynosInputPort->portDefinition.format.video.nFrameHeight = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight;
1367             pExynosInputPort->portDefinition.format.video.nStride = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1368             pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1369
1370             if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1371                 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1372             }
1373 #ifdef SLP_PLATFORM
1374             pExynosOutputPort->portDefinition.nBufferCountActual = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum;
1375             pExynosOutputPort->portDefinition.nBufferCountMin = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum;
1376 #else
1377             pExynosOutputPort->portDefinition.nBufferCountActual = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum - 4;
1378             pExynosOutputPort->portDefinition.nBufferCountMin = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum - 4;
1379 #endif
1380             Exynos_UpdateFrameSize(pOMXComponent);
1381             pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1382
1383             /** Send Port Settings changed call back **/
1384             (*(pExynosComponent->pCallbacks->EventHandler))
1385                 (pOMXComponent,
1386                  pExynosComponent->callbackData,
1387                  OMX_EventPortSettingsChanged, /* The command was completed */
1388                  OMX_DirOutput, /* This is the port index */
1389                  0,
1390                  NULL);
1391         }
1392     }
1393
1394     ret = OMX_ErrorNone;
1395
1396 EXIT:
1397     FunctionOut();
1398
1399     return ret;
1400 }
1401
1402
1403 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetParameter(
1404     OMX_IN OMX_HANDLETYPE hComponent,
1405     OMX_IN OMX_INDEXTYPE  nParamIndex,
1406     OMX_INOUT OMX_PTR     pComponentParameterStructure)
1407 {
1408     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1409     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1410     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1411
1412     FunctionIn();
1413
1414     if (hComponent == NULL || pComponentParameterStructure == NULL) {
1415         ret = OMX_ErrorBadParameter;
1416         goto EXIT;
1417     }
1418     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1419     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1420     if (ret != OMX_ErrorNone) {
1421         goto EXIT;
1422     }
1423     if (pOMXComponent->pComponentPrivate == NULL) {
1424         ret = OMX_ErrorBadParameter;
1425         goto EXIT;
1426     }
1427
1428     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1429     if (pExynosComponent->currentState == OMX_StateInvalid ) {
1430         ret = OMX_ErrorInvalidState;
1431         goto EXIT;
1432     }
1433
1434     switch (nParamIndex) {
1435     case OMX_IndexParamVideoMpeg4:
1436     {
1437         OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1438         OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = NULL;
1439         EXYNOS_MPEG4DEC_HANDLE       *pMpeg4Dec      = NULL;
1440
1441         ret = Exynos_OMX_Check_SizeVersion(pDstMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1442         if (ret != OMX_ErrorNone) {
1443             goto EXIT;
1444         }
1445
1446         if (pDstMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
1447             ret = OMX_ErrorBadPortIndex;
1448             goto EXIT;
1449         }
1450
1451         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1452         pSrcMpeg4Param = &pMpeg4Dec->mpeg4Component[pDstMpeg4Param->nPortIndex];
1453
1454         Exynos_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1455     }
1456         break;
1457     case OMX_IndexParamVideoH263:
1458     {
1459         OMX_VIDEO_PARAM_H263TYPE  *pDstH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1460         OMX_VIDEO_PARAM_H263TYPE  *pSrcH263Param = NULL;
1461         EXYNOS_MPEG4DEC_HANDLE       *pMpeg4Dec     = NULL;
1462
1463         ret = Exynos_OMX_Check_SizeVersion(pDstH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1464         if (ret != OMX_ErrorNone) {
1465             goto EXIT;
1466         }
1467
1468         if (pDstH263Param->nPortIndex >= ALL_PORT_NUM) {
1469             ret = OMX_ErrorBadPortIndex;
1470             goto EXIT;
1471         }
1472
1473         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1474         pSrcH263Param = &pMpeg4Dec->h263Component[pDstH263Param->nPortIndex];
1475
1476         Exynos_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1477     }
1478         break;
1479     case OMX_IndexParamStandardComponentRole:
1480     {
1481         OMX_S32                      codecType;
1482         OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1483
1484         ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1485         if (ret != OMX_ErrorNone) {
1486             goto EXIT;
1487         }
1488
1489         codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1490         if (codecType == CODEC_TYPE_MPEG4)
1491             Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE);
1492         else
1493             Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE);
1494     }
1495         break;
1496     case OMX_IndexParamVideoProfileLevelQuerySupported:
1497     {
1498         OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel   = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1499         EXYNOS_OMX_VIDEO_PROFILELEVEL    *pProfileLevel      = NULL;
1500         OMX_U32                           maxProfileLevelNum = 0;
1501         OMX_S32                           codecType;
1502
1503         ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1504         if (ret != OMX_ErrorNone) {
1505             goto EXIT;
1506         }
1507
1508         if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1509             ret = OMX_ErrorBadPortIndex;
1510             goto EXIT;
1511         }
1512
1513         codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1514         if (codecType == CODEC_TYPE_MPEG4) {
1515             pProfileLevel = supportedMPEG4ProfileLevels;
1516             maxProfileLevelNum = sizeof(supportedMPEG4ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1517         } else {
1518             pProfileLevel = supportedH263ProfileLevels;
1519             maxProfileLevelNum = sizeof(supportedH263ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1520         }
1521
1522         if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
1523             ret = OMX_ErrorNoMore;
1524             goto EXIT;
1525         }
1526
1527         pProfileLevel += pDstProfileLevel->nProfileIndex;
1528         pDstProfileLevel->eProfile = pProfileLevel->profile;
1529         pDstProfileLevel->eLevel = pProfileLevel->level;
1530     }
1531         break;
1532     case OMX_IndexParamVideoProfileLevelCurrent:
1533     {
1534         OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1535         OMX_VIDEO_PARAM_MPEG4TYPE        *pSrcMpeg4Param   = NULL;
1536         OMX_VIDEO_PARAM_H263TYPE         *pSrcH263Param    = NULL;
1537         EXYNOS_MPEG4DEC_HANDLE              *pMpeg4Dec        = NULL;
1538         OMX_S32                           codecType;
1539
1540         ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1541         if (ret != OMX_ErrorNone) {
1542             goto EXIT;
1543         }
1544
1545         if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1546             ret = OMX_ErrorBadPortIndex;
1547             goto EXIT;
1548         }
1549
1550         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1551         codecType = pMpeg4Dec->hMFCMpeg4Handle.codecType;
1552         if (codecType == CODEC_TYPE_MPEG4) {
1553             pSrcMpeg4Param = &pMpeg4Dec->mpeg4Component[pDstProfileLevel->nPortIndex];
1554             pDstProfileLevel->eProfile = pSrcMpeg4Param->eProfile;
1555             pDstProfileLevel->eLevel = pSrcMpeg4Param->eLevel;
1556         } else {
1557             pSrcH263Param = &pMpeg4Dec->h263Component[pDstProfileLevel->nPortIndex];
1558             pDstProfileLevel->eProfile = pSrcH263Param->eProfile;
1559             pDstProfileLevel->eLevel = pSrcH263Param->eLevel;
1560         }
1561     }
1562         break;
1563     case OMX_IndexParamVideoErrorCorrection:
1564     {
1565         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1566         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1567         EXYNOS_MPEG4DEC_HANDLE                 *pMpeg4Dec               = NULL;
1568
1569         ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1570         if (ret != OMX_ErrorNone) {
1571             goto EXIT;
1572         }
1573
1574         if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1575             ret = OMX_ErrorBadPortIndex;
1576             goto EXIT;
1577         }
1578
1579         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1580         pSrcErrorCorrectionType = &pMpeg4Dec->errorCorrectionType[INPUT_PORT_INDEX];
1581
1582         pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1583         pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1584         pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1585         pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1586         pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1587     }
1588         break;
1589     default:
1590         ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1591         break;
1592     }
1593 EXIT:
1594     FunctionOut();
1595
1596     return ret;
1597 }
1598
1599 OMX_ERRORTYPE Exynos_Mpeg4Dec_SetParameter(
1600     OMX_IN OMX_HANDLETYPE hComponent,
1601     OMX_IN OMX_INDEXTYPE  nIndex,
1602     OMX_IN OMX_PTR        pComponentParameterStructure)
1603 {
1604     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1605     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1606     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1607
1608     FunctionIn();
1609
1610     if (hComponent == NULL || pComponentParameterStructure == NULL) {
1611         ret = OMX_ErrorBadParameter;
1612         goto EXIT;
1613     }
1614     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1615     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1616     if (ret != OMX_ErrorNone) {
1617         goto EXIT;
1618     }
1619     if (pOMXComponent->pComponentPrivate == NULL) {
1620         ret = OMX_ErrorBadParameter;
1621         goto EXIT;
1622     }
1623
1624     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1625     if (pExynosComponent->currentState == OMX_StateInvalid ) {
1626         ret = OMX_ErrorInvalidState;
1627         goto EXIT;
1628     }
1629
1630     switch (nIndex) {
1631     case OMX_IndexParamVideoMpeg4:
1632     {
1633         OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = NULL;
1634         OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1635         EXYNOS_MPEG4DEC_HANDLE    *pMpeg4Dec      = NULL;
1636
1637         ret = Exynos_OMX_Check_SizeVersion(pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1638         if (ret != OMX_ErrorNone) {
1639             goto EXIT;
1640         }
1641
1642         if (pSrcMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
1643             ret = OMX_ErrorBadPortIndex;
1644             goto EXIT;
1645         }
1646
1647         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1648         pDstMpeg4Param = &pMpeg4Dec->mpeg4Component[pSrcMpeg4Param->nPortIndex];
1649
1650         Exynos_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1651     }
1652         break;
1653     case OMX_IndexParamVideoH263:
1654     {
1655         OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = NULL;
1656         OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1657         EXYNOS_MPEG4DEC_HANDLE   *pMpeg4Dec     = NULL;
1658
1659         ret = Exynos_OMX_Check_SizeVersion(pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1660         if (ret != OMX_ErrorNone) {
1661             goto EXIT;
1662         }
1663
1664         if (pSrcH263Param->nPortIndex >= ALL_PORT_NUM) {
1665             ret = OMX_ErrorBadPortIndex;
1666             goto EXIT;
1667         }
1668
1669         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1670         pDstH263Param = &pMpeg4Dec->h263Component[pSrcH263Param->nPortIndex];
1671
1672         Exynos_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1673     }
1674         break;
1675     case OMX_IndexParamStandardComponentRole:
1676     {
1677         OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1678
1679         ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1680         if (ret != OMX_ErrorNone) {
1681             goto EXIT;
1682         }
1683
1684         if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1685             ret = OMX_ErrorIncorrectStateOperation;
1686             goto EXIT;
1687         }
1688
1689         if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE)) {
1690             pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
1691         } else if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE)) {
1692             pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
1693         } else {
1694             ret = OMX_ErrorBadParameter;
1695             goto EXIT;
1696         }
1697     }
1698         break;
1699     case OMX_IndexParamPortDefinition:
1700     {
1701         OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1702         OMX_U32                       portIndex       = pPortDefinition->nPortIndex;
1703         EXYNOS_OMX_BASEPORT          *pExynosPort;
1704         OMX_U32                       width, height, size;
1705         OMX_U32                       realWidth, realHeight;
1706         OMX_PARAM_PORTDEFINITIONTYPE  portDefinition_backup;
1707
1708         if (portIndex >= pExynosComponent->portParam.nPorts) {
1709             ret = OMX_ErrorBadPortIndex;
1710             goto EXIT;
1711         }
1712         ret = Exynos_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1713         if (ret != OMX_ErrorNone) {
1714             goto EXIT;
1715         }
1716
1717         pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1718
1719         if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1720             if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1721                 ret = OMX_ErrorIncorrectStateOperation;
1722                 goto EXIT;
1723             }
1724         }
1725         if (pPortDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1726             ret = OMX_ErrorBadParameter;
1727             goto EXIT;
1728         }
1729
1730         Exynos_OSAL_Memcpy(&portDefinition_backup, &pExynosPort->portDefinition, pPortDefinition->nSize);
1731         Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
1732         RESTORE_READONLYPARAMETERS_OMX_PARAM_PORTDEFINITIONTYPE(&pExynosPort->portDefinition,&portDefinition_backup);
1733
1734         realWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1735         realHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1736         width = ((realWidth + 15) & (~15));
1737         height = ((realHeight + 15) & (~15));
1738         size = (width * height * 3) / 2;
1739         pExynosPort->portDefinition.format.video.nStride = width;
1740         pExynosPort->portDefinition.format.video.nSliceHeight = height;
1741         pExynosPort->portDefinition.nBufferSize = (size > pExynosPort->portDefinition.nBufferSize) ? size : pExynosPort->portDefinition.nBufferSize;
1742
1743         if (portIndex == INPUT_PORT_INDEX) {
1744             EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1745             pExynosOutputPort->portDefinition.format.video.nFrameWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1746             pExynosOutputPort->portDefinition.format.video.nFrameHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1747             pExynosOutputPort->portDefinition.format.video.nStride = width;
1748             pExynosOutputPort->portDefinition.format.video.nSliceHeight = height;
1749
1750             switch (pExynosOutputPort->portDefinition.format.video.eColorFormat) {
1751             case OMX_COLOR_FormatYUV420Planar:
1752             case OMX_COLOR_FormatYUV420SemiPlanar:
1753                 pExynosOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
1754                 break;
1755 #ifdef SLP_PLATFORM /* NV12T fd */
1756             case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
1757                 pExynosOutputPort->portDefinition.nBufferSize = sizeof(MMVideoBuffer);
1758                 break;
1759 #endif
1760             case OMX_SEC_COLOR_FormatNV12Tiled:
1761                 pExynosOutputPort->portDefinition.nBufferSize =
1762                     calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1763                     calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1764                 break;
1765             default:
1766                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Color format is not support!! use default YUV size!!");
1767                 ret = OMX_ErrorUnsupportedSetting;
1768                 break;
1769             }
1770
1771             if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1772                 pExynosOutputPort->portDefinition.nBufferSize =
1773                     calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1774                     calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1775             }
1776         }
1777     }
1778         break;
1779     case OMX_IndexParamVideoProfileLevelCurrent:
1780     {
1781         OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1782         OMX_VIDEO_PARAM_MPEG4TYPE        *pDstMpeg4Param   = NULL;
1783         OMX_VIDEO_PARAM_H263TYPE         *pDstH263Param    = NULL;
1784         EXYNOS_MPEG4DEC_HANDLE           *pMpeg4Dec        = NULL;
1785         OMX_S32                           codecType;
1786
1787         ret = Exynos_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1788         if (ret != OMX_ErrorNone)
1789             goto EXIT;
1790
1791         if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1792             ret = OMX_ErrorBadPortIndex;
1793             goto EXIT;
1794         }
1795
1796         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1797         codecType = pMpeg4Dec->hMFCMpeg4Handle.codecType;
1798         if (codecType == CODEC_TYPE_MPEG4) {
1799             /*
1800              * To do: Check validity of profile & level parameters
1801              */
1802
1803             pDstMpeg4Param = &pMpeg4Dec->mpeg4Component[pSrcProfileLevel->nPortIndex];
1804             pDstMpeg4Param->eProfile = pSrcProfileLevel->eProfile;
1805             pDstMpeg4Param->eLevel = pSrcProfileLevel->eLevel;
1806         } else {
1807             /*
1808              * To do: Check validity of profile & level parameters
1809              */
1810
1811             pDstH263Param = &pMpeg4Dec->h263Component[pSrcProfileLevel->nPortIndex];
1812             pDstH263Param->eProfile = pSrcProfileLevel->eProfile;
1813             pDstH263Param->eLevel = pSrcProfileLevel->eLevel;
1814         }
1815     }
1816         break;
1817     case OMX_IndexParamVideoErrorCorrection:
1818     {
1819         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1820         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1821         EXYNOS_MPEG4DEC_HANDLE              *pMpeg4Dec               = NULL;
1822
1823         ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1824         if (ret != OMX_ErrorNone) {
1825             goto EXIT;
1826         }
1827
1828         if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1829             ret = OMX_ErrorBadPortIndex;
1830             goto EXIT;
1831         }
1832
1833         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1834         pDstErrorCorrectionType = &pMpeg4Dec->errorCorrectionType[INPUT_PORT_INDEX];
1835
1836         pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1837         pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1838         pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1839         pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1840         pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1841     }
1842         break;
1843     default:
1844         ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1845         break;
1846     }
1847 EXIT:
1848     FunctionOut();
1849
1850     return ret;
1851 }
1852
1853 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetConfig(
1854     OMX_IN OMX_HANDLETYPE hComponent,
1855     OMX_IN OMX_INDEXTYPE  nIndex,
1856     OMX_IN OMX_PTR        pComponentConfigStructure)
1857 {
1858     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1859     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1860     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1861
1862     FunctionIn();
1863
1864     if (hComponent == NULL || pComponentConfigStructure == NULL) {
1865         ret = OMX_ErrorBadParameter;
1866         goto EXIT;
1867     }
1868     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1869     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1870     if (ret != OMX_ErrorNone) {
1871         goto EXIT;
1872     }
1873     if (pOMXComponent->pComponentPrivate == NULL) {
1874         ret = OMX_ErrorBadParameter;
1875         goto EXIT;
1876     }
1877     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1878     if (pExynosComponent->currentState == OMX_StateInvalid) {
1879         ret = OMX_ErrorInvalidState;
1880         goto EXIT;
1881     }
1882
1883     switch (nIndex) {
1884     default:
1885         ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1886         break;
1887     }
1888
1889 EXIT:
1890     FunctionOut();
1891
1892     return ret;
1893 }
1894
1895 OMX_ERRORTYPE Exynos_Mpeg4Dec_SetConfig(
1896     OMX_IN OMX_HANDLETYPE hComponent,
1897     OMX_IN OMX_INDEXTYPE  nIndex,
1898     OMX_IN OMX_PTR        pComponentConfigStructure)
1899 {
1900     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1901     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1902     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1903
1904     FunctionIn();
1905
1906     if (hComponent == NULL || pComponentConfigStructure == NULL) {
1907         ret = OMX_ErrorBadParameter;
1908         goto EXIT;
1909     }
1910     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1911     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1912     if (ret != OMX_ErrorNone) {
1913         goto EXIT;
1914     }
1915     if (pOMXComponent->pComponentPrivate == NULL) {
1916         ret = OMX_ErrorBadParameter;
1917         goto EXIT;
1918     }
1919     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1920     if (pExynosComponent->currentState == OMX_StateInvalid) {
1921         ret = OMX_ErrorInvalidState;
1922         goto EXIT;
1923     }
1924
1925     switch (nIndex) {
1926     default:
1927         ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1928         break;
1929     }
1930
1931 EXIT:
1932     FunctionOut();
1933
1934     return ret;
1935 }
1936
1937 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetExtensionIndex(
1938     OMX_IN  OMX_HANDLETYPE  hComponent,
1939     OMX_IN  OMX_STRING      cParameterName,
1940     OMX_OUT OMX_INDEXTYPE  *pIndexType)
1941 {
1942     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1943     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1944     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1945
1946     FunctionIn();
1947
1948     if (hComponent == NULL) {
1949         ret = OMX_ErrorBadParameter;
1950         goto EXIT;
1951     }
1952     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1953     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1954     if (ret != OMX_ErrorNone) {
1955         goto EXIT;
1956     }
1957     if (pOMXComponent->pComponentPrivate == NULL) {
1958         ret = OMX_ErrorBadParameter;
1959         goto EXIT;
1960     }
1961     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1962     if ((cParameterName == NULL) || (pIndexType == NULL)) {
1963         ret = OMX_ErrorBadParameter;
1964         goto EXIT;
1965     }
1966     if (pExynosComponent->currentState == OMX_StateInvalid) {
1967         ret = OMX_ErrorInvalidState;
1968         goto EXIT;
1969     }
1970
1971     if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1972         EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1973         *pIndexType = OMX_IndexVendorThumbnailMode;
1974         ret = OMX_ErrorNone;
1975     } else {
1976         ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1977     }
1978
1979 EXIT:
1980     FunctionOut();
1981
1982     return ret;
1983 }
1984
1985 OMX_ERRORTYPE Exynos_Mpeg4Dec_ComponentRoleEnum(
1986     OMX_IN  OMX_HANDLETYPE hComponent,
1987     OMX_OUT OMX_U8        *cRole,
1988     OMX_IN  OMX_U32        nIndex)
1989 {
1990     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1991     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1992     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1993     OMX_S32                   codecType;
1994
1995     FunctionIn();
1996
1997     if ((hComponent == NULL) || (cRole == NULL)) {
1998         ret = OMX_ErrorBadParameter;
1999         goto EXIT;
2000     }
2001     if (nIndex != (MAX_COMPONENT_ROLE_NUM - 1)) {
2002         ret = OMX_ErrorNoMore;
2003         goto EXIT;
2004     }
2005     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2006     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
2007     if (ret != OMX_ErrorNone) {
2008         goto EXIT;
2009     }
2010     if (pOMXComponent->pComponentPrivate == NULL) {
2011         ret = OMX_ErrorBadParameter;
2012         goto EXIT;
2013     }
2014     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2015     if (pExynosComponent->currentState == OMX_StateInvalid ) {
2016         ret = OMX_ErrorInvalidState;
2017         goto EXIT;
2018     }
2019
2020     codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
2021     if (codecType == CODEC_TYPE_MPEG4)
2022         Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE);
2023     else
2024         Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE);
2025
2026 EXIT:
2027     FunctionOut();
2028
2029     return ret;
2030 }
2031
2032 /* MFC Init */
2033 OMX_ERRORTYPE Exynos_Mpeg4Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
2034 {
2035     OMX_ERRORTYPE                  ret               = OMX_ErrorNone;
2036     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent  = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2037     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec         = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2038     EXYNOS_OMX_BASEPORT           *pExynosInputPort  = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2039     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2040     EXYNOS_MPEG4DEC_HANDLE        *pMpeg4Dec         = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
2041     OMX_PTR                        hMFCHandle        = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2042
2043     ExynosVideoDecOps       *pDecOps    = NULL;
2044     ExynosVideoDecBufferOps *pInbufOps  = NULL;
2045     ExynosVideoDecBufferOps *pOutbufOps = NULL;
2046
2047     CSC_METHOD csc_method = CSC_METHOD_SW;
2048     int i, plane;
2049
2050     FunctionIn();
2051
2052     pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_FALSE;
2053     pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_FALSE;
2054     pExynosComponent->bUseFlagEOF = OMX_TRUE;
2055     pExynosComponent->bSaveFlagEOS = OMX_FALSE;
2056
2057     /* Mpeg4 Codec Open */
2058     ret = Mpeg4CodecOpen(pMpeg4Dec);
2059     if (ret != OMX_ErrorNone) {
2060         goto EXIT;
2061     }
2062
2063     pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2064     pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
2065     pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2066
2067     if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2068         Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
2069         Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
2070
2071         if (pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
2072             for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2073                 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
2074                 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
2075                 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
2076
2077             for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2078             /* Use ION Allocator */
2079                 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, DEFAULT_MFC_INPUT_BUFFER_SIZE, NORMAL_MEMORY);
2080                 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2081                 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = DEFAULT_MFC_INPUT_BUFFER_SIZE;
2082             pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2083             if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] == NULL) {
2084                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
2085                 ret = OMX_ErrorInsufficientResources;
2086                 goto EXIT;
2087             }
2088                 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2089             }
2090
2091                 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
2092             }
2093         } else {
2094 #ifdef SLP_PLATFORM
2095                 if (pOMXComponent == NULL) {
2096                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d: invalid parm: pOMXComponent = %p", __FUNCTION__, __LINE__, pOMXComponent);
2097                 }
2098 #endif
2099                 ret = Mpeg4CodecSrcInit(pOMXComponent);
2100                 if (ret != OMX_ErrorNone)
2101                     goto EXIT;
2102         }
2103     } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2104         /*************/
2105         /*    TBD    */
2106         /*************/
2107         /* Does not require any actions. */
2108     }
2109
2110     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2111         Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
2112         Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
2113     } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2114         /*************/
2115         /*    TBD    */
2116         /*************/
2117         /* Does not require any actions. */
2118     }
2119
2120     pMpeg4Dec->bSourceStart = OMX_FALSE;
2121     Exynos_OSAL_SignalCreate(&pMpeg4Dec->hSourceStartEvent);
2122     pMpeg4Dec->bDestinationStart = OMX_FALSE;
2123     Exynos_OSAL_SignalCreate(&pMpeg4Dec->hDestinationStartEvent);
2124
2125     Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
2126     Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
2127     pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp = 0;
2128     pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp = 0;
2129
2130     pExynosComponent->getAllDelayBuffer = OMX_FALSE;
2131
2132 #if 0//defined(USE_CSC_GSCALER)
2133     csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
2134 #endif
2135     pVideoDec->csc_handle = csc_init(csc_method);
2136     if (pVideoDec->csc_handle == NULL) {
2137         ret = OMX_ErrorInsufficientResources;
2138         goto EXIT;
2139     }
2140     pVideoDec->csc_set_format = OMX_FALSE;
2141
2142 EXIT:
2143     FunctionOut();
2144
2145     return ret;
2146 }
2147
2148 /* MFC Terminate */
2149 OMX_ERRORTYPE Exynos_Mpeg4Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
2150 {
2151     OMX_ERRORTYPE          ret = OMX_ErrorNone;
2152     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2153     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2154     EXYNOS_OMX_BASEPORT      *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2155     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2156     EXYNOS_MPEG4DEC_HANDLE    *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2157     OMX_PTR                hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2158
2159     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2160     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
2161     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2162
2163     int i, plane;
2164
2165     FunctionIn();
2166
2167     if (pVideoDec->csc_handle != NULL) {
2168         csc_deinit(pVideoDec->csc_handle);
2169         pVideoDec->csc_handle = NULL;
2170     }
2171
2172     Exynos_OSAL_SignalTerminate(pMpeg4Dec->hDestinationStartEvent);
2173     pMpeg4Dec->hDestinationStartEvent = NULL;
2174     pMpeg4Dec->bDestinationStart = OMX_FALSE;
2175     Exynos_OSAL_SignalTerminate(pMpeg4Dec->hSourceStartEvent);
2176     pMpeg4Dec->hSourceStartEvent = NULL;
2177     pMpeg4Dec->bSourceStart = OMX_FALSE;
2178
2179     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2180         Mpeg4CodecDstFreeCodecBuffers(pOMXComponent);
2181
2182         Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
2183         Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
2184     } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2185         /*************/
2186         /*    TBD    */
2187         /*************/
2188         /* Does not require any actions. */
2189     }
2190
2191     if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2192         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2193             if (pVideoDec->pMFCDecInputBuffer[i] != NULL) {
2194 #ifndef SLP_PLATFORM /* do not use ion */
2195                 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2196                     if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] != NULL)
2197                         Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2198                 }
2199 #endif
2200                 Exynos_OSAL_Free(pVideoDec->pMFCDecInputBuffer[i]);
2201                 pVideoDec->pMFCDecInputBuffer[i] = NULL;
2202             }
2203         }
2204
2205         Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
2206         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
2207     } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2208         /*************/
2209         /*    TBD    */
2210         /*************/
2211         /* Does not require any actions. */
2212     }
2213     Mpeg4CodecClose(pMpeg4Dec);
2214
2215 EXIT:
2216     FunctionOut();
2217
2218     return ret;
2219 }
2220
2221 OMX_ERRORTYPE Exynos_Mpeg4Dec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2222 {
2223     OMX_ERRORTYPE               ret = OMX_ErrorNone;
2224     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2225     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2226     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2227     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2228     EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2229     EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2230     OMX_U32  oneFrameSize = pSrcInputData->dataLen;
2231        OMX_BOOL bInStartCode = OMX_FALSE;
2232     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2233     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
2234     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2235     ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2236     int i;
2237
2238     FunctionIn();
2239
2240     if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc == OMX_FALSE) {
2241         ret = Mpeg4CodecSrcSetup(pOMXComponent, pSrcInputData);
2242         goto EXIT;
2243     }
2244     if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_FALSE) {
2245         ret = Mpeg4CodecDstSetup(pOMXComponent);
2246     }
2247
2248   if (((bInStartCode = Check_Stream_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize, pMpeg4Dec->hMFCMpeg4Handle.codecType)) == OMX_TRUE) ||
2249         ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)){
2250         pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->timeStamp;
2251         pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->nFlags;
2252         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "input timestamp %lld us (%.2f secs), Tag: %d, nFlags: 0x%x", pSrcInputData->timeStamp, pSrcInputData->timeStamp / 1E6, pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp, pSrcInputData->nFlags);
2253         pDecOps->Set_FrameTag(hMFCHandle, pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp);
2254         pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp++;
2255         pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp %= MAX_TIMESTAMP;
2256
2257 #ifdef USE_IMMEDIATE_DISPLAY
2258     /* Set Immediately display for I Frame*/
2259         if (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
2260             if ( pExynosComponent->checkTimeStamp.bImmediateDisplay == OMX_FALSE) {
2261                 /* Enable Immediately display After seek*/
2262                 pDecOps->Set_ImmediateDisplay(hMFCHandle);
2263                 pExynosComponent->checkTimeStamp.bImmediateDisplay = OMX_TRUE;
2264             }
2265         }
2266 #endif
2267         /* queue work for input buffer */
2268         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
2269         codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
2270                                     (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
2271         if (codecReturn != VIDEO_ERROR_NONE) {
2272             ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2273             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2274             goto EXIT;
2275         }
2276         Mpeg4CodecStart(pOMXComponent, INPUT_PORT_INDEX);
2277         if (pMpeg4Dec->bSourceStart == OMX_FALSE) {
2278             pMpeg4Dec->bSourceStart = OMX_TRUE;
2279             Exynos_OSAL_SignalSet(pMpeg4Dec->hSourceStartEvent);
2280             Exynos_OSAL_SleepMillisec(0);
2281         }
2282         if (pMpeg4Dec->bDestinationStart == OMX_FALSE) {
2283             pMpeg4Dec->bDestinationStart = OMX_TRUE;
2284             Exynos_OSAL_SignalSet(pMpeg4Dec->hDestinationStartEvent);
2285             Exynos_OSAL_SleepMillisec(0);
2286         }
2287          } else if (bInStartCode == OMX_FALSE) {
2288         ret = OMX_ErrorCorruptedFrame;
2289         goto EXIT;
2290     }
2291
2292     ret = OMX_ErrorNone;
2293
2294 EXIT:
2295     FunctionOut();
2296
2297     return ret;
2298 }
2299
2300 OMX_ERRORTYPE Exynos_Mpeg4Dec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2301 {
2302     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
2303     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2304     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2305     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2306     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2307     EXYNOS_OMX_BASEPORT     *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2308     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2309     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
2310     ExynosVideoBuffer       *pVideoBuffer;
2311
2312     FunctionIn();
2313
2314     pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
2315
2316     pSrcOutputData->dataLen       = 0;
2317     pSrcOutputData->usedDataLen   = 0;
2318     pSrcOutputData->remainDataLen = 0;
2319     pSrcOutputData->nFlags    = 0;
2320     pSrcOutputData->timeStamp = 0;
2321
2322     if (pVideoBuffer == NULL) {
2323         pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
2324         pSrcOutputData->allocSize  = 0;
2325         pSrcOutputData->pPrivate = NULL;
2326         pSrcOutputData->bufferHeader = NULL;
2327     } else {
2328         pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2329         pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2330         pSrcOutputData->allocSize  = pVideoBuffer->planes[0].allocSize;
2331
2332         if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2333             int i = 0;
2334             while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
2335                 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2336                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
2337                     ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2338                     goto EXIT;
2339                 }
2340                 i++;
2341             }
2342             pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2343             pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
2344         }
2345
2346         /* For Share Buffer */
2347         pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2348     }
2349
2350     ret = OMX_ErrorNone;
2351
2352 EXIT:
2353     FunctionOut();
2354
2355     return ret;
2356 }
2357
2358 OMX_ERRORTYPE Exynos_Mpeg4Dec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2359 {
2360     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
2361     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2362     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2363     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2364     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2365     EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2366     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2367     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2368     OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0,};
2369     ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2370
2371     FunctionIn();
2372
2373     if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
2374         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2375         ret = OMX_ErrorBadParameter;
2376         goto EXIT;
2377     }
2378
2379     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
2380                                         pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
2381                                         pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
2382
2383     if ((pVideoDec->bDRCProcessing == OMX_TRUE) &&
2384         (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) &&
2385         (pExynosOutputPort->exceptionFlag == GENERAL_STATE)) {
2386         ret = Mpeg4CodecDstSetup(pOMXComponent);
2387         if (ret != OMX_ErrorNone) {
2388             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "DRC Reconfig CodecDstSetup Failed");
2389             goto EXIT;
2390         }
2391         pVideoDec->bDRCProcessing = OMX_FALSE;
2392     }
2393
2394     codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
2395                  (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
2396
2397     if (codecReturn != VIDEO_ERROR_NONE) {
2398         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2399         ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2400         goto EXIT;
2401     }
2402     Mpeg4CodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2403
2404     ret = OMX_ErrorNone;
2405
2406 EXIT:
2407     FunctionOut();
2408
2409     return ret;
2410 }
2411
2412 OMX_ERRORTYPE Exynos_Mpeg4Dec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2413 {
2414     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
2415     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2416     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2417     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2418     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2419     EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2420     EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2421     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2422     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2423     ExynosVideoBuffer       *pVideoBuffer;
2424     ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2425     ExynosVideoGeometry *bufferGeometry;
2426     DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
2427     OMX_S32 indexTimestamp = 0;
2428     int plane;
2429
2430     FunctionIn();
2431
2432     if (pMpeg4Dec->bDestinationStart == OMX_FALSE) {
2433         ret = OMX_ErrorNone;
2434         goto EXIT;
2435     }
2436
2437     while (1) {
2438         pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle);
2439         if (pVideoBuffer == (ExynosVideoBuffer *)VIDEO_ERROR_DQBUF_EIO) {
2440             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "HW is not available");
2441             ret = OMX_ErrorHardware;
2442             goto EXIT;
2443         }
2444
2445         if (pVideoBuffer == NULL) {
2446             ret = OMX_ErrorNone;
2447             goto EXIT;
2448         }
2449         displayStatus = pVideoBuffer->displayStatus;
2450         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
2451
2452         if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
2453             (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
2454             (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2455             (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2456             (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2457             if (pVideoBuffer != NULL) {
2458                 ret = OMX_ErrorNone;
2459                 break;
2460             } else {
2461                 ret = OMX_ErrorUndefined;
2462                 break;
2463             }
2464         }
2465     }
2466
2467     if (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) {
2468         if (pVideoDec->bDRCProcessing != OMX_TRUE) {
2469             pExynosOutputPort->exceptionFlag = NEED_PORT_FLUSH;
2470             pVideoDec->bDRCProcessing = OMX_TRUE;
2471             Mpeg4CodecCheckResolutionChange(pOMXComponent);
2472             pVideoDec->csc_set_format = OMX_FALSE;
2473         }
2474         ret = OMX_ErrorNone;
2475         goto EXIT;
2476     }
2477
2478     pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp++;
2479     pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
2480
2481     pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
2482     for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
2483         pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2484         pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2485         pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
2486         pDstOutputData->dataLen +=  pVideoBuffer->planes[plane].dataSize;
2487     }
2488     pDstOutputData->usedDataLen = 0;
2489     pDstOutputData->pPrivate = pVideoBuffer;
2490     /* For Share Buffer */
2491     pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2492
2493     pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
2494     bufferGeometry = &pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf;
2495     pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
2496     pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
2497     switch (bufferGeometry->eColorFormat) {
2498     case VIDEO_COLORFORMAT_NV12:
2499 #ifdef SLP_PLATFORM /* NV12T fd */
2500         pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
2501 #else
2502         pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2503 #endif
2504         break;
2505     case VIDEO_COLORFORMAT_NV12_TILED:
2506     default:
2507         pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
2508         break;
2509     }
2510
2511     indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
2512     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
2513     if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2514         if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
2515             (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
2516             pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2517             pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2518             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
2519         } else {
2520             pDstOutputData->timeStamp = 0x00;
2521             pDstOutputData->nFlags = 0x00;
2522         }
2523     } else {
2524         /* For timestamp correction. if mfc support frametype detect */
2525         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
2526 //#ifdef NEED_TIMESTAMP_REORDER
2527         if (pMpeg4Dec->hMFCMpeg4Handle.bPackedPB == OMX_TRUE ||
2528             pVideoDec->bNeedTimestampReorder == OMX_TRUE) { /* SLP_PLATFORM */
2529             if ((pVideoBuffer->frameType == VIDEO_FRAME_I)) {
2530                 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2531                 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2532                 pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp = indexTimestamp;
2533             } else {
2534                 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2535                 pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2536             }
2537         } else {
2538 //#else
2539             pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2540             pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2541         }
2542 //#endif
2543         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
2544     }
2545
2546     if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2547         (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2548         ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2549         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
2550         pDstOutputData->remainDataLen = 0;
2551     } else {
2552         pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
2553     }
2554
2555     ret = OMX_ErrorNone;
2556
2557 EXIT:
2558     FunctionOut();
2559
2560     return ret;
2561 }
2562
2563 OMX_ERRORTYPE Exynos_Mpeg4Dec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2564 {
2565     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2566     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2567     EXYNOS_MPEG4DEC_HANDLE    *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2568     EXYNOS_OMX_BASEPORT      *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2569
2570     FunctionIn();
2571
2572     if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2573         ret = OMX_ErrorNone;
2574         goto EXIT;
2575     }
2576     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2577         ret = OMX_ErrorNone;
2578         goto EXIT;
2579     }
2580
2581     ret = Exynos_Mpeg4Dec_SrcIn(pOMXComponent, pSrcInputData);
2582 if ((ret != OMX_ErrorNone) &&
2583         (ret != OMX_ErrorInputDataDecodeYet) &&
2584         (ret != OMX_ErrorCorruptedFrame)) {
2585         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2586                                                 pExynosComponent->callbackData,
2587                                                 OMX_EventError, ret, 0, NULL);
2588     }
2589
2590 EXIT:
2591     FunctionOut();
2592
2593     return ret;
2594 }
2595
2596 OMX_ERRORTYPE Exynos_Mpeg4Dec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2597 {
2598     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2599     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2600     EXYNOS_MPEG4DEC_HANDLE   *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2601     EXYNOS_OMX_BASEPORT     *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2602
2603     FunctionIn();
2604
2605     if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2606         ret = OMX_ErrorNone;
2607         goto EXIT;
2608     }
2609
2610     if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2611         if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2612             ret = OMX_ErrorNone;
2613             goto EXIT;
2614         }
2615     }
2616     if ((pMpeg4Dec->bSourceStart == OMX_FALSE) &&
2617        (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2618         Exynos_OSAL_SignalWait(pMpeg4Dec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2619         Exynos_OSAL_SignalReset(pMpeg4Dec->hSourceStartEvent);
2620     }
2621
2622     ret = Exynos_Mpeg4Dec_SrcOut(pOMXComponent, pSrcOutputData);
2623     if ((ret != OMX_ErrorNone) &&
2624         (pExynosComponent->currentState == OMX_StateExecuting)) {
2625         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2626                                                 pExynosComponent->callbackData,
2627                                                 OMX_EventError, ret, 0, NULL);
2628     }
2629
2630 EXIT:
2631     FunctionOut();
2632
2633     return ret;
2634 }
2635
2636 OMX_ERRORTYPE Exynos_Mpeg4Dec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2637 {
2638     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2639     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2640     EXYNOS_MPEG4DEC_HANDLE    *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2641     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2642
2643     FunctionIn();
2644
2645     if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2646         ret = OMX_ErrorNone;
2647         goto EXIT;
2648     }
2649     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2650         ret = OMX_ErrorNone;
2651         goto EXIT;
2652     }
2653     if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2654         if ((pMpeg4Dec->bDestinationStart == OMX_FALSE) &&
2655            (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2656             Exynos_OSAL_SignalWait(pMpeg4Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2657             Exynos_OSAL_SignalReset(pMpeg4Dec->hDestinationStartEvent);
2658         }
2659     }
2660     if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_TRUE) {
2661         ret = Exynos_Mpeg4Dec_DstIn(pOMXComponent, pDstInputData);
2662         if (ret != OMX_ErrorNone) {
2663             pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2664                                                 pExynosComponent->callbackData,
2665                                                 OMX_EventError, ret, 0, NULL);
2666         }
2667     }
2668
2669 EXIT:
2670     FunctionOut();
2671
2672     return ret;
2673 }
2674
2675 OMX_ERRORTYPE Exynos_Mpeg4Dec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2676 {
2677     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2678     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2679     EXYNOS_MPEG4DEC_HANDLE   *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2680     EXYNOS_OMX_BASEPORT     *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2681
2682     FunctionIn();
2683
2684     if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2685         ret = OMX_ErrorNone;
2686         goto EXIT;
2687     }
2688     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2689         ret = OMX_ErrorNone;
2690         goto EXIT;
2691     }
2692
2693     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2694         if ((pMpeg4Dec->bDestinationStart == OMX_FALSE) &&
2695             (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2696             Exynos_OSAL_SignalWait(pMpeg4Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2697             Exynos_OSAL_SignalReset(pMpeg4Dec->hDestinationStartEvent);
2698         }
2699     }
2700     ret = Exynos_Mpeg4Dec_DstOut(pOMXComponent, pDstOutputData);
2701     if ((ret != OMX_ErrorNone) &&
2702         (pExynosComponent->currentState == OMX_StateExecuting)) {
2703         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2704                                                 pExynosComponent->callbackData,
2705                                                 OMX_EventError, ret, 0, NULL);
2706     }
2707
2708 EXIT:
2709     FunctionOut();
2710
2711     return ret;
2712 }
2713
2714 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
2715 {
2716     OMX_ERRORTYPE                  ret              = OMX_ErrorNone;
2717     OMX_COMPONENTTYPE             *pOMXComponent    = NULL;
2718     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = NULL;
2719     EXYNOS_OMX_BASEPORT           *pExynosPort      = NULL;
2720     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec        = NULL;
2721     EXYNOS_MPEG4DEC_HANDLE        *pMpeg4Dec        = NULL;
2722     int i = 0;
2723     OMX_S32 codecType = -1;
2724
2725     FunctionIn();
2726
2727     if ((hComponent == NULL) || (componentName == NULL)) {
2728         ret = OMX_ErrorBadParameter;
2729         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2730         goto EXIT;
2731     }
2732     if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_MPEG4_DEC, componentName) == 0) {
2733         codecType = CODEC_TYPE_MPEG4;
2734     } else if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H263_DEC, componentName) == 0) {
2735         codecType = CODEC_TYPE_H263;
2736     } else {
2737         ret = OMX_ErrorBadParameter;
2738         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2739         goto EXIT;
2740     }
2741
2742     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2743     ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
2744     if (ret != OMX_ErrorNone) {
2745         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2746         goto EXIT;
2747     }
2748     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2749     pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
2750
2751     pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2752     if (pExynosComponent->componentName == NULL) {
2753         Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2754         ret = OMX_ErrorInsufficientResources;
2755         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2756         goto EXIT;
2757     }
2758     Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2759
2760     pMpeg4Dec = Exynos_OSAL_Malloc(sizeof(EXYNOS_MPEG4DEC_HANDLE));
2761     if (pMpeg4Dec == NULL) {
2762         Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2763         ret = OMX_ErrorInsufficientResources;
2764         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2765         goto EXIT;
2766     }
2767     Exynos_OSAL_Memset(pMpeg4Dec, 0, sizeof(EXYNOS_MPEG4DEC_HANDLE));
2768     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2769     pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pMpeg4Dec;
2770     pMpeg4Dec->hMFCMpeg4Handle.codecType = codecType;
2771
2772     if (codecType == CODEC_TYPE_MPEG4)
2773         Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_MPEG4_DEC);
2774     else
2775         Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H263_DEC);
2776
2777     /* In case of BUFFER_COPY mode
2778             bShareableBuf = TRUE means MemoryType is V4L2_MEMORY_USERPTR
2779             bShareableBuf = FALSE means MemoryType is V4L2_MEMORY_MMAP
2780          In case of BUFFER_SHARE
2781             bShareableBuf should be TRUE, FALSE is ignored
2782     */
2783     pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf = OMX_FALSE;
2784     pMpeg4Dec->hMFCMpeg4Handle.bPackedPB = OMX_FALSE;
2785
2786     /* Set componentVersion */
2787     pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2788     pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2789     pExynosComponent->componentVersion.s.nRevision     = REVISION_NUMBER;
2790     pExynosComponent->componentVersion.s.nStep         = STEP_NUMBER;
2791     /* Set specVersion */
2792     pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2793     pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2794     pExynosComponent->specVersion.s.nRevision     = REVISION_NUMBER;
2795     pExynosComponent->specVersion.s.nStep         = STEP_NUMBER;
2796
2797     /* Input port */
2798     pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2799     pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2800     pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2801     pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2802     pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2803     pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2804     if (codecType == CODEC_TYPE_MPEG4) {
2805         pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
2806         Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2807         Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/mpeg4");
2808     } else {
2809         pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
2810         Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2811         Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/h263");
2812     }
2813     pExynosPort->portDefinition.format.video.pNativeRender = 0;
2814     pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2815     pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2816     pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2817     pExynosPort->bufferProcessType = BUFFER_COPY;
2818     pExynosPort->portWayType = WAY2_PORT;
2819
2820     /* Output port */
2821     pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2822     pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2823     pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2824     pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2825     pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2826     pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2827     pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2828     Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2829     Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2830     pExynosPort->portDefinition.format.video.pNativeRender = 0;
2831     pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2832 #ifdef SLP_PLATFORM
2833     pExynosPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
2834     pExynosPort->bufferProcessType = BUFFER_SHARE;
2835 #else
2836     pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2837     pExynosPort->bufferProcessType = BUFFER_COPY;
2838 #endif
2839     pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2840     pExynosPort->portWayType = WAY2_PORT;
2841
2842     if (codecType == CODEC_TYPE_MPEG4) {
2843         for(i = 0; i < ALL_PORT_NUM; i++) {
2844             INIT_SET_SIZE_VERSION(&pMpeg4Dec->mpeg4Component[i], OMX_VIDEO_PARAM_MPEG4TYPE);
2845             pMpeg4Dec->mpeg4Component[i].nPortIndex = i;
2846             pMpeg4Dec->mpeg4Component[i].eProfile   = OMX_VIDEO_MPEG4ProfileSimple;
2847             pMpeg4Dec->mpeg4Component[i].eLevel     = OMX_VIDEO_MPEG4Level3;
2848         }
2849     } else {
2850         for(i = 0; i < ALL_PORT_NUM; i++) {
2851             INIT_SET_SIZE_VERSION(&pMpeg4Dec->h263Component[i], OMX_VIDEO_PARAM_H263TYPE);
2852             pMpeg4Dec->h263Component[i].nPortIndex = i;
2853             pMpeg4Dec->h263Component[i].eProfile   = OMX_VIDEO_H263ProfileBaseline | OMX_VIDEO_H263ProfileISWV2;
2854             pMpeg4Dec->h263Component[i].eLevel     = OMX_VIDEO_H263Level45;
2855         }
2856     }
2857
2858     pOMXComponent->GetParameter      = &Exynos_Mpeg4Dec_GetParameter;
2859     pOMXComponent->SetParameter      = &Exynos_Mpeg4Dec_SetParameter;
2860     pOMXComponent->GetConfig         = &Exynos_Mpeg4Dec_GetConfig;
2861     pOMXComponent->SetConfig         = &Exynos_Mpeg4Dec_SetConfig;
2862     pOMXComponent->GetExtensionIndex = &Exynos_Mpeg4Dec_GetExtensionIndex;
2863     pOMXComponent->ComponentRoleEnum = &Exynos_Mpeg4Dec_ComponentRoleEnum;
2864     pOMXComponent->ComponentDeInit   = &Exynos_OMX_ComponentDeinit;
2865
2866     pExynosComponent->exynos_codec_componentInit      = &Exynos_Mpeg4Dec_Init;
2867     pExynosComponent->exynos_codec_componentTerminate = &Exynos_Mpeg4Dec_Terminate;
2868
2869     pVideoDec->exynos_codec_srcInputProcess  = &Exynos_Mpeg4Dec_srcInputBufferProcess;
2870     pVideoDec->exynos_codec_srcOutputProcess = &Exynos_Mpeg4Dec_srcOutputBufferProcess;
2871     pVideoDec->exynos_codec_dstInputProcess  = &Exynos_Mpeg4Dec_dstInputBufferProcess;
2872     pVideoDec->exynos_codec_dstOutputProcess = &Exynos_Mpeg4Dec_dstOutputBufferProcess;
2873
2874     pVideoDec->exynos_codec_start            = &Mpeg4CodecStart;
2875     pVideoDec->exynos_codec_stop             = &Mpeg4CodecStop;
2876     pVideoDec->exynos_codec_bufferProcessRun = &Mpeg4CodecOutputBufferProcessRun;
2877     pVideoDec->exynos_codec_enqueueAllBuffer = &Mpeg4CodecEnQueueAllBuffer;
2878     pVideoDec->exynos_codec_resetupAllElement = &Mpeg4CodecResetupAllElement;
2879
2880     if (codecType == CODEC_TYPE_MPEG4)
2881         pVideoDec->exynos_checkInputFrame = &Check_Mpeg4_Frame;
2882     else
2883         pVideoDec->exynos_checkInputFrame = &Check_H263_Frame;
2884
2885     pVideoDec->exynos_codec_getCodecInputPrivateData  = &GetCodecInputPrivateData;
2886     pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2887
2888 #ifndef SLP_PLATFORM /* do not use ion */
2889     pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2890     if (pVideoDec->hSharedMemory == NULL) {
2891         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2892         Exynos_OSAL_Free(pMpeg4Dec);
2893         pMpeg4Dec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2894         Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2895         ret = OMX_ErrorInsufficientResources;
2896         goto EXIT;
2897     }
2898 #endif
2899     pExynosComponent->currentState = OMX_StateLoaded;
2900
2901     ret = OMX_ErrorNone;
2902
2903 EXIT:
2904     FunctionOut();
2905
2906     return ret;
2907 }
2908
2909 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
2910 {
2911     OMX_ERRORTYPE            ret = OMX_ErrorNone;
2912     OMX_COMPONENTTYPE       *pOMXComponent = NULL;
2913     EXYNOS_OMX_BASECOMPONENT   *pExynosComponent = NULL;
2914     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2915     EXYNOS_MPEG4DEC_HANDLE      *pMpeg4Dec = NULL;
2916
2917     FunctionIn();
2918
2919     if (hComponent == NULL) {
2920         ret = OMX_ErrorBadParameter;
2921         goto EXIT;
2922     }
2923     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2924     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2925     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2926 #ifndef SLP_PLATFORM /* do not use ion */
2927     Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2928 #endif
2929     Exynos_OSAL_Free(pExynosComponent->componentName);
2930     pExynosComponent->componentName = NULL;
2931
2932     pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
2933     if (pMpeg4Dec != NULL) {
2934         Exynos_OSAL_Free(pMpeg4Dec);
2935         pMpeg4Dec = pVideoDec->hCodecHandle = NULL;
2936     }
2937
2938     ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2939     if (ret != OMX_ErrorNone) {
2940         goto EXIT;
2941     }
2942
2943     ret = OMX_ErrorNone;
2944
2945 EXIT:
2946     FunctionOut();
2947
2948     return ret;
2949 }