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