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