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].allocSize = nAllocLen[plane];
1263                 }
1264
1265                 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1266                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1267                 ret = OMX_ErrorInsufficientResources;
1268                 goto EXIT;
1269             }
1270                 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
1271                                (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1272             }
1273         } else {
1274             ret = OMX_ErrorNotImplemented;
1275             goto EXIT;
1276         }
1277 #else
1278         ret = OMX_ErrorNotImplemented;
1279         goto EXIT;
1280 #endif
1281     }
1282
1283     if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1284         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1285         ret = OMX_ErrorInsufficientResources;
1286         goto EXIT;
1287     }
1288
1289     if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1290         Mpeg4CodecStop (pOMXComponent, OUTPUT_PORT_INDEX);
1291     }
1292     pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_TRUE;
1293
1294     ret = OMX_ErrorNone;
1295
1296 EXIT:
1297     FunctionOut();
1298
1299     return ret;
1300 }
1301
1302 OMX_ERRORTYPE Mpeg4CodecCheckResolutionChange(OMX_COMPONENTTYPE *pOMXComponent)
1303 {
1304     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
1305     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1306     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1307     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1308     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
1309     EXYNOS_OMX_BASEPORT           *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1310     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1311
1312     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
1313     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
1314     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
1315     ExynosVideoGeometry      bufferConf;
1316     int i;
1317
1318     FunctionIn();
1319
1320     /* get geometry for output */
1321     Exynos_OSAL_Memset(&pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
1322     if (pOutbufOps->Get_Geometry(hMFCHandle, &pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf) != VIDEO_ERROR_NONE) {
1323         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
1324         ret = OMX_ErrorInsufficientResources;
1325         goto EXIT;
1326     }
1327
1328     /* get dpb count */
1329     pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
1330     if (pVideoDec->bThumbnailMode == OMX_FALSE)
1331         pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum += EXTRA_DPB_NUM;
1332     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Mpeg4CodecCheckResolutionChange Mpeg4CodecSetup nOutbufs: %d", pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum);
1333
1334     pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_TRUE;
1335
1336     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1337         if ((pVideoDec->bDRCProcessing) ||
1338             (pExynosInputPort->portDefinition.format.video.nFrameWidth != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth) ||
1339             (pExynosInputPort->portDefinition.format.video.nFrameHeight != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight)) {
1340             pExynosInputPort->portDefinition.format.video.nFrameWidth = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth;
1341             pExynosInputPort->portDefinition.format.video.nFrameHeight = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight;
1342             pExynosInputPort->portDefinition.format.video.nStride = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1343             pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1344
1345             if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1346                 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1347             }
1348             Exynos_UpdateFrameSize(pOMXComponent);
1349             pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1350
1351             /** Send Port Settings changed call back **/
1352         (*(pExynosComponent->pCallbacks->EventHandler))
1353             (pOMXComponent,
1354              pExynosComponent->callbackData,
1355              OMX_EventPortSettingsChanged, /* The command was completed */
1356              OMX_DirOutput, /* This is the port index */
1357                  0,
1358              NULL);
1359     }
1360     } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1361         if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth) ||
1362             (pExynosInputPort->portDefinition.format.video.nFrameHeight != pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight) ||
1363             (pExynosOutputPort->portDefinition.nBufferCountActual != pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum)) {
1364             pExynosInputPort->portDefinition.format.video.nFrameWidth = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth;
1365             pExynosInputPort->portDefinition.format.video.nFrameHeight = pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight;
1366             pExynosInputPort->portDefinition.format.video.nStride = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
1367             pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
1368
1369             if (pVideoDec->bDRCProcessing == OMX_TRUE) {
1370                 pVideoDec->nDRCSavedBufferCount = pExynosOutputPort->portDefinition.nBufferCountActual;
1371             }
1372 #ifdef SLP_PLATFORM
1373             pExynosOutputPort->portDefinition.nBufferCountActual = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum;
1374             pExynosOutputPort->portDefinition.nBufferCountMin = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum;
1375 #else
1376             pExynosOutputPort->portDefinition.nBufferCountActual = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum - 4;
1377             pExynosOutputPort->portDefinition.nBufferCountMin = pMpeg4Dec->hMFCMpeg4Handle.maxDPBNum - 4;
1378 #endif
1379             Exynos_UpdateFrameSize(pOMXComponent);
1380             pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
1381
1382             /** Send Port Settings changed call back **/
1383             (*(pExynosComponent->pCallbacks->EventHandler))
1384                 (pOMXComponent,
1385                  pExynosComponent->callbackData,
1386                  OMX_EventPortSettingsChanged, /* The command was completed */
1387                  OMX_DirOutput, /* This is the port index */
1388                  0,
1389                  NULL);
1390         }
1391     }
1392
1393     ret = OMX_ErrorNone;
1394
1395 EXIT:
1396     FunctionOut();
1397
1398     return ret;
1399 }
1400
1401
1402 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetParameter(
1403     OMX_IN OMX_HANDLETYPE hComponent,
1404     OMX_IN OMX_INDEXTYPE  nParamIndex,
1405     OMX_INOUT OMX_PTR     pComponentParameterStructure)
1406 {
1407     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1408     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1409     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1410
1411     FunctionIn();
1412
1413     if (hComponent == NULL || pComponentParameterStructure == NULL) {
1414         ret = OMX_ErrorBadParameter;
1415         goto EXIT;
1416     }
1417     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1418     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1419     if (ret != OMX_ErrorNone) {
1420         goto EXIT;
1421     }
1422     if (pOMXComponent->pComponentPrivate == NULL) {
1423         ret = OMX_ErrorBadParameter;
1424         goto EXIT;
1425     }
1426
1427     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1428     if (pExynosComponent->currentState == OMX_StateInvalid ) {
1429         ret = OMX_ErrorInvalidState;
1430         goto EXIT;
1431     }
1432
1433     switch (nParamIndex) {
1434     case OMX_IndexParamVideoMpeg4:
1435     {
1436         OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1437         OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = NULL;
1438         EXYNOS_MPEG4DEC_HANDLE       *pMpeg4Dec      = NULL;
1439
1440         ret = Exynos_OMX_Check_SizeVersion(pDstMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1441         if (ret != OMX_ErrorNone) {
1442             goto EXIT;
1443         }
1444
1445         if (pDstMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
1446             ret = OMX_ErrorBadPortIndex;
1447             goto EXIT;
1448         }
1449
1450         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1451         pSrcMpeg4Param = &pMpeg4Dec->mpeg4Component[pDstMpeg4Param->nPortIndex];
1452
1453         Exynos_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1454     }
1455         break;
1456     case OMX_IndexParamVideoH263:
1457     {
1458         OMX_VIDEO_PARAM_H263TYPE  *pDstH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1459         OMX_VIDEO_PARAM_H263TYPE  *pSrcH263Param = NULL;
1460         EXYNOS_MPEG4DEC_HANDLE       *pMpeg4Dec     = NULL;
1461
1462         ret = Exynos_OMX_Check_SizeVersion(pDstH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1463         if (ret != OMX_ErrorNone) {
1464             goto EXIT;
1465         }
1466
1467         if (pDstH263Param->nPortIndex >= ALL_PORT_NUM) {
1468             ret = OMX_ErrorBadPortIndex;
1469             goto EXIT;
1470         }
1471
1472         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1473         pSrcH263Param = &pMpeg4Dec->h263Component[pDstH263Param->nPortIndex];
1474
1475         Exynos_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1476     }
1477         break;
1478     case OMX_IndexParamStandardComponentRole:
1479     {
1480         OMX_S32                      codecType;
1481         OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1482
1483         ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1484         if (ret != OMX_ErrorNone) {
1485             goto EXIT;
1486         }
1487
1488         codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1489         if (codecType == CODEC_TYPE_MPEG4)
1490             Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE);
1491         else
1492             Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE);
1493     }
1494         break;
1495     case OMX_IndexParamVideoProfileLevelQuerySupported:
1496     {
1497         OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel   = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1498         EXYNOS_OMX_VIDEO_PROFILELEVEL    *pProfileLevel      = NULL;
1499         OMX_U32                           maxProfileLevelNum = 0;
1500         OMX_S32                           codecType;
1501
1502         ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1503         if (ret != OMX_ErrorNone) {
1504             goto EXIT;
1505         }
1506
1507         if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1508             ret = OMX_ErrorBadPortIndex;
1509             goto EXIT;
1510         }
1511
1512         codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
1513         if (codecType == CODEC_TYPE_MPEG4) {
1514             pProfileLevel = supportedMPEG4ProfileLevels;
1515             maxProfileLevelNum = sizeof(supportedMPEG4ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1516         } else {
1517             pProfileLevel = supportedH263ProfileLevels;
1518             maxProfileLevelNum = sizeof(supportedH263ProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1519         }
1520
1521         if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
1522             ret = OMX_ErrorNoMore;
1523             goto EXIT;
1524         }
1525
1526         pProfileLevel += pDstProfileLevel->nProfileIndex;
1527         pDstProfileLevel->eProfile = pProfileLevel->profile;
1528         pDstProfileLevel->eLevel = pProfileLevel->level;
1529     }
1530         break;
1531     case OMX_IndexParamVideoProfileLevelCurrent:
1532     {
1533         OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1534         OMX_VIDEO_PARAM_MPEG4TYPE        *pSrcMpeg4Param   = NULL;
1535         OMX_VIDEO_PARAM_H263TYPE         *pSrcH263Param    = NULL;
1536         EXYNOS_MPEG4DEC_HANDLE              *pMpeg4Dec        = NULL;
1537         OMX_S32                           codecType;
1538
1539         ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1540         if (ret != OMX_ErrorNone) {
1541             goto EXIT;
1542         }
1543
1544         if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1545             ret = OMX_ErrorBadPortIndex;
1546             goto EXIT;
1547         }
1548
1549         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1550         codecType = pMpeg4Dec->hMFCMpeg4Handle.codecType;
1551         if (codecType == CODEC_TYPE_MPEG4) {
1552             pSrcMpeg4Param = &pMpeg4Dec->mpeg4Component[pDstProfileLevel->nPortIndex];
1553             pDstProfileLevel->eProfile = pSrcMpeg4Param->eProfile;
1554             pDstProfileLevel->eLevel = pSrcMpeg4Param->eLevel;
1555         } else {
1556             pSrcH263Param = &pMpeg4Dec->h263Component[pDstProfileLevel->nPortIndex];
1557             pDstProfileLevel->eProfile = pSrcH263Param->eProfile;
1558             pDstProfileLevel->eLevel = pSrcH263Param->eLevel;
1559         }
1560     }
1561         break;
1562     case OMX_IndexParamVideoErrorCorrection:
1563     {
1564         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1565         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1566         EXYNOS_MPEG4DEC_HANDLE                 *pMpeg4Dec               = NULL;
1567
1568         ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1569         if (ret != OMX_ErrorNone) {
1570             goto EXIT;
1571         }
1572
1573         if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1574             ret = OMX_ErrorBadPortIndex;
1575             goto EXIT;
1576         }
1577
1578         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1579         pSrcErrorCorrectionType = &pMpeg4Dec->errorCorrectionType[INPUT_PORT_INDEX];
1580
1581         pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1582         pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1583         pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1584         pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1585         pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1586     }
1587         break;
1588     default:
1589         ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1590         break;
1591     }
1592 EXIT:
1593     FunctionOut();
1594
1595     return ret;
1596 }
1597
1598 OMX_ERRORTYPE Exynos_Mpeg4Dec_SetParameter(
1599     OMX_IN OMX_HANDLETYPE hComponent,
1600     OMX_IN OMX_INDEXTYPE  nIndex,
1601     OMX_IN OMX_PTR        pComponentParameterStructure)
1602 {
1603     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1604     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1605     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1606
1607     FunctionIn();
1608
1609     if (hComponent == NULL || pComponentParameterStructure == NULL) {
1610         ret = OMX_ErrorBadParameter;
1611         goto EXIT;
1612     }
1613     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1614     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1615     if (ret != OMX_ErrorNone) {
1616         goto EXIT;
1617     }
1618     if (pOMXComponent->pComponentPrivate == NULL) {
1619         ret = OMX_ErrorBadParameter;
1620         goto EXIT;
1621     }
1622
1623     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1624     if (pExynosComponent->currentState == OMX_StateInvalid ) {
1625         ret = OMX_ErrorInvalidState;
1626         goto EXIT;
1627     }
1628
1629     switch (nIndex) {
1630     case OMX_IndexParamVideoMpeg4:
1631     {
1632         OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = NULL;
1633         OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
1634         EXYNOS_MPEG4DEC_HANDLE    *pMpeg4Dec      = NULL;
1635
1636         ret = Exynos_OMX_Check_SizeVersion(pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1637         if (ret != OMX_ErrorNone) {
1638             goto EXIT;
1639         }
1640
1641         if (pSrcMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
1642             ret = OMX_ErrorBadPortIndex;
1643             goto EXIT;
1644         }
1645
1646         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1647         pDstMpeg4Param = &pMpeg4Dec->mpeg4Component[pSrcMpeg4Param->nPortIndex];
1648
1649         Exynos_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1650     }
1651         break;
1652     case OMX_IndexParamVideoH263:
1653     {
1654         OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = NULL;
1655         OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
1656         EXYNOS_MPEG4DEC_HANDLE   *pMpeg4Dec     = NULL;
1657
1658         ret = Exynos_OMX_Check_SizeVersion(pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1659         if (ret != OMX_ErrorNone) {
1660             goto EXIT;
1661         }
1662
1663         if (pSrcH263Param->nPortIndex >= ALL_PORT_NUM) {
1664             ret = OMX_ErrorBadPortIndex;
1665             goto EXIT;
1666         }
1667
1668         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1669         pDstH263Param = &pMpeg4Dec->h263Component[pSrcH263Param->nPortIndex];
1670
1671         Exynos_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1672     }
1673         break;
1674     case OMX_IndexParamStandardComponentRole:
1675     {
1676         OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1677
1678         ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1679         if (ret != OMX_ErrorNone) {
1680             goto EXIT;
1681         }
1682
1683         if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1684             ret = OMX_ErrorIncorrectStateOperation;
1685             goto EXIT;
1686         }
1687
1688         if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE)) {
1689             pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
1690         } else if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE)) {
1691             pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
1692         } else {
1693             ret = OMX_ErrorBadParameter;
1694             goto EXIT;
1695         }
1696     }
1697         break;
1698     case OMX_IndexParamPortDefinition:
1699     {
1700         OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1701         OMX_U32                       portIndex       = pPortDefinition->nPortIndex;
1702         EXYNOS_OMX_BASEPORT          *pExynosPort;
1703         OMX_U32                       width, height, size;
1704         OMX_U32                       realWidth, realHeight;
1705         OMX_PARAM_PORTDEFINITIONTYPE  portDefinition_backup;
1706
1707         if (portIndex >= pExynosComponent->portParam.nPorts) {
1708             ret = OMX_ErrorBadPortIndex;
1709             goto EXIT;
1710         }
1711         ret = Exynos_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1712         if (ret != OMX_ErrorNone) {
1713             goto EXIT;
1714         }
1715
1716         pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1717
1718         if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1719             if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1720                 ret = OMX_ErrorIncorrectStateOperation;
1721                 goto EXIT;
1722             }
1723         }
1724         if (pPortDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1725             ret = OMX_ErrorBadParameter;
1726             goto EXIT;
1727         }
1728
1729         Exynos_OSAL_Memcpy(&portDefinition_backup, &pExynosPort->portDefinition, pPortDefinition->nSize);
1730         Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
1731         RESTORE_READONLYPARAMETERS_OMX_PARAM_PORTDEFINITIONTYPE(&pExynosPort->portDefinition,&portDefinition_backup);
1732
1733         realWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1734         realHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1735         width = ((realWidth + 15) & (~15));
1736         height = ((realHeight + 15) & (~15));
1737         size = (width * height * 3) / 2;
1738         pExynosPort->portDefinition.format.video.nStride = width;
1739         pExynosPort->portDefinition.format.video.nSliceHeight = height;
1740         pExynosPort->portDefinition.nBufferSize = (size > pExynosPort->portDefinition.nBufferSize) ? size : pExynosPort->portDefinition.nBufferSize;
1741
1742         if (portIndex == INPUT_PORT_INDEX) {
1743             EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1744             pExynosOutputPort->portDefinition.format.video.nFrameWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1745             pExynosOutputPort->portDefinition.format.video.nFrameHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1746             pExynosOutputPort->portDefinition.format.video.nStride = width;
1747             pExynosOutputPort->portDefinition.format.video.nSliceHeight = height;
1748
1749             switch (pExynosOutputPort->portDefinition.format.video.eColorFormat) {
1750             case OMX_COLOR_FormatYUV420Planar:
1751             case OMX_COLOR_FormatYUV420SemiPlanar:
1752                 pExynosOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
1753                 break;
1754 #ifdef SLP_PLATFORM /* NV12T fd */
1755             case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
1756                 pExynosOutputPort->portDefinition.nBufferSize = sizeof(MMVideoBuffer);
1757                 break;
1758 #endif
1759             case OMX_SEC_COLOR_FormatNV12Tiled:
1760                 pExynosOutputPort->portDefinition.nBufferSize =
1761                     calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1762                     calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1763                 break;
1764             default:
1765                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Color format is not support!! use default YUV size!!");
1766                 ret = OMX_ErrorUnsupportedSetting;
1767                 break;
1768             }
1769
1770             if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1771                 pExynosOutputPort->portDefinition.nBufferSize =
1772                     calc_yplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1773                     calc_uvplane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1774             }
1775         }
1776     }
1777         break;
1778     case OMX_IndexParamVideoProfileLevelCurrent:
1779     {
1780         OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1781         OMX_VIDEO_PARAM_MPEG4TYPE        *pDstMpeg4Param   = NULL;
1782         OMX_VIDEO_PARAM_H263TYPE         *pDstH263Param    = NULL;
1783         EXYNOS_MPEG4DEC_HANDLE           *pMpeg4Dec        = NULL;
1784         OMX_S32                           codecType;
1785
1786         ret = Exynos_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1787         if (ret != OMX_ErrorNone)
1788             goto EXIT;
1789
1790         if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1791             ret = OMX_ErrorBadPortIndex;
1792             goto EXIT;
1793         }
1794
1795         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1796         codecType = pMpeg4Dec->hMFCMpeg4Handle.codecType;
1797         if (codecType == CODEC_TYPE_MPEG4) {
1798             /*
1799              * To do: Check validity of profile & level parameters
1800              */
1801
1802             pDstMpeg4Param = &pMpeg4Dec->mpeg4Component[pSrcProfileLevel->nPortIndex];
1803             pDstMpeg4Param->eProfile = pSrcProfileLevel->eProfile;
1804             pDstMpeg4Param->eLevel = pSrcProfileLevel->eLevel;
1805         } else {
1806             /*
1807              * To do: Check validity of profile & level parameters
1808              */
1809
1810             pDstH263Param = &pMpeg4Dec->h263Component[pSrcProfileLevel->nPortIndex];
1811             pDstH263Param->eProfile = pSrcProfileLevel->eProfile;
1812             pDstH263Param->eLevel = pSrcProfileLevel->eLevel;
1813         }
1814     }
1815         break;
1816     case OMX_IndexParamVideoErrorCorrection:
1817     {
1818         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1819         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1820         EXYNOS_MPEG4DEC_HANDLE              *pMpeg4Dec               = NULL;
1821
1822         ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1823         if (ret != OMX_ErrorNone) {
1824             goto EXIT;
1825         }
1826
1827         if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1828             ret = OMX_ErrorBadPortIndex;
1829             goto EXIT;
1830         }
1831
1832         pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1833         pDstErrorCorrectionType = &pMpeg4Dec->errorCorrectionType[INPUT_PORT_INDEX];
1834
1835         pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1836         pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1837         pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1838         pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1839         pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1840     }
1841         break;
1842     default:
1843         ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1844         break;
1845     }
1846 EXIT:
1847     FunctionOut();
1848
1849     return ret;
1850 }
1851
1852 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetConfig(
1853     OMX_IN OMX_HANDLETYPE hComponent,
1854     OMX_IN OMX_INDEXTYPE  nIndex,
1855     OMX_IN OMX_PTR        pComponentConfigStructure)
1856 {
1857     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1858     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1859     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1860
1861     FunctionIn();
1862
1863     if (hComponent == NULL || pComponentConfigStructure == NULL) {
1864         ret = OMX_ErrorBadParameter;
1865         goto EXIT;
1866     }
1867     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1868     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1869     if (ret != OMX_ErrorNone) {
1870         goto EXIT;
1871     }
1872     if (pOMXComponent->pComponentPrivate == NULL) {
1873         ret = OMX_ErrorBadParameter;
1874         goto EXIT;
1875     }
1876     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1877     if (pExynosComponent->currentState == OMX_StateInvalid) {
1878         ret = OMX_ErrorInvalidState;
1879         goto EXIT;
1880     }
1881
1882     switch (nIndex) {
1883     default:
1884         ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1885         break;
1886     }
1887
1888 EXIT:
1889     FunctionOut();
1890
1891     return ret;
1892 }
1893
1894 OMX_ERRORTYPE Exynos_Mpeg4Dec_SetConfig(
1895     OMX_IN OMX_HANDLETYPE hComponent,
1896     OMX_IN OMX_INDEXTYPE  nIndex,
1897     OMX_IN OMX_PTR        pComponentConfigStructure)
1898 {
1899     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1900     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1901     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1902
1903     FunctionIn();
1904
1905     if (hComponent == NULL || pComponentConfigStructure == NULL) {
1906         ret = OMX_ErrorBadParameter;
1907         goto EXIT;
1908     }
1909     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1910     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1911     if (ret != OMX_ErrorNone) {
1912         goto EXIT;
1913     }
1914     if (pOMXComponent->pComponentPrivate == NULL) {
1915         ret = OMX_ErrorBadParameter;
1916         goto EXIT;
1917     }
1918     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1919     if (pExynosComponent->currentState == OMX_StateInvalid) {
1920         ret = OMX_ErrorInvalidState;
1921         goto EXIT;
1922     }
1923
1924     switch (nIndex) {
1925     default:
1926         ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1927         break;
1928     }
1929
1930 EXIT:
1931     FunctionOut();
1932
1933     return ret;
1934 }
1935
1936 OMX_ERRORTYPE Exynos_Mpeg4Dec_GetExtensionIndex(
1937     OMX_IN  OMX_HANDLETYPE  hComponent,
1938     OMX_IN  OMX_STRING      cParameterName,
1939     OMX_OUT OMX_INDEXTYPE  *pIndexType)
1940 {
1941     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1942     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1943     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1944
1945     FunctionIn();
1946
1947     if (hComponent == NULL) {
1948         ret = OMX_ErrorBadParameter;
1949         goto EXIT;
1950     }
1951     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1952     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1953     if (ret != OMX_ErrorNone) {
1954         goto EXIT;
1955     }
1956     if (pOMXComponent->pComponentPrivate == NULL) {
1957         ret = OMX_ErrorBadParameter;
1958         goto EXIT;
1959     }
1960     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1961     if ((cParameterName == NULL) || (pIndexType == NULL)) {
1962         ret = OMX_ErrorBadParameter;
1963         goto EXIT;
1964     }
1965     if (pExynosComponent->currentState == OMX_StateInvalid) {
1966         ret = OMX_ErrorInvalidState;
1967         goto EXIT;
1968     }
1969
1970     if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1971         EXYNOS_MPEG4DEC_HANDLE *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1972         *pIndexType = OMX_IndexVendorThumbnailMode;
1973         ret = OMX_ErrorNone;
1974     } else {
1975         ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1976     }
1977
1978 EXIT:
1979     FunctionOut();
1980
1981     return ret;
1982 }
1983
1984 OMX_ERRORTYPE Exynos_Mpeg4Dec_ComponentRoleEnum(
1985     OMX_IN  OMX_HANDLETYPE hComponent,
1986     OMX_OUT OMX_U8        *cRole,
1987     OMX_IN  OMX_U32        nIndex)
1988 {
1989     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1990     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1991     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1992     OMX_S32                   codecType;
1993
1994     FunctionIn();
1995
1996     if ((hComponent == NULL) || (cRole == NULL)) {
1997         ret = OMX_ErrorBadParameter;
1998         goto EXIT;
1999     }
2000     if (nIndex != (MAX_COMPONENT_ROLE_NUM - 1)) {
2001         ret = OMX_ErrorNoMore;
2002         goto EXIT;
2003     }
2004     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2005     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
2006     if (ret != OMX_ErrorNone) {
2007         goto EXIT;
2008     }
2009     if (pOMXComponent->pComponentPrivate == NULL) {
2010         ret = OMX_ErrorBadParameter;
2011         goto EXIT;
2012     }
2013     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2014     if (pExynosComponent->currentState == OMX_StateInvalid ) {
2015         ret = OMX_ErrorInvalidState;
2016         goto EXIT;
2017     }
2018
2019     codecType = ((EXYNOS_MPEG4DEC_HANDLE *)(((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle))->hMFCMpeg4Handle.codecType;
2020     if (codecType == CODEC_TYPE_MPEG4)
2021         Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_MPEG4_DEC_ROLE);
2022     else
2023         Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_H263_DEC_ROLE);
2024
2025 EXIT:
2026     FunctionOut();
2027
2028     return ret;
2029 }
2030
2031 /* MFC Init */
2032 OMX_ERRORTYPE Exynos_Mpeg4Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
2033 {
2034     OMX_ERRORTYPE                  ret               = OMX_ErrorNone;
2035     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent  = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2036     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec         = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2037     EXYNOS_OMX_BASEPORT           *pExynosInputPort  = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2038     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2039     EXYNOS_MPEG4DEC_HANDLE        *pMpeg4Dec         = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
2040     OMX_PTR                        hMFCHandle        = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2041
2042     ExynosVideoDecOps       *pDecOps    = NULL;
2043     ExynosVideoDecBufferOps *pInbufOps  = NULL;
2044     ExynosVideoDecBufferOps *pOutbufOps = NULL;
2045
2046     CSC_METHOD csc_method = CSC_METHOD_SW;
2047     int i, plane;
2048
2049     FunctionIn();
2050
2051     pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc = OMX_FALSE;
2052     pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst = OMX_FALSE;
2053     pExynosComponent->bUseFlagEOF = OMX_TRUE;
2054     pExynosComponent->bSaveFlagEOS = OMX_FALSE;
2055
2056     /* Mpeg4 Codec Open */
2057     ret = Mpeg4CodecOpen(pMpeg4Dec);
2058     if (ret != OMX_ErrorNone) {
2059         goto EXIT;
2060     }
2061
2062     pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2063     pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
2064     pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2065
2066     if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2067         Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
2068         Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
2069
2070         if (pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf == OMX_TRUE) {
2071             for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2072                 pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
2073                 Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
2074                 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
2075
2076             for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2077             /* Use ION Allocator */
2078                 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, DEFAULT_MFC_INPUT_BUFFER_SIZE, NORMAL_MEMORY);
2079                 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2080                 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = DEFAULT_MFC_INPUT_BUFFER_SIZE;
2081             pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2082             if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] == NULL) {
2083                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
2084                 ret = OMX_ErrorInsufficientResources;
2085                 goto EXIT;
2086             }
2087                 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2088             }
2089
2090                 Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
2091             }
2092         } else {
2093 #ifdef SLP_PLATFORM
2094                 if (pOMXComponent == NULL) {
2095                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d: invalid parm: pOMXComponent = %p", __FUNCTION__, __LINE__, pOMXComponent);
2096                 }
2097 #endif
2098                 ret = Mpeg4CodecSrcInit(pOMXComponent);
2099                 if (ret != OMX_ErrorNone)
2100                     goto EXIT;
2101         }
2102     } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2103         /*************/
2104         /*    TBD    */
2105         /*************/
2106         /* Does not require any actions. */
2107     }
2108
2109     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2110         Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
2111         Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
2112     } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2113         /*************/
2114         /*    TBD    */
2115         /*************/
2116         /* Does not require any actions. */
2117     }
2118
2119     pMpeg4Dec->bSourceStart = OMX_FALSE;
2120     Exynos_OSAL_SignalCreate(&pMpeg4Dec->hSourceStartEvent);
2121     pMpeg4Dec->bDestinationStart = OMX_FALSE;
2122     Exynos_OSAL_SignalCreate(&pMpeg4Dec->hDestinationStartEvent);
2123
2124     Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
2125     Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
2126     pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp = 0;
2127     pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp = 0;
2128
2129     pExynosComponent->getAllDelayBuffer = OMX_FALSE;
2130
2131 #if 0//defined(USE_CSC_GSCALER)
2132     csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
2133 #endif
2134     pVideoDec->csc_handle = csc_init(csc_method);
2135     if (pVideoDec->csc_handle == NULL) {
2136         ret = OMX_ErrorInsufficientResources;
2137         goto EXIT;
2138     }
2139     pVideoDec->csc_set_format = OMX_FALSE;
2140
2141 EXIT:
2142     FunctionOut();
2143
2144     return ret;
2145 }
2146
2147 /* MFC Terminate */
2148 OMX_ERRORTYPE Exynos_Mpeg4Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
2149 {
2150     OMX_ERRORTYPE          ret = OMX_ErrorNone;
2151     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2152     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2153     EXYNOS_OMX_BASEPORT      *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2154     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2155     EXYNOS_MPEG4DEC_HANDLE    *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2156     OMX_PTR                hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2157
2158     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2159     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
2160     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2161
2162     int i, plane;
2163
2164     FunctionIn();
2165
2166     if (pVideoDec->csc_handle != NULL) {
2167         csc_deinit(pVideoDec->csc_handle);
2168         pVideoDec->csc_handle = NULL;
2169     }
2170
2171     Exynos_OSAL_SignalTerminate(pMpeg4Dec->hDestinationStartEvent);
2172     pMpeg4Dec->hDestinationStartEvent = NULL;
2173     pMpeg4Dec->bDestinationStart = OMX_FALSE;
2174     Exynos_OSAL_SignalTerminate(pMpeg4Dec->hSourceStartEvent);
2175     pMpeg4Dec->hSourceStartEvent = NULL;
2176     pMpeg4Dec->bSourceStart = OMX_FALSE;
2177
2178     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2179         Mpeg4CodecDstFreeCodecBuffers(pOMXComponent);
2180
2181         Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
2182         Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
2183     } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2184         /*************/
2185         /*    TBD    */
2186         /*************/
2187         /* Does not require any actions. */
2188     }
2189
2190     if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2191         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
2192             if (pVideoDec->pMFCDecInputBuffer[i] != NULL) {
2193 #ifndef SLP_PLATFORM /* do not use ion */
2194                 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2195                     if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] != NULL)
2196                         Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
2197                 }
2198 #endif
2199                 Exynos_OSAL_Free(pVideoDec->pMFCDecInputBuffer[i]);
2200                 pVideoDec->pMFCDecInputBuffer[i] = NULL;
2201             }
2202         }
2203
2204         Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
2205         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
2206     } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
2207         /*************/
2208         /*    TBD    */
2209         /*************/
2210         /* Does not require any actions. */
2211     }
2212     Mpeg4CodecClose(pMpeg4Dec);
2213
2214 EXIT:
2215     FunctionOut();
2216
2217     return ret;
2218 }
2219
2220 OMX_ERRORTYPE Exynos_Mpeg4Dec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2221 {
2222     OMX_ERRORTYPE               ret = OMX_ErrorNone;
2223     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2224     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2225     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2226     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2227     EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2228     EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2229     OMX_U32  oneFrameSize = pSrcInputData->dataLen;
2230        OMX_BOOL bInStartCode = OMX_FALSE;
2231     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2232     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
2233     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2234     ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2235     int i;
2236
2237     FunctionIn();
2238
2239     if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCSrc == OMX_FALSE) {
2240         ret = Mpeg4CodecSrcSetup(pOMXComponent, pSrcInputData);
2241         goto EXIT;
2242     }
2243     if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_FALSE) {
2244         ret = Mpeg4CodecDstSetup(pOMXComponent);
2245     }
2246
2247   if (((bInStartCode = Check_Stream_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize, pMpeg4Dec->hMFCMpeg4Handle.codecType)) == OMX_TRUE) ||
2248         ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)){
2249         pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->timeStamp;
2250         pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp] = pSrcInputData->nFlags;
2251         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);
2252         pDecOps->Set_FrameTag(hMFCHandle, pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp);
2253         pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp++;
2254         pMpeg4Dec->hMFCMpeg4Handle.indexTimestamp %= MAX_TIMESTAMP;
2255
2256 #ifdef USE_IMMEDIATE_DISPLAY
2257     /* Set Immediately display for I Frame*/
2258         if (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp == OMX_TRUE) {
2259             if ( pExynosComponent->checkTimeStamp.bImmediateDisplay == OMX_FALSE) {
2260                 /* Enable Immediately display After seek*/
2261                 pDecOps->Set_ImmediateDisplay(hMFCHandle);
2262                 pExynosComponent->checkTimeStamp.bImmediateDisplay = OMX_TRUE;
2263             }
2264         }
2265 #endif
2266         /* queue work for input buffer */
2267         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
2268         codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
2269                                     (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
2270         if (codecReturn != VIDEO_ERROR_NONE) {
2271             ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2272             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2273             goto EXIT;
2274         }
2275         Mpeg4CodecStart(pOMXComponent, INPUT_PORT_INDEX);
2276         if (pMpeg4Dec->bSourceStart == OMX_FALSE) {
2277             pMpeg4Dec->bSourceStart = OMX_TRUE;
2278             Exynos_OSAL_SignalSet(pMpeg4Dec->hSourceStartEvent);
2279             Exynos_OSAL_SleepMillisec(0);
2280         }
2281         if (pMpeg4Dec->bDestinationStart == OMX_FALSE) {
2282             pMpeg4Dec->bDestinationStart = OMX_TRUE;
2283             Exynos_OSAL_SignalSet(pMpeg4Dec->hDestinationStartEvent);
2284             Exynos_OSAL_SleepMillisec(0);
2285         }
2286          } else if (bInStartCode == OMX_FALSE) {
2287         ret = OMX_ErrorCorruptedFrame;
2288         goto EXIT;
2289     }
2290
2291     ret = OMX_ErrorNone;
2292
2293 EXIT:
2294     FunctionOut();
2295
2296     return ret;
2297 }
2298
2299 OMX_ERRORTYPE Exynos_Mpeg4Dec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2300 {
2301     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
2302     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2303     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2304     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2305     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2306     EXYNOS_OMX_BASEPORT     *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2307     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2308     ExynosVideoDecBufferOps *pInbufOps  = pMpeg4Dec->hMFCMpeg4Handle.pInbufOps;
2309     ExynosVideoBuffer       *pVideoBuffer;
2310
2311     FunctionIn();
2312
2313     pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
2314
2315     pSrcOutputData->dataLen       = 0;
2316     pSrcOutputData->usedDataLen   = 0;
2317     pSrcOutputData->remainDataLen = 0;
2318     pSrcOutputData->nFlags    = 0;
2319     pSrcOutputData->timeStamp = 0;
2320
2321     if (pVideoBuffer == NULL) {
2322         pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
2323         pSrcOutputData->allocSize  = 0;
2324         pSrcOutputData->pPrivate = NULL;
2325         pSrcOutputData->bufferHeader = NULL;
2326     } else {
2327         pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2328         pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2329         pSrcOutputData->allocSize  = pVideoBuffer->planes[0].allocSize;
2330
2331         if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2332             int i = 0;
2333             while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
2334                 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2335                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
2336                     ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2337                     goto EXIT;
2338                 }
2339                 i++;
2340             }
2341             pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
2342             pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
2343         }
2344
2345         /* For Share Buffer */
2346         pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2347     }
2348
2349     ret = OMX_ErrorNone;
2350
2351 EXIT:
2352     FunctionOut();
2353
2354     return ret;
2355 }
2356
2357 OMX_ERRORTYPE Exynos_Mpeg4Dec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2358 {
2359     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
2360     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2361     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2362     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2363     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2364     EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2365     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2366     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2367     OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0,};
2368     ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2369
2370     FunctionIn();
2371
2372     if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
2373         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2374         ret = OMX_ErrorBadParameter;
2375         goto EXIT;
2376     }
2377
2378     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
2379                                         pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
2380                                         pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
2381
2382     if ((pVideoDec->bDRCProcessing == OMX_TRUE) &&
2383         (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) &&
2384         (pExynosOutputPort->exceptionFlag == GENERAL_STATE)) {
2385         ret = Mpeg4CodecDstSetup(pOMXComponent);
2386         if (ret != OMX_ErrorNone) {
2387             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "DRC Reconfig CodecDstSetup Failed");
2388             goto EXIT;
2389         }
2390         pVideoDec->bDRCProcessing = OMX_FALSE;
2391     }
2392
2393     codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
2394                  (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
2395
2396     if (codecReturn != VIDEO_ERROR_NONE) {
2397         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
2398         ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
2399         goto EXIT;
2400     }
2401     Mpeg4CodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2402
2403     ret = OMX_ErrorNone;
2404
2405 EXIT:
2406     FunctionOut();
2407
2408     return ret;
2409 }
2410
2411 OMX_ERRORTYPE Exynos_Mpeg4Dec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2412 {
2413     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
2414     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2415     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2416     EXYNOS_MPEG4DEC_HANDLE         *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2417     void                          *hMFCHandle = pMpeg4Dec->hMFCMpeg4Handle.hMFCHandle;
2418     EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2419     EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2420     ExynosVideoDecOps       *pDecOps    = pMpeg4Dec->hMFCMpeg4Handle.pDecOps;
2421     ExynosVideoDecBufferOps *pOutbufOps = pMpeg4Dec->hMFCMpeg4Handle.pOutbufOps;
2422     ExynosVideoBuffer       *pVideoBuffer;
2423     ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2424     ExynosVideoGeometry *bufferGeometry;
2425     DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
2426     OMX_S32 indexTimestamp = 0;
2427     int plane;
2428
2429     FunctionIn();
2430
2431     if (pMpeg4Dec->bDestinationStart == OMX_FALSE) {
2432         ret = OMX_ErrorNone;
2433         goto EXIT;
2434     }
2435
2436     while (1) {
2437         pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle);
2438         if (pVideoBuffer == (ExynosVideoBuffer *)VIDEO_ERROR_DQBUF_EIO) {
2439             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "HW is not available");
2440             ret = OMX_ErrorHardware;
2441             goto EXIT;
2442         }
2443
2444         if (pVideoBuffer == NULL) {
2445             ret = OMX_ErrorNone;
2446             goto EXIT;
2447         }
2448         displayStatus = pVideoBuffer->displayStatus;
2449         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
2450
2451         if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
2452             (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
2453             (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2454             (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2455             (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2456             if (pVideoBuffer != NULL) {
2457                 ret = OMX_ErrorNone;
2458                 break;
2459             } else {
2460                 ret = OMX_ErrorUndefined;
2461                 break;
2462             }
2463         }
2464     }
2465
2466     if (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) {
2467         if (pVideoDec->bDRCProcessing != OMX_TRUE) {
2468             pExynosOutputPort->exceptionFlag = NEED_PORT_FLUSH;
2469             pVideoDec->bDRCProcessing = OMX_TRUE;
2470             Mpeg4CodecCheckResolutionChange(pOMXComponent);
2471             pVideoDec->csc_set_format = OMX_FALSE;
2472         }
2473         ret = OMX_ErrorNone;
2474         goto EXIT;
2475     }
2476
2477     pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp++;
2478     pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
2479
2480     pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
2481     for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
2482         pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2483         pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2484         pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
2485         pDstOutputData->dataLen +=  pVideoBuffer->planes[plane].dataSize;
2486     }
2487     pDstOutputData->usedDataLen = 0;
2488     pDstOutputData->pPrivate = pVideoBuffer;
2489     /* For Share Buffer */
2490     pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2491
2492     pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
2493     bufferGeometry = &pMpeg4Dec->hMFCMpeg4Handle.codecOutbufConf;
2494     pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
2495     pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
2496     switch (bufferGeometry->eColorFormat) {
2497     case VIDEO_COLORFORMAT_NV12:
2498 #ifdef SLP_PLATFORM /* NV12T fd */
2499         pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
2500 #else
2501         pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2502 #endif
2503         break;
2504     case VIDEO_COLORFORMAT_NV12_TILED:
2505     default:
2506         pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
2507         break;
2508     }
2509
2510     indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
2511     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
2512     if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2513         if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
2514             (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
2515             pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2516             pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2517             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
2518         } else {
2519             pDstOutputData->timeStamp = 0x00;
2520             pDstOutputData->nFlags = 0x00;
2521         }
2522     } else {
2523         /* For timestamp correction. if mfc support frametype detect */
2524         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
2525 //#ifdef NEED_TIMESTAMP_REORDER
2526         if (pMpeg4Dec->hMFCMpeg4Handle.bPackedPB == OMX_TRUE ||
2527             pVideoDec->bNeedTimestampReorder == OMX_TRUE) { /* SLP_PLATFORM */
2528             if ((pVideoBuffer->frameType == VIDEO_FRAME_I)) {
2529                 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2530                 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2531                 pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp = indexTimestamp;
2532             } else {
2533                 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2534                 pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg4Dec->hMFCMpeg4Handle.outputIndexTimestamp];
2535             }
2536         } else {
2537 //#else
2538             pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2539             pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2540         }
2541 //#endif
2542         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
2543     }
2544
2545     if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2546         (displayStatus == VIDEO_FRAME_STATUS_DECODING_FINISHED) ||
2547         ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2548         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
2549         pDstOutputData->remainDataLen = 0;
2550     } else {
2551         pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
2552     }
2553
2554     ret = OMX_ErrorNone;
2555
2556 EXIT:
2557     FunctionOut();
2558
2559     return ret;
2560 }
2561
2562 OMX_ERRORTYPE Exynos_Mpeg4Dec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2563 {
2564     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2565     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2566     EXYNOS_MPEG4DEC_HANDLE    *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2567     EXYNOS_OMX_BASEPORT      *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2568
2569     FunctionIn();
2570
2571     if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2572         ret = OMX_ErrorNone;
2573         goto EXIT;
2574     }
2575     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2576         ret = OMX_ErrorNone;
2577         goto EXIT;
2578     }
2579
2580     ret = Exynos_Mpeg4Dec_SrcIn(pOMXComponent, pSrcInputData);
2581 if ((ret != OMX_ErrorNone) &&
2582         (ret != OMX_ErrorInputDataDecodeYet) &&
2583         (ret != OMX_ErrorCorruptedFrame)) {
2584         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2585                                                 pExynosComponent->callbackData,
2586                                                 OMX_EventError, ret, 0, NULL);
2587     }
2588
2589 EXIT:
2590     FunctionOut();
2591
2592     return ret;
2593 }
2594
2595 OMX_ERRORTYPE Exynos_Mpeg4Dec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2596 {
2597     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2598     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2599     EXYNOS_MPEG4DEC_HANDLE   *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2600     EXYNOS_OMX_BASEPORT     *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2601
2602     FunctionIn();
2603
2604     if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2605         ret = OMX_ErrorNone;
2606         goto EXIT;
2607     }
2608
2609     if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2610         if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2611             ret = OMX_ErrorNone;
2612             goto EXIT;
2613         }
2614     }
2615     if ((pMpeg4Dec->bSourceStart == OMX_FALSE) &&
2616        (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2617         Exynos_OSAL_SignalWait(pMpeg4Dec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2618         Exynos_OSAL_SignalReset(pMpeg4Dec->hSourceStartEvent);
2619     }
2620
2621     ret = Exynos_Mpeg4Dec_SrcOut(pOMXComponent, pSrcOutputData);
2622     if ((ret != OMX_ErrorNone) &&
2623         (pExynosComponent->currentState == OMX_StateExecuting)) {
2624         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2625                                                 pExynosComponent->callbackData,
2626                                                 OMX_EventError, ret, 0, NULL);
2627     }
2628
2629 EXIT:
2630     FunctionOut();
2631
2632     return ret;
2633 }
2634
2635 OMX_ERRORTYPE Exynos_Mpeg4Dec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2636 {
2637     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2638     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2639     EXYNOS_MPEG4DEC_HANDLE    *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2640     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2641
2642     FunctionIn();
2643
2644     if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2645         ret = OMX_ErrorNone;
2646         goto EXIT;
2647     }
2648     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2649         ret = OMX_ErrorNone;
2650         goto EXIT;
2651     }
2652     if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2653         if ((pMpeg4Dec->bDestinationStart == OMX_FALSE) &&
2654            (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2655             Exynos_OSAL_SignalWait(pMpeg4Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2656             Exynos_OSAL_SignalReset(pMpeg4Dec->hDestinationStartEvent);
2657         }
2658     }
2659     if (pMpeg4Dec->hMFCMpeg4Handle.bConfiguredMFCDst == OMX_TRUE) {
2660         ret = Exynos_Mpeg4Dec_DstIn(pOMXComponent, pDstInputData);
2661         if (ret != OMX_ErrorNone) {
2662             pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2663                                                 pExynosComponent->callbackData,
2664                                                 OMX_EventError, ret, 0, NULL);
2665         }
2666     }
2667
2668 EXIT:
2669     FunctionOut();
2670
2671     return ret;
2672 }
2673
2674 OMX_ERRORTYPE Exynos_Mpeg4Dec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2675 {
2676     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2677     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2678     EXYNOS_MPEG4DEC_HANDLE   *pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2679     EXYNOS_OMX_BASEPORT     *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2680
2681     FunctionIn();
2682
2683     if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2684         ret = OMX_ErrorNone;
2685         goto EXIT;
2686     }
2687     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2688         ret = OMX_ErrorNone;
2689         goto EXIT;
2690     }
2691
2692     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2693         if ((pMpeg4Dec->bDestinationStart == OMX_FALSE) &&
2694             (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2695             Exynos_OSAL_SignalWait(pMpeg4Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2696             Exynos_OSAL_SignalReset(pMpeg4Dec->hDestinationStartEvent);
2697         }
2698     }
2699     ret = Exynos_Mpeg4Dec_DstOut(pOMXComponent, pDstOutputData);
2700     if ((ret != OMX_ErrorNone) &&
2701         (pExynosComponent->currentState == OMX_StateExecuting)) {
2702         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2703                                                 pExynosComponent->callbackData,
2704                                                 OMX_EventError, ret, 0, NULL);
2705     }
2706
2707 EXIT:
2708     FunctionOut();
2709
2710     return ret;
2711 }
2712
2713 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(OMX_HANDLETYPE hComponent, OMX_STRING componentName)
2714 {
2715     OMX_ERRORTYPE                  ret              = OMX_ErrorNone;
2716     OMX_COMPONENTTYPE             *pOMXComponent    = NULL;
2717     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = NULL;
2718     EXYNOS_OMX_BASEPORT           *pExynosPort      = NULL;
2719     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec        = NULL;
2720     EXYNOS_MPEG4DEC_HANDLE        *pMpeg4Dec        = NULL;
2721     int i = 0;
2722     OMX_S32 codecType = -1;
2723
2724     FunctionIn();
2725
2726     if ((hComponent == NULL) || (componentName == NULL)) {
2727         ret = OMX_ErrorBadParameter;
2728         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2729         goto EXIT;
2730     }
2731     if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_MPEG4_DEC, componentName) == 0) {
2732         codecType = CODEC_TYPE_MPEG4;
2733     } else if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H263_DEC, componentName) == 0) {
2734         codecType = CODEC_TYPE_H263;
2735     } else {
2736         ret = OMX_ErrorBadParameter;
2737         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2738         goto EXIT;
2739     }
2740
2741     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2742     ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
2743     if (ret != OMX_ErrorNone) {
2744         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2745         goto EXIT;
2746     }
2747     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2748     pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
2749
2750     pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2751     if (pExynosComponent->componentName == NULL) {
2752         Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2753         ret = OMX_ErrorInsufficientResources;
2754         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2755         goto EXIT;
2756     }
2757     Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2758
2759     pMpeg4Dec = Exynos_OSAL_Malloc(sizeof(EXYNOS_MPEG4DEC_HANDLE));
2760     if (pMpeg4Dec == NULL) {
2761         Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2762         ret = OMX_ErrorInsufficientResources;
2763         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2764         goto EXIT;
2765     }
2766     Exynos_OSAL_Memset(pMpeg4Dec, 0, sizeof(EXYNOS_MPEG4DEC_HANDLE));
2767     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2768     pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pMpeg4Dec;
2769     pMpeg4Dec->hMFCMpeg4Handle.codecType = codecType;
2770
2771     if (codecType == CODEC_TYPE_MPEG4)
2772         Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_MPEG4_DEC);
2773     else
2774         Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H263_DEC);
2775
2776     /* In case of BUFFER_COPY mode
2777             bShareableBuf = TRUE means MemoryType is V4L2_MEMORY_USERPTR
2778             bShareableBuf = FALSE means MemoryType is V4L2_MEMORY_MMAP
2779          In case of BUFFER_SHARE
2780             bShareableBuf should be TRUE, FALSE is ignored
2781     */
2782     pMpeg4Dec->hMFCMpeg4Handle.bShareableBuf = OMX_FALSE;
2783     pMpeg4Dec->hMFCMpeg4Handle.bPackedPB = OMX_FALSE;
2784
2785     /* Set componentVersion */
2786     pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2787     pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2788     pExynosComponent->componentVersion.s.nRevision     = REVISION_NUMBER;
2789     pExynosComponent->componentVersion.s.nStep         = STEP_NUMBER;
2790     /* Set specVersion */
2791     pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2792     pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2793     pExynosComponent->specVersion.s.nRevision     = REVISION_NUMBER;
2794     pExynosComponent->specVersion.s.nStep         = STEP_NUMBER;
2795
2796     /* Input port */
2797     pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2798     pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2799     pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2800     pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2801     pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2802     pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2803     if (codecType == CODEC_TYPE_MPEG4) {
2804         pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
2805         Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2806         Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/mpeg4");
2807     } else {
2808         pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
2809         Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2810         Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/h263");
2811     }
2812     pExynosPort->portDefinition.format.video.pNativeRender = 0;
2813     pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2814     pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2815     pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2816     pExynosPort->bufferProcessType = BUFFER_COPY;
2817     pExynosPort->portWayType = WAY2_PORT;
2818
2819     /* Output port */
2820     pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2821     pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2822     pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2823     pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2824     pExynosPort->portDefinition.format.video.nSliceHeight = 0;
2825     pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2826     pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2827     Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2828     Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2829     pExynosPort->portDefinition.format.video.pNativeRender = 0;
2830     pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
2831 #ifdef SLP_PLATFORM
2832     pExynosPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd;
2833     pExynosPort->bufferProcessType = BUFFER_SHARE;
2834 #else
2835     pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
2836     pExynosPort->bufferProcessType = BUFFER_COPY;
2837 #endif
2838     pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2839     pExynosPort->portWayType = WAY2_PORT;
2840
2841     if (codecType == CODEC_TYPE_MPEG4) {
2842         for(i = 0; i < ALL_PORT_NUM; i++) {
2843             INIT_SET_SIZE_VERSION(&pMpeg4Dec->mpeg4Component[i], OMX_VIDEO_PARAM_MPEG4TYPE);
2844             pMpeg4Dec->mpeg4Component[i].nPortIndex = i;
2845             pMpeg4Dec->mpeg4Component[i].eProfile   = OMX_VIDEO_MPEG4ProfileSimple;
2846             pMpeg4Dec->mpeg4Component[i].eLevel     = OMX_VIDEO_MPEG4Level3;
2847         }
2848     } else {
2849         for(i = 0; i < ALL_PORT_NUM; i++) {
2850             INIT_SET_SIZE_VERSION(&pMpeg4Dec->h263Component[i], OMX_VIDEO_PARAM_H263TYPE);
2851             pMpeg4Dec->h263Component[i].nPortIndex = i;
2852             pMpeg4Dec->h263Component[i].eProfile   = OMX_VIDEO_H263ProfileBaseline | OMX_VIDEO_H263ProfileISWV2;
2853             pMpeg4Dec->h263Component[i].eLevel     = OMX_VIDEO_H263Level45;
2854         }
2855     }
2856
2857     pOMXComponent->GetParameter      = &Exynos_Mpeg4Dec_GetParameter;
2858     pOMXComponent->SetParameter      = &Exynos_Mpeg4Dec_SetParameter;
2859     pOMXComponent->GetConfig         = &Exynos_Mpeg4Dec_GetConfig;
2860     pOMXComponent->SetConfig         = &Exynos_Mpeg4Dec_SetConfig;
2861     pOMXComponent->GetExtensionIndex = &Exynos_Mpeg4Dec_GetExtensionIndex;
2862     pOMXComponent->ComponentRoleEnum = &Exynos_Mpeg4Dec_ComponentRoleEnum;
2863     pOMXComponent->ComponentDeInit   = &Exynos_OMX_ComponentDeinit;
2864
2865     pExynosComponent->exynos_codec_componentInit      = &Exynos_Mpeg4Dec_Init;
2866     pExynosComponent->exynos_codec_componentTerminate = &Exynos_Mpeg4Dec_Terminate;
2867
2868     pVideoDec->exynos_codec_srcInputProcess  = &Exynos_Mpeg4Dec_srcInputBufferProcess;
2869     pVideoDec->exynos_codec_srcOutputProcess = &Exynos_Mpeg4Dec_srcOutputBufferProcess;
2870     pVideoDec->exynos_codec_dstInputProcess  = &Exynos_Mpeg4Dec_dstInputBufferProcess;
2871     pVideoDec->exynos_codec_dstOutputProcess = &Exynos_Mpeg4Dec_dstOutputBufferProcess;
2872
2873     pVideoDec->exynos_codec_start            = &Mpeg4CodecStart;
2874     pVideoDec->exynos_codec_stop             = &Mpeg4CodecStop;
2875     pVideoDec->exynos_codec_bufferProcessRun = &Mpeg4CodecOutputBufferProcessRun;
2876     pVideoDec->exynos_codec_enqueueAllBuffer = &Mpeg4CodecEnQueueAllBuffer;
2877     pVideoDec->exynos_codec_resetupAllElement = &Mpeg4CodecResetupAllElement;
2878
2879     if (codecType == CODEC_TYPE_MPEG4)
2880         pVideoDec->exynos_checkInputFrame = &Check_Mpeg4_Frame;
2881     else
2882         pVideoDec->exynos_checkInputFrame = &Check_H263_Frame;
2883
2884     pVideoDec->exynos_codec_getCodecInputPrivateData  = &GetCodecInputPrivateData;
2885     pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2886
2887 #ifndef SLP_PLATFORM /* do not use ion */
2888     pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2889     if (pVideoDec->hSharedMemory == NULL) {
2890         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2891         Exynos_OSAL_Free(pMpeg4Dec);
2892         pMpeg4Dec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2893         Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2894         ret = OMX_ErrorInsufficientResources;
2895         goto EXIT;
2896     }
2897 #endif
2898     pExynosComponent->currentState = OMX_StateLoaded;
2899
2900     ret = OMX_ErrorNone;
2901
2902 EXIT:
2903     FunctionOut();
2904
2905     return ret;
2906 }
2907
2908 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
2909 {
2910     OMX_ERRORTYPE            ret = OMX_ErrorNone;
2911     OMX_COMPONENTTYPE       *pOMXComponent = NULL;
2912     EXYNOS_OMX_BASECOMPONENT   *pExynosComponent = NULL;
2913     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2914     EXYNOS_MPEG4DEC_HANDLE      *pMpeg4Dec = NULL;
2915
2916     FunctionIn();
2917
2918     if (hComponent == NULL) {
2919         ret = OMX_ErrorBadParameter;
2920         goto EXIT;
2921     }
2922     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2923     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2924     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2925 #ifndef SLP_PLATFORM /* do not use ion */
2926     Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2927 #endif
2928     Exynos_OSAL_Free(pExynosComponent->componentName);
2929     pExynosComponent->componentName = NULL;
2930
2931     pMpeg4Dec = (EXYNOS_MPEG4DEC_HANDLE *)pVideoDec->hCodecHandle;
2932     if (pMpeg4Dec != NULL) {
2933         Exynos_OSAL_Free(pMpeg4Dec);
2934         pMpeg4Dec = pVideoDec->hCodecHandle = NULL;
2935     }
2936
2937     ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2938     if (ret != OMX_ErrorNone) {
2939         goto EXIT;
2940     }
2941
2942     ret = OMX_ErrorNone;
2943
2944 EXIT:
2945     FunctionOut();
2946
2947     return ret;
2948 }