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