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

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