openmax/component/video/dec/h264/Exynos_OMX_H264dec.c

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