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