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