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