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