openmax/component/video/dec/mpeg2/Exynos_OMX_Mpeg2dec.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_Mpeg2dec.c
  20  * @brief
  21  * @author      Satish Kumar Reddy (palli.satish@samsung.com)
  22  * @version     2.0.0
  23  * @history
  24  *   2012.07.10 : Create
  25  */
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <mm_types.h>
  31
  32 #include "Exynos_OMX_Macros.h"
  33 #include "Exynos_OMX_Basecomponent.h"
  34 #include "Exynos_OMX_Baseport.h"
  35 #include "Exynos_OMX_Vdec.h"
  36 #include "Exynos_OSAL_ETC.h"
  37 #include "Exynos_OSAL_Semaphore.h"
  38 #include "Exynos_OSAL_Thread.h"
  39 #include "library_register.h"
  40 #include "Exynos_OMX_Mpeg2dec.h"
  41 #include "ExynosVideoApi.h"
  42 #include "Exynos_OSAL_SharedMemory.h"
  43 #include "Exynos_OSAL_Event.h"
  44 #include "Exynos_OMX_VdecControl.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_MPEG2_DEC"
  56 #define EXYNOS_LOG_OFF
  57 //#define EXYNOS_TRACE_ON
  58 #include "Exynos_OSAL_Log.h"
  59
  60 #define MPEG2_DEC_NUM_OF_EXTRA_BUFFERS 7
  61
  62 //#define FULL_FRAME_SEARCH /* Full frame search not support*/
  63
  64 static OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, void *pVirtAddr, OMX_U32 *dataSize)
  65 {
  66     return OMX_ErrorNone;
  67 }
  68
  69 static OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, OMX_PTR addr[], OMX_U32 size[])
  70 {
  71     OMX_ERRORTYPE       ret          = OMX_ErrorNone;
  72     ExynosVideoBuffer  *pCodecBuffer = NULL;
  73
  74     if (codecBuffer == NULL) {
  75         ret = OMX_ErrorBadParameter;
  76         goto EXIT;
  77     }
  78
  79     pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
  80
  81     if (addr != NULL) {
  82         addr[0] = pCodecBuffer->planes[0].addr;
  83         addr[1] = pCodecBuffer->planes[1].addr;
  84         addr[2] = pCodecBuffer->planes[2].addr;
  85     }
  86
  87     if (size != NULL) {
  88         size[0] = pCodecBuffer->planes[0].allocSize;
  89         size[1] = pCodecBuffer->planes[1].allocSize;
  90         size[2] = pCodecBuffer->planes[2].allocSize;
  91     }
  92
  93 EXIT:
  94     return ret;
  95 }
  96
  97 #ifndef TIZEN_FEATURE_E3250
  98 int Check_Mpeg2_Frame(
  99     OMX_U8   *pInputStream,
 100     int       buffSize,
 101     OMX_U32   flag,
 102     OMX_BOOL  bPreviousFrameEOF,
 103     OMX_BOOL *pbEndOfFrame)
 104 {
 105     FunctionIn();
 106
 107     *pbEndOfFrame = OMX_TRUE;
 108
 109     /* Frame  Start code*/
 110     if (pInputStream[0] != 0x00 || pInputStream[1] != 0x00 || pInputStream[2]!=0x01) {
 111         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mpeg2 Frame Start Code not Found");
 112         *pbEndOfFrame = OMX_FALSE;
 113     }
 114
 115     FunctionOut();
 116     return buffSize;
 117 }
 118 #endif
 119
 120 static OMX_BOOL Check_Mpeg2_StartCode(
 121     OMX_U8     *pInputStream,
 122     OMX_U32     streamSize)
 123 {
 124     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "streamSize: %d",streamSize);
 125
 126     if (streamSize < 3) {
 127         return OMX_FALSE;
 128     }
 129
 130     /* Frame  Start code*/
 131     if (pInputStream[0] != 0x00 || pInputStream[1] != 0x00 || pInputStream[2]!=0x01) {
 132         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mpeg2 Frame Start Code not Found");
 133         return OMX_FALSE;
 134     }
 135
 136     return OMX_TRUE;
 137 }
 138
 139 OMX_ERRORTYPE Mpeg2CodecOpen(EXYNOS_MPEG2DEC_HANDLE *pMpeg2Dec)
 140 {
 141     OMX_ERRORTYPE           ret = OMX_ErrorNone;
 142     ExynosVideoDecOps       *pDecOps    = NULL;
 143     ExynosVideoDecBufferOps *pInbufOps  = NULL;
 144     ExynosVideoDecBufferOps *pOutbufOps = NULL;
 145
 146     FunctionIn();
 147
 148     if (pMpeg2Dec == NULL) {
 149         ret = OMX_ErrorBadParameter;
 150         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
 151         goto EXIT;
 152     }
 153
 154     /* alloc ops structure */
 155     pDecOps    = (ExynosVideoDecOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecOps));
 156     pInbufOps  = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
 157     pOutbufOps = (ExynosVideoDecBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoDecBufferOps));
 158
 159     if ((pDecOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
 160         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate decoder ops buffer");
 161         ret = OMX_ErrorInsufficientResources;
 162         goto EXIT;
 163     }
 164
 165     pMpeg2Dec->hMFCMpeg2Handle.pDecOps    = pDecOps;
 166     pMpeg2Dec->hMFCMpeg2Handle.pInbufOps  = pInbufOps;
 167     pMpeg2Dec->hMFCMpeg2Handle.pOutbufOps = pOutbufOps;
 168
 169     /* function pointer mapping */
 170     pDecOps->nSize    = sizeof(ExynosVideoDecOps);
 171     pInbufOps->nSize  = sizeof(ExynosVideoDecBufferOps);
 172     pOutbufOps->nSize = sizeof(ExynosVideoDecBufferOps);
 173
 174     Exynos_Video_Register_Decoder(pDecOps, pInbufOps, pOutbufOps);
 175
 176     /* check mandatory functions for decoder ops */
 177     if ((pDecOps->Init == NULL) || (pDecOps->Finalize == NULL) ||
 178         (pDecOps->Get_ActualBufferCount == NULL) || (pDecOps->Set_FrameTag == NULL) ||
 179         (pDecOps->Get_FrameTag == NULL)) {
 180         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
 181         ret = OMX_ErrorInsufficientResources;
 182         goto EXIT;
 183     }
 184
 185     /* check mandatory functions for buffer ops */
 186     if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
 187         (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
 188         (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
 189         (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
 190         (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
 191         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
 192         ret = OMX_ErrorInsufficientResources;
 193         goto EXIT;
 194     }
 195
 196     /* alloc context, open, querycap */
 197 #ifdef USE_DMA_BUF
 198     pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.pDecOps->Init(V4L2_MEMORY_DMABUF);
 199 #else
 200     pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.pDecOps->Init(V4L2_MEMORY_USERPTR);
 201 #endif
 202     if (pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle == NULL) {
 203         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
 204         ret = OMX_ErrorInsufficientResources;
 205         goto EXIT;
 206     }
 207
 208     ret = OMX_ErrorNone;
 209
 210 EXIT:
 211     if (ret != OMX_ErrorNone) {
 212         if (pDecOps != NULL) {
 213             Exynos_OSAL_Free(pDecOps);
 214             pMpeg2Dec->hMFCMpeg2Handle.pDecOps = NULL;
 215         }
 216         if (pInbufOps != NULL) {
 217             Exynos_OSAL_Free(pInbufOps);
 218             pMpeg2Dec->hMFCMpeg2Handle.pInbufOps = NULL;
 219         }
 220         if (pOutbufOps != NULL) {
 221             Exynos_OSAL_Free(pOutbufOps);
 222             pMpeg2Dec->hMFCMpeg2Handle.pOutbufOps = NULL;
 223         }
 224     }
 225
 226     FunctionOut();
 227
 228     return ret;
 229 }
 230
 231 OMX_ERRORTYPE Mpeg2CodecClose(EXYNOS_MPEG2DEC_HANDLE *pMpeg2Dec)
 232 {
 233     OMX_ERRORTYPE            ret = OMX_ErrorNone;
 234     void                    *hMFCHandle = NULL;
 235     ExynosVideoDecOps       *pDecOps    = NULL;
 236     ExynosVideoDecBufferOps *pInbufOps  = NULL;
 237     ExynosVideoDecBufferOps *pOutbufOps = NULL;
 238
 239     FunctionIn();
 240
 241     if (pMpeg2Dec == NULL) {
 242         ret = OMX_ErrorBadParameter;
 243         goto EXIT;
 244     }
 245
 246     hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle;
 247     pDecOps    = pMpeg2Dec->hMFCMpeg2Handle.pDecOps;
 248     pInbufOps  = pMpeg2Dec->hMFCMpeg2Handle.pInbufOps;
 249     pOutbufOps = pMpeg2Dec->hMFCMpeg2Handle.pOutbufOps;
 250
 251     if (hMFCHandle != NULL) {
 252         pDecOps->Finalize(hMFCHandle);
 253         pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle = NULL;
 254     }
 255     if (pOutbufOps != NULL) {
 256         Exynos_OSAL_Free(pOutbufOps);
 257         pMpeg2Dec->hMFCMpeg2Handle.pOutbufOps = NULL;
 258     }
 259     if (pInbufOps != NULL) {
 260         Exynos_OSAL_Free(pInbufOps);
 261         pMpeg2Dec->hMFCMpeg2Handle.pInbufOps = NULL;
 262     }
 263     if (pDecOps != NULL) {
 264         Exynos_OSAL_Free(pDecOps);
 265         pMpeg2Dec->hMFCMpeg2Handle.pDecOps = NULL;
 266     }
 267
 268     ret = OMX_ErrorNone;
 269
 270 EXIT:
 271     FunctionOut();
 272
 273     return ret;
 274 }
 275
 276 OMX_ERRORTYPE Mpeg2CodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 277 {
 278     OMX_ERRORTYPE            ret = OMX_ErrorNone;
 279     void                    *hMFCHandle = NULL;
 280     ExynosVideoDecBufferOps *pInbufOps  = NULL;
 281     ExynosVideoDecBufferOps *pOutbufOps = NULL;
 282     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
 283     EXYNOS_MPEG2DEC_HANDLE   *pMpeg2Dec = NULL;
 284
 285     FunctionIn();
 286
 287     if (pOMXComponent == NULL) {
 288         ret = OMX_ErrorBadParameter;
 289         goto EXIT;
 290     }
 291
 292     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
 293     if (pVideoDec == NULL) {
 294         ret = OMX_ErrorBadParameter;
 295         goto EXIT;
 296     }
 297
 298     pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)pVideoDec->hCodecHandle;
 299     if (pMpeg2Dec == NULL) {
 300         ret = OMX_ErrorBadParameter;
 301         goto EXIT;
 302     }
 303
 304     hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle;
 305     pInbufOps  = pMpeg2Dec->hMFCMpeg2Handle.pInbufOps;
 306     pOutbufOps = pMpeg2Dec->hMFCMpeg2Handle.pOutbufOps;
 307
 308     if (nPortIndex == INPUT_PORT_INDEX)
 309         pInbufOps->Run(hMFCHandle);
 310     else if (nPortIndex == OUTPUT_PORT_INDEX)
 311         pOutbufOps->Run(hMFCHandle);
 312
 313     ret = OMX_ErrorNone;
 314
 315 EXIT:
 316     FunctionOut();
 317
 318     return ret;
 319 }
 320
 321 OMX_ERRORTYPE Mpeg2CodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 322 {
 323     OMX_ERRORTYPE            ret = OMX_ErrorNone;
 324     void                    *hMFCHandle = NULL;
 325     ExynosVideoDecBufferOps *pInbufOps  = NULL;
 326     ExynosVideoDecBufferOps *pOutbufOps = NULL;
 327     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
 328     EXYNOS_MPEG2DEC_HANDLE   *pMpeg2Dec = NULL;
 329
 330     FunctionIn();
 331
 332     if (pOMXComponent == NULL) {
 333         ret = OMX_ErrorBadParameter;
 334         goto EXIT;
 335     }
 336
 337     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
 338     if (pVideoDec == NULL) {
 339         ret = OMX_ErrorBadParameter;
 340         goto EXIT;
 341     }
 342     pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)pVideoDec->hCodecHandle;
 343     if (pMpeg2Dec == NULL) {
 344         ret = OMX_ErrorBadParameter;
 345         goto EXIT;
 346     }
 347
 348     hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle;
 349     pInbufOps  = pMpeg2Dec->hMFCMpeg2Handle.pInbufOps;
 350     pOutbufOps = pMpeg2Dec->hMFCMpeg2Handle.pOutbufOps;
 351
 352     if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
 353         pInbufOps->Stop(hMFCHandle);
 354     else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
 355         pOutbufOps->Stop(hMFCHandle);
 356
 357     ret = OMX_ErrorNone;
 358
 359 EXIT:
 360     FunctionOut();
 361
 362     return ret;
 363 }
 364
 365 OMX_ERRORTYPE Mpeg2CodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 366 {
 367     OMX_ERRORTYPE            ret = OMX_ErrorNone;
 368     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
 369     EXYNOS_MPEG2DEC_HANDLE   *pMpeg2Dec = NULL;
 370
 371     FunctionIn();
 372
 373     if (pOMXComponent == NULL) {
 374         ret = OMX_ErrorBadParameter;
 375         goto EXIT;
 376     }
 377
 378     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
 379     if (pVideoDec == NULL) {
 380         ret = OMX_ErrorBadParameter;
 381         goto EXIT;
 382     }
 383     pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)pVideoDec->hCodecHandle;
 384     if (pMpeg2Dec == NULL) {
 385         ret = OMX_ErrorBadParameter;
 386         goto EXIT;
 387     }
 388
 389     if (nPortIndex == INPUT_PORT_INDEX) {
 390         if (pMpeg2Dec->bSourceStart == OMX_FALSE) {
 391             Exynos_OSAL_SignalSet(pMpeg2Dec->hSourceStartEvent);
 392             Exynos_OSAL_SleepMillisec(0);
 393         }
 394     }
 395
 396     if (nPortIndex == OUTPUT_PORT_INDEX) {
 397         if (pMpeg2Dec->bDestinationStart == OMX_FALSE) {
 398             Exynos_OSAL_SignalSet(pMpeg2Dec->hDestinationStartEvent);
 399             Exynos_OSAL_SleepMillisec(0);
 400         }
 401     }
 402
 403     ret = OMX_ErrorNone;
 404
 405 EXIT:
 406     FunctionOut();
 407
 408     return ret;
 409 }
 410
 411 OMX_ERRORTYPE Mpeg2CodecEnQueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 412 {
 413     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 414     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 415     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 416     EXYNOS_MPEG2DEC_HANDLE         *pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 417     void                          *hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle;
 418     int i, nOutbufs;
 419
 420     ExynosVideoDecOps       *pDecOps    = pMpeg2Dec->hMFCMpeg2Handle.pDecOps;
 421     ExynosVideoDecBufferOps *pInbufOps  = pMpeg2Dec->hMFCMpeg2Handle.pInbufOps;
 422     ExynosVideoDecBufferOps *pOutbufOps = pMpeg2Dec->hMFCMpeg2Handle.pOutbufOps;
 423
 424     FunctionIn();
 425
 426     if ((nPortIndex == INPUT_PORT_INDEX) &&
 427         (pMpeg2Dec->bSourceStart == OMX_TRUE)) {
 428         Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
 429
 430         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
 431             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
 432             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]);
 433
 434             Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
 435         }
 436
 437         pInbufOps->Clear_Queue(hMFCHandle);
 438     } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
 439                (pMpeg2Dec->bDestinationStart == OMX_TRUE)) {
 440         ExynosVideoBuffer *pBuffer = NULL;
 441
 442         Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
 443
 444         nOutbufs = pDecOps->Get_ActualBufferCount(hMFCHandle);
 445         nOutbufs += EXTRA_DPB_NUM;
 446         for (i = 0; i < nOutbufs; i++) {
 447             pOutbufOps->Get_Buffer(hMFCHandle, i, &pBuffer);
 448             Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR)pBuffer);
 449         }
 450         pOutbufOps->Clear_Queue(hMFCHandle);
 451     } else {
 452         ret = OMX_ErrorBadParameter;
 453         goto EXIT;
 454     }
 455
 456 EXIT:
 457     FunctionOut();
 458
 459     return ret;
 460 }
 461
 462 OMX_ERRORTYPE Mpeg2CodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
 463 {
 464     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 465     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 466     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 467     EXYNOS_MPEG2DEC_HANDLE        *pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 468     void                          *hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle;
 469     EXYNOS_OMX_BASEPORT           *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 470     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 471     OMX_U32                        oneFrameSize = pSrcInputData->dataLen;
 472
 473     ExynosVideoDecOps       *pDecOps    = pMpeg2Dec->hMFCMpeg2Handle.pDecOps;
 474     ExynosVideoDecBufferOps *pInbufOps  = pMpeg2Dec->hMFCMpeg2Handle.pInbufOps;
 475     ExynosVideoDecBufferOps *pOutbufOps = pMpeg2Dec->hMFCMpeg2Handle.pOutbufOps;
 476     ExynosVideoGeometry      bufferConf;
 477     OMX_U32                  inputBufferNumber = 0;
 478     int i;
 479
 480     FunctionIn();
 481
 482     if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
 483         OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
 484         OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
 485         if (OMXBuffer == NULL) {
 486             ret = OMX_ErrorUndefined;
 487             goto EXIT;
 488         }
 489
 490         OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
 491         OMXBuffer->nFlags = pSrcInputData->nFlags;
 492         Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
 493
 494         ret = OMX_ErrorNone;
 495         goto EXIT;
 496     }
 497
 498     if (pVideoDec->bThumbnailMode == OMX_TRUE)
 499         pDecOps->Set_DisplayDelay(hMFCHandle, 0);
 500
 501     /* input buffer info */
 502     Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
 503     bufferConf.eCompressionFormat = VIDEO_CODING_MPEG2;
 504     pInbufOps->Set_Shareable(hMFCHandle);
 505     if (pExynosInputPort->bufferProcessType == BUFFER_SHARE) {
 506         bufferConf.nSizeImage = pExynosInputPort->portDefinition.format.video.nFrameWidth
 507                                 * pExynosInputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
 508         inputBufferNumber = MAX_VIDEO_INPUTBUFFER_NUM;
 509     } else if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
 510         bufferConf.nSizeImage = DEFAULT_MFC_INPUT_BUFFER_SIZE;
 511         inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
 512     }
 513
 514     /* should be done before prepare input buffer */
 515     if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
 516         ret = OMX_ErrorInsufficientResources;
 517         goto EXIT;
 518     }
 519
 520     /* set input buffer geometry */
 521     if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
 522         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
 523         ret = OMX_ErrorInsufficientResources;
 524         goto EXIT;
 525     }
 526
 527     /* setup input buffer */
 528     if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
 529         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
 530         ret = OMX_ErrorInsufficientResources;
 531         goto EXIT;
 532     }
 533
 534     if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
 535         /* Register input buffer */
 536         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
 537             ExynosVideoPlane plane;
 538             plane.addr = pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0];
 539             plane.allocSize = pVideoDec->pMFCDecInputBuffer[i]->bufferSize[0];
 540             plane.fd = pVideoDec->pMFCDecInputBuffer[i]->fd[0];
 541             if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
 542                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "BUFFER_COPY Failed to Register input buffer");
 543                 ret = OMX_ErrorInsufficientResources;
 544                 goto EXIT;
 545             }
 546         }
 547     } else if (pExynosInputPort->bufferProcessType == BUFFER_SHARE) {
 548         /* Register input buffer */
 549         for (i = 0; i < pExynosInputPort->portDefinition.nBufferCountActual; i++) {
 550             ExynosVideoPlane plane;
 551             plane.addr = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
 552             plane.allocSize = pExynosInputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
 553             plane.fd = pExynosInputPort->extendBufferHeader[i].buf_fd[0];
 554             if (pInbufOps->Register(hMFCHandle, &plane, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
 555                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "BUFFER_SHARE Failed to Register input buffer");
 556                 ret = OMX_ErrorInsufficientResources;
 557                 goto EXIT;
 558             }
 559         }
 560     }
 561
 562     /* set output geometry */
 563     Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
 564     pMpeg2Dec->hMFCMpeg2Handle.MFCOutputColorType = bufferConf.eColorFormat = VIDEO_COLORFORMAT_NV12_TILED;
 565     if (pOutbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
 566         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
 567         ret = OMX_ErrorInsufficientResources;
 568         goto EXIT;
 569     }
 570
 571     /* input buffer enqueue for header parsing */
 572     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d", oneFrameSize);
 573     if (pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
 574                         (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader) != VIDEO_ERROR_NONE) {
 575         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to enqueue input buffer for header parsing");
 576 //        ret = OMX_ErrorInsufficientResources;
 577         ret = (OMX_ERRORTYPE)OMX_ErrorCodecInit;
 578         goto EXIT;
 579     }
 580
 581     /* start header parsing */
 582     if (pInbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
 583         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run input buffer for header parsing");
 584         ret = OMX_ErrorCodecInit;
 585         goto EXIT;
 586     }
 587
 588     /* get geometry for output */
 589     Exynos_OSAL_Memset(&pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf, 0, sizeof(ExynosVideoGeometry));
 590     if (pOutbufOps->Get_Geometry(hMFCHandle, &pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf) != VIDEO_ERROR_NONE) {
 591         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get geometry for parsed header info");
 592         ret = OMX_ErrorInsufficientResources;
 593         goto EXIT;
 594     }
 595
 596     /* get dpb count */
 597     pMpeg2Dec->hMFCMpeg2Handle.maxDPBNum = pDecOps->Get_ActualBufferCount(hMFCHandle);
 598     if (pVideoDec->bThumbnailMode == OMX_FALSE)
 599         pMpeg2Dec->hMFCMpeg2Handle.maxDPBNum += EXTRA_DPB_NUM;
 600     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Mpeg2CodecSetup nOutbufs: %d", pMpeg2Dec->hMFCMpeg2Handle.maxDPBNum);
 601
 602     pMpeg2Dec->hMFCMpeg2Handle.bConfiguredMFCSrc = OMX_TRUE;
 603
 604     if ((pExynosOutputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
 605         if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameWidth) ||
 606             (pExynosInputPort->portDefinition.format.video.nFrameHeight != pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameHeight)) {
 607             pExynosInputPort->portDefinition.format.video.nFrameWidth = pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameWidth;
 608             pExynosInputPort->portDefinition.format.video.nFrameHeight = pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameHeight;
 609             pExynosInputPort->portDefinition.format.video.nStride = ((pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
 610             pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
 611
 612             Exynos_UpdateFrameSize(pOMXComponent);
 613 /* FIXME: OMX_EventPortSettingsChanged. do not set NEED_PORT_DISABLE in SLP platform now */
 614 /*            pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;*/
 615
 616             /** Send Port Settings changed call back **/
 617             (*(pExynosComponent->pCallbacks->EventHandler))
 618                 (pOMXComponent,
 619                  pExynosComponent->callbackData,
 620                  OMX_EventPortSettingsChanged, /* The command was completed */
 621                  OMX_DirOutput, /* This is the port index */
 622                  0,
 623                  NULL);
 624         }
 625     } else if (pExynosOutputPort->bufferProcessType == BUFFER_SHARE) {
 626         if ((pExynosInputPort->portDefinition.format.video.nFrameWidth != pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameWidth) ||
 627             (pExynosInputPort->portDefinition.format.video.nFrameHeight != pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameHeight) ||
 628             (pExynosOutputPort->portDefinition.nBufferCountActual != pMpeg2Dec->hMFCMpeg2Handle.maxDPBNum)) {
 629             pExynosInputPort->portDefinition.format.video.nFrameWidth = pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameWidth;
 630             pExynosInputPort->portDefinition.format.video.nFrameHeight = pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameHeight;
 631             pExynosInputPort->portDefinition.format.video.nStride = ((pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameWidth + 15) & (~15));
 632             pExynosInputPort->portDefinition.format.video.nSliceHeight = ((pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameHeight + 15) & (~15));
 633
 634             pExynosOutputPort->portDefinition.nBufferCountActual = pMpeg2Dec->hMFCMpeg2Handle.maxDPBNum - 4;
 635             pExynosOutputPort->portDefinition.nBufferCountMin = pMpeg2Dec->hMFCMpeg2Handle.maxDPBNum - 4;
 636
 637             Exynos_UpdateFrameSize(pOMXComponent);
 638             pExynosOutputPort->exceptionFlag = NEED_PORT_DISABLE;
 639
 640             /** Send Port Settings changed call back **/
 641             (*(pExynosComponent->pCallbacks->EventHandler))
 642                 (pOMXComponent,
 643                  pExynosComponent->callbackData,
 644                  OMX_EventPortSettingsChanged, /* The command was completed */
 645                  OMX_DirOutput, /* This is the port index */
 646                  0,
 647                  NULL);
 648         }
 649     }
 650     Exynos_OSAL_SleepMillisec(0);
 651     ret = OMX_ErrorInputDataDecodeYet;
 652     Mpeg2CodecStop(pOMXComponent, INPUT_PORT_INDEX);
 653
 654 EXIT:
 655     FunctionOut();
 656
 657     return ret;
 658 }
 659
 660 OMX_ERRORTYPE Mpeg2CodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
 661 {
 662     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 663     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 664     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
 665     EXYNOS_MPEG2DEC_HANDLE         *pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 666     void                          *hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle;
 667     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 668
 669     ExynosVideoDecBufferOps *pOutbufOps = pMpeg2Dec->hMFCMpeg2Handle.pOutbufOps;
 670
 671     int i, nOutbufs;
 672
 673     FunctionIn();
 674
 675     /* get dpb count */
 676     nOutbufs = pMpeg2Dec->hMFCMpeg2Handle.maxDPBNum;
 677
 678     if ((pExynosOutputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
 679         /* should be done before prepare output buffer */
 680         if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
 681             ret = OMX_ErrorInsufficientResources;
 682             goto EXIT;
 683         }
 684     }
 685
 686     pOutbufOps->Set_Shareable(hMFCHandle);
 687     if (pOutbufOps->Setup(hMFCHandle, nOutbufs) != VIDEO_ERROR_NONE) {
 688         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
 689         ret = OMX_ErrorInsufficientResources;
 690         goto EXIT;
 691     }
 692
 693     ExynosVideoPlane planes[MFC_OUTPUT_BUFFER_PLANE];
 694     OMX_U32 nAllocLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
 695     OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0, 0};
 696     int plane;
 697
 698     nAllocLen[0] = calc_plane(pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameWidth,
 699                         pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameHeight);
 700     nAllocLen[1] = calc_plane(pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameWidth,
 701                         pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf.nFrameHeight >> 1);
 702
 703     if ((pExynosOutputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
 704         /* Register output buffer */
 705         for (i = 0; i < nOutbufs; i++) {
 706             pVideoDec->pMFCDecOutputBuffer[i] = (CODEC_DEC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
 707             Exynos_OSAL_Memset(pVideoDec->pMFCDecOutputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
 708
 709             for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
 710                 pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane] =
 711                     (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, nAllocLen[plane], NORMAL_MEMORY);
 712                 if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane] == NULL) {
 713                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc output buffer");
 714                 ret = OMX_ErrorInsufficientResources;
 715                 goto EXIT;
 716             }
 717                 pVideoDec->pMFCDecOutputBuffer[i]->fd[plane] =
 718                     Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory,
 719                                                        pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane]);
 720                 pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[plane] = nAllocLen[plane];
 721
 722                 planes[plane].addr = pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane];
 723                 planes[plane].fd = pVideoDec->pMFCDecOutputBuffer[i]->fd[plane];
 724                 planes[plane].allocSize = pVideoDec->pMFCDecOutputBuffer[i]->bufferSize[plane];
 725             }
 726
 727             if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
 728                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
 729                 ret = OMX_ErrorInsufficientResources;
 730                 goto EXIT;
 731             }
 732             pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr,
 733                             (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
 734         }
 735     } else if (pExynosOutputPort->bufferProcessType == BUFFER_SHARE) {
 736         /* Register output buffer */
 737         /*************/
 738         /*    TBD    */
 739         /*************/
 740 #ifdef USE_PB
 741         if (pExynosOutputPort->bIsPBEnabled == OMX_TRUE) {
 742             for (i = 0; i < pExynosOutputPort->assignedBufferNum; i++) {
 743                 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
 744                     planes[plane].fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[plane];
 745                     planes[plane].addr = pExynosOutputPort->extendBufferHeader[i].pYUVBuf[plane];
 746                     planes[plane].tbm_bo = pExynosOutputPort->extendBufferHeader[i].tbm_bo[plane];
 747                     planes[plane].allocSize = nAllocLen[plane];
 748                 }
 749
 750                 if (pOutbufOps->Register(hMFCHandle, planes, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
 751                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
 752                     ret = OMX_ErrorInsufficientResources;
 753                     goto EXIT;
 754                 }
 755                 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pExynosOutputPort->extendBufferHeader[i].pYUVBuf,
 756                               (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
 757             }
 758         } else {
 759             ret = OMX_ErrorNotImplemented;
 760             goto EXIT;
 761         }
 762 #else
 763         ret = OMX_ErrorNotImplemented;
 764         goto EXIT;
 765 #endif
 766     }
 767
 768     if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
 769         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
 770         ret = OMX_ErrorInsufficientResources;
 771         goto EXIT;
 772     }
 773
 774     if (pExynosOutputPort->bufferProcessType == BUFFER_SHARE) {
 775         Mpeg2CodecStop (pOMXComponent, OUTPUT_PORT_INDEX);
 776     }
 777     pMpeg2Dec->hMFCMpeg2Handle.bConfiguredMFCDst = OMX_TRUE;
 778
 779     ret = OMX_ErrorNone;
 780
 781 EXIT:
 782     FunctionOut();
 783
 784     return ret;
 785 }
 786
 787 OMX_ERRORTYPE Exynos_Mpeg2Dec_GetParameter(
 788     OMX_IN OMX_HANDLETYPE hComponent,
 789     OMX_IN OMX_INDEXTYPE  nParamIndex,
 790     OMX_INOUT OMX_PTR     pComponentParameterStructure)
 791 {
 792     OMX_ERRORTYPE          ret = OMX_ErrorNone;
 793     OMX_COMPONENTTYPE     *pOMXComponent = NULL;
 794     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 795
 796     FunctionIn();
 797
 798     if (hComponent == NULL || pComponentParameterStructure == NULL) {
 799         ret = OMX_ErrorBadParameter;
 800         goto EXIT;
 801     }
 802     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 803     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 804     if (ret != OMX_ErrorNone) {
 805         goto EXIT;
 806     }
 807     if (pOMXComponent->pComponentPrivate == NULL) {
 808         ret = OMX_ErrorBadParameter;
 809         goto EXIT;
 810     }
 811
 812     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 813     if (pExynosComponent->currentState == OMX_StateInvalid ) {
 814         ret = OMX_ErrorInvalidState;
 815         goto EXIT;
 816     }
 817
 818     switch (nParamIndex) {
 819     case OMX_IndexParamVideoMpeg2:
 820     {
 821         OMX_VIDEO_PARAM_MPEG2TYPE *pDstMpeg2Param = (OMX_VIDEO_PARAM_MPEG2TYPE *)pComponentParameterStructure;
 822         OMX_VIDEO_PARAM_MPEG2TYPE *pSrcMpeg2Param = NULL;
 823         EXYNOS_MPEG2DEC_HANDLE       *pMpeg2Dec      = NULL;
 824         ret = Exynos_OMX_Check_SizeVersion(pDstMpeg2Param, sizeof(OMX_VIDEO_PARAM_MPEG2TYPE));
 825         if (ret != OMX_ErrorNone) {
 826             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "1");
 827             goto EXIT;
 828         }
 829
 830         if (pDstMpeg2Param->nPortIndex > OUTPUT_PORT_INDEX) {
 831             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "2");
 832             ret = OMX_ErrorBadPortIndex;
 833         }
 834
 835         pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 836         pSrcMpeg2Param = &pMpeg2Dec->Mpeg2Component[pDstMpeg2Param->nPortIndex];
 837
 838         Exynos_OSAL_Memcpy(pDstMpeg2Param, pSrcMpeg2Param, sizeof(OMX_VIDEO_PARAM_MPEG2TYPE));
 839     }
 840         break;
 841     case OMX_IndexParamStandardComponentRole:
 842     {
 843         OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
 844         ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
 845         if (ret != OMX_ErrorNone) {
 846             goto EXIT;
 847         }
 848
 849         Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG2_DEC_ROLE);
 850     }
 851         break;
 852     case OMX_IndexParamVideoProfileLevelCurrent:
 853     {
 854         OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
 855         OMX_VIDEO_PARAM_MPEG2TYPE *pSrcMpeg2Component = NULL;
 856         EXYNOS_MPEG2DEC_HANDLE      *pMpeg2Dec = NULL;
 857
 858         ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
 859         if (ret != OMX_ErrorNone) {
 860             goto EXIT;
 861         }
 862
 863         if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
 864             ret = OMX_ErrorBadPortIndex;
 865             goto EXIT;
 866         }
 867
 868         pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 869         pSrcMpeg2Component = &pMpeg2Dec->Mpeg2Component[pDstProfileLevel->nPortIndex];
 870
 871         pDstProfileLevel->eProfile = pSrcMpeg2Component->eProfile;
 872         pDstProfileLevel->eLevel = pSrcMpeg2Component->eLevel;
 873     }
 874         break;
 875     case OMX_IndexParamVideoErrorCorrection:
 876     {
 877         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
 878         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
 879         EXYNOS_MPEG2DEC_HANDLE                *pMpeg2Dec                 = NULL;
 880
 881         ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
 882         if (ret != OMX_ErrorNone) {
 883             goto EXIT;
 884         }
 885
 886         if (pDstErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
 887             ret = OMX_ErrorBadPortIndex;
 888             goto EXIT;
 889         }
 890
 891         pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 892         pSrcErrorCorrectionType = &pMpeg2Dec->errorCorrectionType[INPUT_PORT_INDEX];
 893
 894         pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
 895         pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
 896         pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
 897         pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
 898         pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
 899     }
 900         break;
 901     default:
 902         ret = Exynos_OMX_VideoDecodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
 903         break;
 904     }
 905 EXIT:
 906     FunctionOut();
 907
 908     return ret;
 909 }
 910
 911 OMX_ERRORTYPE Exynos_Mpeg2Dec_SetParameter(
 912     OMX_IN OMX_HANDLETYPE hComponent,
 913     OMX_IN OMX_INDEXTYPE  nIndex,
 914     OMX_IN OMX_PTR        pComponentParameterStructure)
 915 {
 916     OMX_ERRORTYPE           ret = OMX_ErrorNone;
 917     OMX_COMPONENTTYPE     *pOMXComponent = NULL;
 918     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
 919
 920     FunctionIn();
 921
 922     if (hComponent == NULL || pComponentParameterStructure == NULL) {
 923         ret = OMX_ErrorBadParameter;
 924         goto EXIT;
 925     }
 926     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 927     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
 928     if (ret != OMX_ErrorNone) {
 929         goto EXIT;
 930     }
 931     if (pOMXComponent->pComponentPrivate == NULL) {
 932         ret = OMX_ErrorBadParameter;
 933         goto EXIT;
 934     }
 935
 936     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 937     if (pExynosComponent->currentState == OMX_StateInvalid ) {
 938         ret = OMX_ErrorInvalidState;
 939         goto EXIT;
 940     }
 941
 942     switch (nIndex) {
 943     case OMX_IndexParamVideoMpeg2:
 944     {
 945         OMX_VIDEO_PARAM_MPEG2TYPE *pDstMpeg2Param = NULL;
 946         OMX_VIDEO_PARAM_MPEG2TYPE *pSrcMpeg2Param = (OMX_VIDEO_PARAM_MPEG2TYPE *)pComponentParameterStructure;
 947         EXYNOS_MPEG2DEC_HANDLE       *pMpeg2Dec      = NULL;
 948         ret = Exynos_OMX_Check_SizeVersion(pSrcMpeg2Param, sizeof(OMX_VIDEO_PARAM_MPEG2TYPE));
 949         if (ret != OMX_ErrorNone) {
 950             goto EXIT;
 951         }
 952
 953         if (pSrcMpeg2Param->nPortIndex > OUTPUT_PORT_INDEX) {
 954             ret = OMX_ErrorBadPortIndex;
 955             goto EXIT;
 956         }
 957
 958         pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 959         pDstMpeg2Param = &pMpeg2Dec->Mpeg2Component[pSrcMpeg2Param->nPortIndex];
 960
 961         Exynos_OSAL_Memcpy(pDstMpeg2Param, pSrcMpeg2Param, sizeof(OMX_VIDEO_PARAM_MPEG2TYPE));
 962     }
 963         break;
 964     case OMX_IndexParamStandardComponentRole:
 965     {
 966         OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
 967
 968         ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
 969         if (ret != OMX_ErrorNone) {
 970             goto EXIT;
 971         }
 972
 973         if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
 974             ret = OMX_ErrorIncorrectStateOperation;
 975             goto EXIT;
 976         }
 977
 978         if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_MPEG2_DEC_ROLE)) {
 979             pExynosComponent->pExynosPort[INPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG2;
 980         } else {
 981             ret = OMX_ErrorBadParameter;
 982             goto EXIT;
 983         }
 984     }
 985         break;
 986     case OMX_IndexParamPortDefinition:
 987     {
 988         OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
 989         OMX_U32                       portIndex       = pPortDefinition->nPortIndex;
 990         EXYNOS_OMX_BASEPORT          *pExynosPort;
 991         OMX_U32                       width, height, size;
 992         OMX_U32                       realWidth, realHeight;
 993
 994         if (portIndex >= pExynosComponent->portParam.nPorts) {
 995             ret = OMX_ErrorBadPortIndex;
 996             goto EXIT;
 997         }
 998         ret = Exynos_OMX_Check_SizeVersion(pPortDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
 999         if (ret != OMX_ErrorNone) {
1000             goto EXIT;
1001         }
1002
1003         pExynosPort = &pExynosComponent->pExynosPort[portIndex];
1004
1005         if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1006             if (pExynosPort->portDefinition.bEnabled == OMX_TRUE) {
1007                 ret = OMX_ErrorIncorrectStateOperation;
1008                 goto EXIT;
1009             }
1010         }
1011         if (pPortDefinition->nBufferCountActual < pExynosPort->portDefinition.nBufferCountMin) {
1012             ret = OMX_ErrorBadParameter;
1013             goto EXIT;
1014         }
1015
1016         Exynos_OSAL_Memcpy(&pExynosPort->portDefinition, pPortDefinition, pPortDefinition->nSize);
1017
1018         realWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1019         realHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1020         width = ((realWidth + 15) & (~15));
1021         height = ((realHeight + 15) & (~15));
1022         size = (width * height * 3) / 2;
1023         pExynosPort->portDefinition.format.video.nStride = width;
1024         pExynosPort->portDefinition.format.video.nSliceHeight = height;
1025         pExynosPort->portDefinition.nBufferSize = (size > pExynosPort->portDefinition.nBufferSize) ? size : pExynosPort->portDefinition.nBufferSize;
1026
1027         if (portIndex == INPUT_PORT_INDEX) {
1028             EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1029             pExynosOutputPort->portDefinition.format.video.nFrameWidth = pExynosPort->portDefinition.format.video.nFrameWidth;
1030             pExynosOutputPort->portDefinition.format.video.nFrameHeight = pExynosPort->portDefinition.format.video.nFrameHeight;
1031             pExynosOutputPort->portDefinition.format.video.nStride = width;
1032             pExynosOutputPort->portDefinition.format.video.nSliceHeight = height;
1033
1034             switch (pExynosOutputPort->portDefinition.format.video.eColorFormat) {
1035             case OMX_COLOR_FormatYUV420Planar:
1036             case OMX_COLOR_FormatYUV420SemiPlanar:
1037 //            case OMX_SEC_COLOR_FormatNV12TPhysicalAddress:
1038             //case OMX_SEC_COLOR_FormatANBYUV420SemiPlanar:
1039                 pExynosOutputPort->portDefinition.nBufferSize = (width * height * 3) / 2;
1040                 break;
1041             case OMX_SEC_COLOR_FormatNV12Tiled:
1042                 pExynosOutputPort->portDefinition.nBufferSize =
1043                     calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1044                     calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1045                 break;
1046             default:
1047                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Color format is not support!! use default YUV size!!");
1048                 ret = OMX_ErrorUnsupportedSetting;
1049                 break;
1050             }
1051
1052             if (pExynosOutputPort->bufferProcessType == BUFFER_SHARE) {
1053                 pExynosOutputPort->portDefinition.nBufferSize =
1054                     calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight) +
1055                     calc_plane(pExynosPort->portDefinition.format.video.nFrameWidth, pExynosOutputPort->portDefinition.format.video.nFrameHeight >> 1);
1056             }
1057         }
1058     }
1059         break;
1060     case OMX_IndexParamVideoProfileLevelCurrent:
1061     {
1062         OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1063         OMX_VIDEO_PARAM_MPEG2TYPE *pDstMpeg2Component = NULL;
1064         EXYNOS_MPEG2DEC_HANDLE      *pMpeg2Dec = NULL;
1065
1066         ret = Exynos_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1067         if (ret != OMX_ErrorNone)
1068             goto EXIT;
1069
1070         if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1071             ret = OMX_ErrorBadPortIndex;
1072             goto EXIT;
1073         }
1074
1075         pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1076
1077         pDstMpeg2Component = &pMpeg2Dec->Mpeg2Component[pSrcProfileLevel->nPortIndex];
1078         pDstMpeg2Component->eProfile = pSrcProfileLevel->eProfile;
1079         pDstMpeg2Component->eLevel = pSrcProfileLevel->eLevel;
1080     }
1081         break;
1082     case OMX_IndexParamVideoErrorCorrection:
1083     {
1084         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1085         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1086         EXYNOS_MPEG2DEC_HANDLE                *pMpeg2Dec                 = NULL;
1087
1088         ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1089         if (ret != OMX_ErrorNone) {
1090             goto EXIT;
1091         }
1092
1093         if (pSrcErrorCorrectionType->nPortIndex != INPUT_PORT_INDEX) {
1094             ret = OMX_ErrorBadPortIndex;
1095             goto EXIT;
1096         }
1097
1098         pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1099         pDstErrorCorrectionType = &pMpeg2Dec->errorCorrectionType[INPUT_PORT_INDEX];
1100
1101         pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1102         pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1103         pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1104         pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1105         pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1106     }
1107         break;
1108     default:
1109         ret = Exynos_OMX_VideoDecodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1110         break;
1111     }
1112 EXIT:
1113     FunctionOut();
1114
1115     return ret;
1116 }
1117
1118 OMX_ERRORTYPE Exynos_Mpeg2Dec_GetConfig(
1119     OMX_HANDLETYPE hComponent,
1120     OMX_INDEXTYPE  nIndex,
1121     OMX_PTR        pComponentConfigStructure)
1122 {
1123     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1124     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1125     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1126
1127     FunctionIn();
1128
1129     if (hComponent == NULL) {
1130         ret = OMX_ErrorBadParameter;
1131         goto EXIT;
1132     }
1133     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1134     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1135     if (ret != OMX_ErrorNone) {
1136         goto EXIT;
1137     }
1138     if (pOMXComponent->pComponentPrivate == NULL) {
1139         ret = OMX_ErrorBadParameter;
1140         goto EXIT;
1141     }
1142     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1143     if (pExynosComponent->currentState == OMX_StateInvalid) {
1144         ret = OMX_ErrorInvalidState;
1145         goto EXIT;
1146     }
1147
1148     switch (nIndex) {
1149     default:
1150         ret = Exynos_OMX_VideoDecodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1151         break;
1152     }
1153
1154 EXIT:
1155     FunctionOut();
1156
1157     return ret;
1158 }
1159
1160 OMX_ERRORTYPE Exynos_Mpeg2Dec_SetConfig(
1161     OMX_HANDLETYPE hComponent,
1162     OMX_INDEXTYPE  nIndex,
1163     OMX_PTR        pComponentConfigStructure)
1164 {
1165     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1166     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1167     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1168
1169     FunctionIn();
1170
1171     if (hComponent == NULL) {
1172         ret = OMX_ErrorBadParameter;
1173         goto EXIT;
1174     }
1175     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1176     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1177     if (ret != OMX_ErrorNone) {
1178         goto EXIT;
1179     }
1180     if (pOMXComponent->pComponentPrivate == NULL) {
1181         ret = OMX_ErrorBadParameter;
1182         goto EXIT;
1183     }
1184     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1185     if (pExynosComponent->currentState == OMX_StateInvalid) {
1186         ret = OMX_ErrorInvalidState;
1187         goto EXIT;
1188     }
1189
1190     switch (nIndex) {
1191     default:
1192         ret = Exynos_OMX_VideoDecodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1193         break;
1194     }
1195
1196 EXIT:
1197     FunctionOut();
1198
1199     return ret;
1200 }
1201
1202 OMX_ERRORTYPE Exynos_Mpeg2Dec_GetExtensionIndex(
1203     OMX_IN  OMX_HANDLETYPE  hComponent,
1204     OMX_IN  OMX_STRING      cParameterName,
1205     OMX_OUT OMX_INDEXTYPE   *pIndexType)
1206 {
1207     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1208     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1209     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1210
1211     FunctionIn();
1212
1213     if (hComponent == NULL) {
1214         ret = OMX_ErrorBadParameter;
1215         goto EXIT;
1216     }
1217     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1218     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1219     if (ret != OMX_ErrorNone) {
1220         goto EXIT;
1221     }
1222     if (pOMXComponent->pComponentPrivate == NULL) {
1223         ret = OMX_ErrorBadParameter;
1224         goto EXIT;
1225     }
1226     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1227     if ((cParameterName == NULL) || (pIndexType == NULL)) {
1228         ret = OMX_ErrorBadParameter;
1229         goto EXIT;
1230     }
1231     if (pExynosComponent->currentState == OMX_StateInvalid) {
1232         ret = OMX_ErrorInvalidState;
1233         goto EXIT;
1234     }
1235
1236     if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENABLE_THUMBNAIL) == 0) {
1237         *pIndexType = OMX_IndexVendorThumbnailMode;
1238         ret = OMX_ErrorNone;
1239     } else {
1240         ret = Exynos_OMX_VideoDecodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1241     }
1242
1243 EXIT:
1244     FunctionOut();
1245
1246     return ret;
1247 }
1248
1249 OMX_ERRORTYPE Exynos_Mpeg2Dec_ComponentRoleEnum(
1250     OMX_HANDLETYPE hComponent,
1251     OMX_U8        *cRole,
1252     OMX_U32        nIndex)
1253 {
1254     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1255
1256     FunctionIn();
1257
1258     if ((hComponent == NULL) || (cRole == NULL)) {
1259         ret = OMX_ErrorBadParameter;
1260         goto EXIT;
1261     }
1262     if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
1263         Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_MPEG2_DEC_ROLE);
1264         ret = OMX_ErrorNone;
1265     } else {
1266         ret = OMX_ErrorNoMore;
1267     }
1268
1269 EXIT:
1270     FunctionOut();
1271
1272     return ret;
1273 }
1274
1275 /* MFC Init */
1276 OMX_ERRORTYPE Exynos_Mpeg2Dec_Init(OMX_COMPONENTTYPE *pOMXComponent)
1277 {
1278     OMX_ERRORTYPE          ret = OMX_ErrorNone;
1279     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1280     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1281     EXYNOS_OMX_BASEPORT      *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1282     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1283     EXYNOS_MPEG2DEC_HANDLE          *pMpeg2Dec           = (EXYNOS_MPEG2DEC_HANDLE *)pVideoDec->hCodecHandle;
1284
1285
1286
1287     CSC_METHOD csc_method = CSC_METHOD_SW;
1288     int i, plane;
1289
1290     FunctionIn();
1291
1292     pMpeg2Dec->hMFCMpeg2Handle.bConfiguredMFCSrc = OMX_FALSE;
1293     pMpeg2Dec->hMFCMpeg2Handle.bConfiguredMFCDst = OMX_FALSE;
1294     pExynosComponent->bUseFlagEOF = OMX_TRUE;
1295     pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1296
1297     /* Mpeg2 Codec Open */
1298     ret = Mpeg2CodecOpen(pMpeg2Dec);
1299     if (ret != OMX_ErrorNone) {
1300         goto EXIT;
1301     }
1302
1303     if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
1304         Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1305         Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1306
1307         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1308             pVideoDec->pMFCDecInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_DEC_BUFFER));
1309             Exynos_OSAL_Memset(pVideoDec->pMFCDecInputBuffer[i], 0, sizeof(CODEC_DEC_BUFFER));
1310             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]: 0x%x", i, pVideoDec->pMFCDecInputBuffer[i]);
1311
1312             for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
1313             /* Use ION Allocator */
1314                 pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoDec->hSharedMemory, DEFAULT_MFC_INPUT_BUFFER_SIZE, NORMAL_MEMORY);
1315                 pVideoDec->pMFCDecInputBuffer[i]->fd[plane] = Exynos_OSAL_SharedMemory_VirtToION(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1316                 pVideoDec->pMFCDecInputBuffer[i]->bufferSize[plane] = DEFAULT_MFC_INPUT_BUFFER_SIZE;
1317             pVideoDec->pMFCDecInputBuffer[i]->dataSize   = 0;
1318                 if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] == NULL) {
1319                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
1320                 ret = OMX_ErrorInsufficientResources;
1321                 goto EXIT;
1322             }
1323                 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoDec->pMFCDecInputBuffer[%d]->pVirAddr[%d]: 0x%x", i, plane, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1324             }
1325
1326             Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoDec->pMFCDecInputBuffer[i]);
1327         }
1328     } else if (pExynosInputPort->bufferProcessType == BUFFER_SHARE) {
1329         /*************/
1330         /*    TBD    */
1331         /*************/
1332         /* Does not require any actions. */
1333     }
1334
1335     if ((pExynosOutputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
1336         Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
1337         Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1338     } else if (pExynosOutputPort->bufferProcessType == BUFFER_SHARE) {
1339         /*************/
1340         /*    TBD    */
1341         /*************/
1342         /* Does not require any actions. */
1343     }
1344
1345     pMpeg2Dec->bSourceStart = OMX_FALSE;
1346     Exynos_OSAL_SignalCreate(&pMpeg2Dec->hSourceStartEvent);
1347     pMpeg2Dec->bDestinationStart = OMX_FALSE;
1348     Exynos_OSAL_SignalCreate(&pMpeg2Dec->hDestinationStartEvent);
1349
1350     Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
1351     Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
1352     pMpeg2Dec->hMFCMpeg2Handle.indexTimestamp = 0;
1353     pMpeg2Dec->hMFCMpeg2Handle.outputIndexTimestamp = 0;
1354
1355     pExynosComponent->getAllDelayBuffer = OMX_FALSE;
1356
1357 #if 0//defined(USE_CSC_GSCALER)
1358     csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
1359 #endif
1360     pVideoDec->csc_handle = csc_init(csc_method);
1361     if (pVideoDec->csc_handle == NULL) {
1362         ret = OMX_ErrorInsufficientResources;
1363         goto EXIT;
1364     }
1365     pVideoDec->csc_set_format = OMX_FALSE;
1366
1367 EXIT:
1368     FunctionOut();
1369
1370     return ret;
1371 }
1372
1373 /* MFC Terminate */
1374 OMX_ERRORTYPE Exynos_Mpeg2Dec_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
1375 {
1376     OMX_ERRORTYPE          ret = OMX_ErrorNone;
1377     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1378     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1379     EXYNOS_OMX_BASEPORT      *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1380     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1381     EXYNOS_MPEG2DEC_HANDLE    *pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1382
1383     int i;
1384
1385     FunctionIn();
1386
1387     if (pVideoDec->csc_handle != NULL) {
1388         csc_deinit(pVideoDec->csc_handle);
1389         pVideoDec->csc_handle = NULL;
1390     }
1391
1392     Exynos_OSAL_SignalTerminate(pMpeg2Dec->hDestinationStartEvent);
1393     pMpeg2Dec->hDestinationStartEvent = NULL;
1394     pMpeg2Dec->bDestinationStart = OMX_FALSE;
1395     Exynos_OSAL_SignalTerminate(pMpeg2Dec->hSourceStartEvent);
1396     pMpeg2Dec->hSourceStartEvent = NULL;
1397     pMpeg2Dec->bSourceStart = OMX_FALSE;
1398
1399     if ((pExynosOutputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
1400         for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
1401             if (pVideoDec->pMFCDecOutputBuffer[i] != NULL) {
1402 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
1403                 for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1404                     if (pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane] != NULL)
1405                         Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecOutputBuffer[i]->pVirAddr[plane]);
1406                 }
1407 #endif
1408                 Exynos_OSAL_Free(pVideoDec->pMFCDecOutputBuffer[i]);
1409                 pVideoDec->pMFCDecOutputBuffer[i] = NULL;
1410             }
1411         }
1412
1413         Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
1414         Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
1415     } else if (pExynosOutputPort->bufferProcessType == BUFFER_SHARE) {
1416         /*************/
1417         /*    TBD    */
1418         /*************/
1419         /* Does not require any actions. */
1420     }
1421
1422     if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
1423         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1424             if (pVideoDec->pMFCDecInputBuffer[i] != NULL) {
1425 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
1426                 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
1427                     if (pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane] != NULL)
1428                         Exynos_OSAL_SharedMemory_Free(pVideoDec->hSharedMemory, pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[plane]);
1429                 }
1430 #endif
1431             Exynos_OSAL_Free(pVideoDec->pMFCDecInputBuffer[i]);
1432             pVideoDec->pMFCDecInputBuffer[i] = NULL;
1433         }
1434         }
1435
1436         Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
1437         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
1438     } else if (pExynosInputPort->bufferProcessType == BUFFER_SHARE) {
1439         /*************/
1440         /*    TBD    */
1441         /*************/
1442         /* Does not require any actions. */
1443     }
1444     Mpeg2CodecClose(pMpeg2Dec);
1445
1446     FunctionOut();
1447
1448     return ret;
1449 }
1450
1451 OMX_ERRORTYPE Exynos_Mpeg2Dec_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1452 {
1453     OMX_ERRORTYPE               ret = OMX_ErrorNone;
1454     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1455     EXYNOS_MPEG2DEC_HANDLE         *pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1456     void                          *hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle;
1457     OMX_U32  oneFrameSize = pSrcInputData->dataLen;
1458     ExynosVideoDecOps       *pDecOps    = pMpeg2Dec->hMFCMpeg2Handle.pDecOps;
1459     ExynosVideoDecBufferOps *pInbufOps  = pMpeg2Dec->hMFCMpeg2Handle.pInbufOps;
1460     ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
1461
1462     FunctionIn();
1463
1464     if (pMpeg2Dec->hMFCMpeg2Handle.bConfiguredMFCSrc == OMX_FALSE) {
1465         ret = Mpeg2CodecSrcSetup(pOMXComponent, pSrcInputData);
1466         goto EXIT;
1467     }
1468     if (pMpeg2Dec->hMFCMpeg2Handle.bConfiguredMFCDst == OMX_FALSE) {
1469         ret = Mpeg2CodecDstSetup(pOMXComponent);
1470     }
1471
1472     if ((Check_Mpeg2_StartCode(pSrcInputData->buffer.singlePlaneBuffer.dataBuffer, oneFrameSize) == OMX_TRUE) ||
1473         ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)){
1474         pExynosComponent->timeStamp[pMpeg2Dec->hMFCMpeg2Handle.indexTimestamp] = pSrcInputData->timeStamp;
1475         pExynosComponent->nFlags[pMpeg2Dec->hMFCMpeg2Handle.indexTimestamp] = pSrcInputData->nFlags;
1476         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "input timestamp %lld us (%.2f secs), Tag: %d, nFlags: 0x%x", pSrcInputData->timeStamp, pSrcInputData->timeStamp / 1E6, pMpeg2Dec->hMFCMpeg2Handle.indexTimestamp, pSrcInputData->nFlags);
1477         pDecOps->Set_FrameTag(hMFCHandle, pMpeg2Dec->hMFCMpeg2Handle.indexTimestamp);
1478         pMpeg2Dec->hMFCMpeg2Handle.indexTimestamp++;
1479         pMpeg2Dec->hMFCMpeg2Handle.indexTimestamp %= MAX_TIMESTAMP;
1480
1481         /* queue work for input buffer */
1482         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "oneFrameSize: %d, bufferHeader: 0x%x, dataBuffer: 0x%x", oneFrameSize, pSrcInputData->bufferHeader, pSrcInputData->buffer.singlePlaneBuffer.dataBuffer);
1483         codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)&pSrcInputData->buffer.singlePlaneBuffer.dataBuffer,
1484                                     (unsigned int *)&oneFrameSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
1485         if (codecReturn != VIDEO_ERROR_NONE) {
1486             ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1487             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
1488             goto EXIT;
1489         }
1490         Mpeg2CodecStart(pOMXComponent, INPUT_PORT_INDEX);
1491         if (pMpeg2Dec->bSourceStart == OMX_FALSE) {
1492             pMpeg2Dec->bSourceStart = OMX_TRUE;
1493             Exynos_OSAL_SignalSet(pMpeg2Dec->hSourceStartEvent);
1494             Exynos_OSAL_SleepMillisec(0);
1495         }
1496         if (pMpeg2Dec->bDestinationStart == OMX_FALSE) {
1497             pMpeg2Dec->bDestinationStart = OMX_TRUE;
1498             Exynos_OSAL_SignalSet(pMpeg2Dec->hDestinationStartEvent);
1499             Exynos_OSAL_SleepMillisec(0);
1500         }
1501     }
1502
1503     ret = OMX_ErrorNone;
1504
1505 EXIT:
1506     FunctionOut();
1507
1508     return ret;
1509 }
1510
1511 OMX_ERRORTYPE Exynos_Mpeg2Dec_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
1512 {
1513     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
1514     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1515     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1516     EXYNOS_MPEG2DEC_HANDLE         *pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1517     void                          *hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle;
1518     EXYNOS_OMX_BASEPORT     *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1519     ExynosVideoDecBufferOps *pInbufOps  = pMpeg2Dec->hMFCMpeg2Handle.pInbufOps;
1520     ExynosVideoBuffer       *pVideoBuffer;
1521
1522     FunctionIn();
1523
1524     pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
1525
1526     pSrcOutputData->dataLen       = 0;
1527     pSrcOutputData->usedDataLen   = 0;
1528     pSrcOutputData->remainDataLen = 0;
1529     pSrcOutputData->nFlags    = 0;
1530     pSrcOutputData->timeStamp = 0;
1531
1532     if (pVideoBuffer == NULL) {
1533         pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
1534         pSrcOutputData->allocSize  = 0;
1535         pSrcOutputData->pPrivate = NULL;
1536         pSrcOutputData->bufferHeader = NULL;
1537     } else {
1538         pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
1539         pSrcOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
1540         pSrcOutputData->allocSize  = pVideoBuffer->planes[0].allocSize;
1541
1542         if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
1543             int i = 0;
1544             while (pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer != pVideoDec->pMFCDecInputBuffer[i]->pVirAddr[0]) {
1545                 i++;
1546                 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
1547                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Can not find buffer");
1548                     ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1549                     goto EXIT;
1550                 }
1551             }
1552             pVideoDec->pMFCDecInputBuffer[i]->dataSize = 0;
1553             pSrcOutputData->pPrivate = pVideoDec->pMFCDecInputBuffer[i];
1554         }
1555
1556         /* For Share Buffer */
1557         pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
1558     }
1559
1560     ret = OMX_ErrorNone;
1561
1562 EXIT:
1563     FunctionOut();
1564
1565     return ret;
1566 }
1567
1568 OMX_ERRORTYPE Exynos_Mpeg2Dec_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
1569 {
1570     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
1571     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1572     EXYNOS_MPEG2DEC_HANDLE         *pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1573     void                          *hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle;
1574     ExynosVideoDecBufferOps *pOutbufOps = pMpeg2Dec->hMFCMpeg2Handle.pOutbufOps;
1575     OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0,};
1576     ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
1577
1578     FunctionIn();
1579
1580     if (pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) {
1581         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
1582         ret = OMX_ErrorBadParameter;
1583         goto EXIT;
1584     }
1585
1586     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s : %d => ADDR[0]: 0x%x, ADDR[1]: 0x%x", __FUNCTION__, __LINE__,
1587                                         pDstInputData->buffer.multiPlaneBuffer.dataBuffer[0],
1588                                         pDstInputData->buffer.multiPlaneBuffer.dataBuffer[1]);
1589
1590     codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pDstInputData->buffer.multiPlaneBuffer.dataBuffer,
1591                      (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
1592
1593     if (codecReturn != VIDEO_ERROR_NONE) {
1594         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s : %d", __FUNCTION__, __LINE__);
1595         ret = (OMX_ERRORTYPE)OMX_ErrorCodecDecode;
1596         goto EXIT;
1597     }
1598     Mpeg2CodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
1599
1600     ret = OMX_ErrorNone;
1601
1602 EXIT:
1603     FunctionOut();
1604
1605     return ret;
1606 }
1607
1608 OMX_ERRORTYPE Exynos_Mpeg2Dec_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
1609 {
1610     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
1611     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1612         EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1613     EXYNOS_MPEG2DEC_HANDLE         *pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1614     void                          *hMFCHandle = pMpeg2Dec->hMFCMpeg2Handle.hMFCHandle;
1615
1616     EXYNOS_OMX_BASEPORT *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1617     ExynosVideoDecOps       *pDecOps    = pMpeg2Dec->hMFCMpeg2Handle.pDecOps;
1618     ExynosVideoDecBufferOps *pOutbufOps = pMpeg2Dec->hMFCMpeg2Handle.pOutbufOps;
1619     ExynosVideoBuffer       *pVideoBuffer;
1620     ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
1621     ExynosVideoGeometry *bufferGeometry;
1622     DECODE_CODEC_EXTRA_BUFFERINFO *pBufferInfo = NULL;
1623     OMX_S32 indexTimestamp = 0;
1624     int plane;
1625
1626     FunctionIn();
1627
1628     if (pMpeg2Dec->bDestinationStart == OMX_FALSE) {
1629         ret = OMX_ErrorNone;
1630         goto EXIT;
1631     }
1632
1633     while (1) {
1634         if ((pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle)) == NULL) {
1635             ret = OMX_ErrorNone;
1636             goto EXIT;
1637         }
1638         displayStatus = pVideoBuffer->displayStatus;
1639         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus: 0x%x", displayStatus);
1640
1641         if ((displayStatus == VIDEO_FRAME_STATUS_DISPLAY_DECODING) ||
1642             (displayStatus == VIDEO_FRAME_STATUS_DISPLAY_ONLY) ||
1643             (displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
1644             (CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
1645             if (pVideoBuffer != NULL) {
1646                 ret = OMX_ErrorNone;
1647                 break;
1648             } else {
1649                 ret = OMX_ErrorUndefined;
1650                 break;
1651             }
1652         }
1653     }
1654
1655     if (ret != OMX_ErrorNone)
1656         goto EXIT;
1657
1658     pMpeg2Dec->hMFCMpeg2Handle.outputIndexTimestamp++;
1659     pMpeg2Dec->hMFCMpeg2Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
1660
1661     pDstOutputData->allocSize = pDstOutputData->dataLen = 0;
1662     for (plane = 0; plane < MFC_OUTPUT_BUFFER_PLANE; plane++) {
1663         pDstOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
1664         pDstOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
1665         pDstOutputData->buffer.multiPlaneBuffer.tbm_bo[plane] = pVideoBuffer->planes[plane].tbm_bo;
1666         pDstOutputData->allocSize += pVideoBuffer->planes[plane].allocSize;
1667         pDstOutputData->dataLen +=  pVideoBuffer->planes[plane].dataSize;
1668     }
1669     pDstOutputData->usedDataLen = 0;
1670     pDstOutputData->pPrivate = pVideoBuffer;
1671     /* For Share Buffer */
1672     pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
1673
1674     pBufferInfo = (DECODE_CODEC_EXTRA_BUFFERINFO *)pDstOutputData->extInfo;
1675     bufferGeometry = &pMpeg2Dec->hMFCMpeg2Handle.codecOutbufConf;
1676     pBufferInfo->imageWidth = bufferGeometry->nFrameWidth;
1677     pBufferInfo->imageHeight = bufferGeometry->nFrameHeight;
1678     switch (bufferGeometry->eColorFormat) {
1679     case VIDEO_COLORFORMAT_NV12:
1680         pBufferInfo->ColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
1681         break;
1682     case VIDEO_COLORFORMAT_NV12_TILED:
1683     default:
1684         pBufferInfo->ColorFormat = OMX_SEC_COLOR_FormatNV12Tiled;
1685         break;
1686     }
1687
1688     indexTimestamp = pDecOps->Get_FrameTag(hMFCHandle);
1689     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "out indexTimestamp: %d", indexTimestamp);
1690     if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
1691         if ((pExynosComponent->checkTimeStamp.needSetStartTimeStamp != OMX_TRUE) &&
1692             (pExynosComponent->checkTimeStamp.needCheckStartTimeStamp != OMX_TRUE)) {
1693             pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg2Dec->hMFCMpeg2Handle.outputIndexTimestamp];
1694             pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg2Dec->hMFCMpeg2Handle.outputIndexTimestamp];
1695             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "missing out indexTimestamp: %d", indexTimestamp);
1696         } else {
1697             pDstOutputData->timeStamp = 0x00;
1698             pDstOutputData->nFlags = 0x00;
1699         }
1700     } else {
1701         /* For timestamp correction. if mfc support frametype detect */
1702         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "disp_pic_frame_type: %d", pVideoBuffer->frameType);
1703 //#ifdef NEED_TIMESTAMP_REORDER
1704         /* TIZEN_FEATURE_E3250 */
1705         if (pVideoDec->bNeedTimestampReorder == OMX_TRUE) {
1706             if ((pVideoBuffer->frameType == VIDEO_FRAME_I)) {
1707                 pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
1708                 pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
1709                 pMpeg2Dec->hMFCMpeg2Handle.outputIndexTimestamp = indexTimestamp;
1710             } else {
1711                 pDstOutputData->timeStamp = pExynosComponent->timeStamp[pMpeg2Dec->hMFCMpeg2Handle.outputIndexTimestamp];
1712                 pDstOutputData->nFlags = pExynosComponent->nFlags[pMpeg2Dec->hMFCMpeg2Handle.outputIndexTimestamp];
1713             }
1714 //#else
1715         } else {
1716             pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
1717             pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
1718         }
1719 //#endif
1720         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "timestamp %lld us (%.2f secs), indexTimestamp: %d, nFlags: 0x%x", pDstOutputData->timeStamp, pDstOutputData->timeStamp / 1E6, indexTimestamp, pDstOutputData->nFlags);
1721     }
1722
1723     if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
1724         ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
1725         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "displayStatus:%d, nFlags0x%x", displayStatus, pDstOutputData->nFlags);
1726         pDstOutputData->remainDataLen = 0;
1727     } else {
1728         pDstOutputData->remainDataLen = bufferGeometry->nFrameWidth * bufferGeometry->nFrameHeight * 3 / 2;
1729     }
1730
1731     ret = OMX_ErrorNone;
1732
1733 EXIT:
1734     FunctionOut();
1735
1736     return ret;
1737 }
1738
1739 OMX_ERRORTYPE Exynos_Mpeg2Dec_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1740 {
1741     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1742     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1743     EXYNOS_OMX_BASEPORT      *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1744
1745     FunctionIn();
1746
1747     if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
1748         ret = OMX_ErrorNone;
1749         goto EXIT;
1750     }
1751     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
1752         ret = OMX_ErrorNone;
1753         goto EXIT;
1754     }
1755
1756     ret = Exynos_Mpeg2Dec_SrcIn(pOMXComponent, pSrcInputData);
1757     if ((ret != OMX_ErrorNone) && (ret != (OMX_ERRORTYPE)OMX_ErrorInputDataDecodeYet)) {
1758         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
1759                                                 pExynosComponent->callbackData,
1760                                                 OMX_EventError, ret, 0, NULL);
1761     }
1762
1763 EXIT:
1764     FunctionOut();
1765
1766     return ret;
1767 }
1768
1769 OMX_ERRORTYPE Exynos_Mpeg2Dec_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
1770 {
1771     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1772     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1773     EXYNOS_MPEG2DEC_HANDLE    *pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1774     EXYNOS_OMX_BASEPORT     *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1775
1776     FunctionIn();
1777
1778     if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
1779         ret = OMX_ErrorNone;
1780         goto EXIT;
1781     }
1782
1783     if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
1784         if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
1785             ret = OMX_ErrorNone;
1786             goto EXIT;
1787         }
1788     }
1789     if ((pMpeg2Dec->bSourceStart == OMX_FALSE) &&
1790        (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
1791         Exynos_OSAL_SignalWait(pMpeg2Dec->hSourceStartEvent, DEF_MAX_WAIT_TIME);
1792         Exynos_OSAL_SignalReset(pMpeg2Dec->hSourceStartEvent);
1793     }
1794
1795     ret = Exynos_Mpeg2Dec_SrcOut(pOMXComponent, pSrcOutputData);
1796     if ((ret != OMX_ErrorNone) &&
1797         (pExynosComponent->currentState == OMX_StateExecuting)) {
1798         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
1799                                                 pExynosComponent->callbackData,
1800                                                 OMX_EventError, ret, 0, NULL);
1801     }
1802
1803 EXIT:
1804     FunctionOut();
1805
1806     return ret;
1807 }
1808
1809 OMX_ERRORTYPE Exynos_Mpeg2Dec_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
1810 {
1811     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1812     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1813     EXYNOS_MPEG2DEC_HANDLE    *pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1814     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1815
1816     FunctionIn();
1817
1818     if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
1819         ret = OMX_ErrorNone;
1820         goto EXIT;
1821     }
1822     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
1823         ret = OMX_ErrorNone;
1824         goto EXIT;
1825     }
1826     if (pExynosOutputPort->bufferProcessType == BUFFER_SHARE) {
1827         if ((pMpeg2Dec->bDestinationStart == OMX_FALSE) &&
1828            (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
1829             Exynos_OSAL_SignalWait(pMpeg2Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
1830             Exynos_OSAL_SignalReset(pMpeg2Dec->hDestinationStartEvent);
1831         }
1832     }
1833     if (pMpeg2Dec->hMFCMpeg2Handle.bConfiguredMFCDst == OMX_TRUE) {
1834         ret = Exynos_Mpeg2Dec_DstIn(pOMXComponent, pDstInputData);
1835         if (ret != OMX_ErrorNone) {
1836             pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
1837                                                 pExynosComponent->callbackData,
1838                                                 OMX_EventError, ret, 0, NULL);
1839         }
1840     }
1841
1842 EXIT:
1843     FunctionOut();
1844
1845     return ret;
1846 }
1847
1848 OMX_ERRORTYPE Exynos_Mpeg2Dec_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
1849 {
1850     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1851     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1852     EXYNOS_MPEG2DEC_HANDLE    *pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1853     EXYNOS_OMX_BASEPORT     *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1854
1855     FunctionIn();
1856
1857     if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
1858         ret = OMX_ErrorNone;
1859         goto EXIT;
1860     }
1861     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
1862         ret = OMX_ErrorNone;
1863         goto EXIT;
1864     }
1865
1866     if ((pExynosOutputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
1867         if ((pMpeg2Dec->bDestinationStart == OMX_FALSE) &&
1868            (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
1869             Exynos_OSAL_SignalWait(pMpeg2Dec->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
1870             Exynos_OSAL_SignalReset(pMpeg2Dec->hDestinationStartEvent);
1871         }
1872     }
1873     ret = Exynos_Mpeg2Dec_DstOut(pOMXComponent, pDstOutputData);
1874     if ((ret != OMX_ErrorNone) &&
1875         (pExynosComponent->currentState == OMX_StateExecuting)) {
1876         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
1877                                                 pExynosComponent->callbackData,
1878                                                 OMX_EventError, ret, 0, NULL);
1879     }
1880
1881 EXIT:
1882     FunctionOut();
1883
1884     return ret;
1885 }
1886
1887 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(
1888     OMX_HANDLETYPE  hComponent,
1889     OMX_STRING      componentName)
1890 {
1891     OMX_ERRORTYPE                    ret                = OMX_ErrorNone;
1892     OMX_COMPONENTTYPE               *pOMXComponent      = NULL;
1893     EXYNOS_OMX_BASECOMPONENT        *pExynosComponent   = NULL;
1894     EXYNOS_OMX_BASEPORT             *pExynosPort        = NULL;
1895     EXYNOS_OMX_VIDEODEC_COMPONENT   *pVideoDec          = NULL;
1896     EXYNOS_MPEG2DEC_HANDLE            *pMpeg2Dec            = NULL;
1897     int i = 0;
1898
1899     FunctionIn();
1900
1901     if ((hComponent == NULL) || (componentName == NULL)) {
1902         ret = OMX_ErrorBadParameter;
1903         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
1904         goto EXIT;
1905     }
1906     if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_MPEG2_DEC, componentName) != 0) {
1907         ret = OMX_ErrorBadParameter;
1908         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
1909         goto EXIT;
1910     }
1911
1912     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1913     ret = Exynos_OMX_VideoDecodeComponentInit(pOMXComponent);
1914     if (ret != OMX_ErrorNone) {
1915         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
1916         goto EXIT;
1917     }
1918     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1919     pExynosComponent->codecType = HW_VIDEO_DEC_CODEC;
1920
1921     pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
1922     if (pExynosComponent->componentName == NULL) {
1923         Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
1924         ret = OMX_ErrorInsufficientResources;
1925         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
1926         goto EXIT;
1927     }
1928     Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
1929
1930     pMpeg2Dec = Exynos_OSAL_Malloc(sizeof(EXYNOS_MPEG2DEC_HANDLE));
1931     if (pMpeg2Dec == NULL) {
1932         Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
1933         ret = OMX_ErrorInsufficientResources;
1934         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
1935         goto EXIT;
1936     }
1937     Exynos_OSAL_Memset(pMpeg2Dec, 0, sizeof(EXYNOS_MPEG2DEC_HANDLE));
1938     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
1939     pVideoDec->hCodecHandle = (OMX_HANDLETYPE)pMpeg2Dec;
1940
1941     Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_MPEG2_DEC);
1942
1943     /* Set componentVersion */
1944     pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
1945     pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
1946     pExynosComponent->componentVersion.s.nRevision     = REVISION_NUMBER;
1947     pExynosComponent->componentVersion.s.nStep         = STEP_NUMBER;
1948     /* Set specVersion */
1949     pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
1950     pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
1951     pExynosComponent->specVersion.s.nRevision     = REVISION_NUMBER;
1952     pExynosComponent->specVersion.s.nStep         = STEP_NUMBER;
1953
1954     /* Input port */
1955     pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1956     pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
1957     pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
1958     pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
1959     pExynosPort->portDefinition.format.video.nSliceHeight = 0;
1960     pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
1961     pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG2;
1962     Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
1963     Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/mpeg2");
1964     pExynosPort->portDefinition.format.video.pNativeRender = 0;
1965     pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
1966     pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
1967     pExynosPort->portDefinition.bEnabled = OMX_TRUE;
1968     //pExynosPort->bufferProcessType = BUFFER_SHARE;
1969     pExynosPort->bufferProcessType = BUFFER_COPY;
1970     pExynosPort->portWayType = WAY2_PORT;
1971
1972     /* Output port */
1973     pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1974     pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
1975     pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
1976     pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
1977     pExynosPort->portDefinition.format.video.nSliceHeight = 0;
1978     pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
1979     pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
1980     Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
1981     Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
1982     pExynosPort->portDefinition.format.video.pNativeRender = 0;
1983     pExynosPort->portDefinition.format.video.bFlagErrorConcealment = OMX_FALSE;
1984     pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
1985     pExynosPort->portDefinition.bEnabled = OMX_TRUE;
1986 #ifdef TIZEN_FEATURE_E3250
1987     pExynosPort->bufferProcessType = BUFFER_SHARE;
1988 #else
1989     pExynosPort->bufferProcessType = BUFFER_COPY | BUFFER_PBSHARE;
1990 #endif
1991     pExynosPort->portWayType = WAY2_PORT;
1992
1993     for(i = 0; i < ALL_PORT_NUM; i++) {
1994         INIT_SET_SIZE_VERSION(&pMpeg2Dec->Mpeg2Component[i], OMX_VIDEO_PARAM_MPEG2TYPE);
1995         pMpeg2Dec->Mpeg2Component[i].nPortIndex = i;
1996         pMpeg2Dec->Mpeg2Component[i].eProfile = OMX_VIDEO_MPEG2ProfileMain;
1997         pMpeg2Dec->Mpeg2Component[i].eLevel = OMX_VIDEO_MPEG2LevelML; /* Check again**** */
1998     }
1999
2000     pOMXComponent->GetParameter      = &Exynos_Mpeg2Dec_GetParameter;
2001     pOMXComponent->SetParameter      = &Exynos_Mpeg2Dec_SetParameter;
2002     pOMXComponent->GetConfig         = &Exynos_Mpeg2Dec_GetConfig;
2003     pOMXComponent->SetConfig         = &Exynos_Mpeg2Dec_SetConfig;
2004     pOMXComponent->GetExtensionIndex = &Exynos_Mpeg2Dec_GetExtensionIndex;
2005     pOMXComponent->ComponentRoleEnum = &Exynos_Mpeg2Dec_ComponentRoleEnum;
2006     pOMXComponent->ComponentDeInit   = &Exynos_OMX_ComponentDeinit;
2007
2008     pExynosComponent->exynos_codec_componentInit      = &Exynos_Mpeg2Dec_Init;
2009     pExynosComponent->exynos_codec_componentTerminate = &Exynos_Mpeg2Dec_Terminate;
2010
2011     pVideoDec->exynos_codec_srcInputProcess  = &Exynos_Mpeg2Dec_srcInputBufferProcess;
2012     pVideoDec->exynos_codec_srcOutputProcess = &Exynos_Mpeg2Dec_srcOutputBufferProcess;
2013     pVideoDec->exynos_codec_dstInputProcess  = &Exynos_Mpeg2Dec_dstInputBufferProcess;
2014     pVideoDec->exynos_codec_dstOutputProcess = &Exynos_Mpeg2Dec_dstOutputBufferProcess;
2015
2016     pVideoDec->exynos_codec_start         = &Mpeg2CodecStart;
2017     pVideoDec->exynos_codec_stop          = &Mpeg2CodecStop;
2018     pVideoDec->exynos_codec_bufferProcessRun = &Mpeg2CodecOutputBufferProcessRun;
2019     pVideoDec->exynos_codec_enqueueAllBuffer = &Mpeg2CodecEnQueueAllBuffer;
2020
2021     pVideoDec->exynos_checkInputFrame                 = NULL;
2022     pVideoDec->exynos_codec_getCodecInputPrivateData  = &GetCodecInputPrivateData;
2023     pVideoDec->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2024
2025 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2026     pVideoDec->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2027     if (pVideoDec->hSharedMemory == NULL) {
2028         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2029         Exynos_OSAL_Free(pMpeg2Dec);
2030         pMpeg2Dec = ((EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2031         Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2032         ret = OMX_ErrorInsufficientResources;
2033         goto EXIT;
2034     }
2035 #endif
2036     pExynosComponent->currentState = OMX_StateLoaded;
2037
2038     ret = OMX_ErrorNone;
2039
2040 EXIT:
2041     FunctionOut();
2042
2043     return ret;
2044 }
2045
2046 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(
2047     OMX_HANDLETYPE hComponent)
2048 {
2049     OMX_ERRORTYPE                ret                = OMX_ErrorNone;
2050     OMX_COMPONENTTYPE           *pOMXComponent      = NULL;
2051     EXYNOS_OMX_BASECOMPONENT    *pExynosComponent   = NULL;
2052     EXYNOS_OMX_VIDEODEC_COMPONENT *pVideoDec = NULL;
2053     EXYNOS_MPEG2DEC_HANDLE        *pMpeg2Dec            = NULL;
2054
2055     FunctionIn();
2056
2057     if (hComponent == NULL) {
2058         ret = OMX_ErrorBadParameter;
2059         goto EXIT;
2060     }
2061     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2062     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2063     pVideoDec = (EXYNOS_OMX_VIDEODEC_COMPONENT *)pExynosComponent->hComponentHandle;
2064 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2065     Exynos_OSAL_SharedMemory_Close(pVideoDec->hSharedMemory);
2066 #endif
2067     Exynos_OSAL_Free(pExynosComponent->componentName);
2068     pExynosComponent->componentName = NULL;
2069
2070     pMpeg2Dec = (EXYNOS_MPEG2DEC_HANDLE *)pVideoDec->hCodecHandle;
2071     if (pMpeg2Dec != NULL) {
2072         Exynos_OSAL_Free(pMpeg2Dec);
2073         pMpeg2Dec = pVideoDec->hCodecHandle = NULL;
2074     }
2075
2076     ret = Exynos_OMX_VideoDecodeComponentDeinit(pOMXComponent);
2077     if (ret != OMX_ErrorNone) {
2078         goto EXIT;
2079     }
2080
2081     ret = OMX_ErrorNone;
2082
2083 EXIT:
2084     FunctionOut();
2085
2086     return ret;
2087 }