openmax/component/video/enc/h264/Exynos_OMX_H264enc.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_H264enc.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
  31 #include "Exynos_OMX_Macros.h"
  32 #include "Exynos_OMX_Basecomponent.h"
  33 #include "Exynos_OMX_Baseport.h"
  34 #include "Exynos_OMX_Venc.h"
  35 #include "Exynos_OSAL_ETC.h"
  36 #include "Exynos_OSAL_Semaphore.h"
  37 #include "Exynos_OSAL_Thread.h"
  38 #include "library_register.h"
  39 #include "Exynos_OMX_H264enc.h"
  40 //#include "ExynosVideoApi.h"
  41 #include "Exynos_OSAL_SharedMemory.h"
  42 #include "Exynos_OSAL_Event.h"
  43 #include "Exynos_OMX_VencControl.h"
  44
  45 /* To use CSC_METHOD_HW in EXYNOS OMX, gralloc should allocate physical memory using FIMC */
  46 /* It means GRALLOC_USAGE_HW_FIMC1 should be set on Native Window usage */
  47 #include "csc.h"
  48
  49 #undef  EXYNOS_LOG_TAG
  50 #define EXYNOS_LOG_TAG    "EXYNOS_H264_ENC"
  51 #define EXYNOS_LOG_OFF
  52 //#define EXYNOS_TRACE_ON
  53 #include "Exynos_OSAL_Log.h"
  54
  55 /* H.264 Encoder Supported Levels & profiles */
  56 EXYNOS_OMX_VIDEO_PROFILELEVEL supportedAVCProfileLevels[] ={
  57     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1},
  58     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1b},
  59     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel11},
  60     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel12},
  61     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13},
  62     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2},
  63     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel21},
  64     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel22},
  65     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel3},
  66     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel31},
  67     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel32},
  68     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel4},
  69     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel41},
  70     {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel42},
  71
  72     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1},
  73     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel1b},
  74     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel11},
  75     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel12},
  76     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel13},
  77     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel2},
  78     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel21},
  79     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel22},
  80     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel3},
  81     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel31},
  82     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel32},
  83     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel4},
  84     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel41},
  85     {OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel42},
  86
  87     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1},
  88     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel1b},
  89     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel11},
  90     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel12},
  91     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel13},
  92     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel2},
  93     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel21},
  94     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel22},
  95     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel3},
  96     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel31},
  97     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel32},
  98     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel4},
  99     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel41},
 100     {OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel42}};
 101
 102 static OMX_U32 OMXAVCProfileToProfileIDC(OMX_VIDEO_AVCPROFILETYPE profile)
 103 {
 104     OMX_U32 ret = 0;
 105
 106     if (profile == OMX_VIDEO_AVCProfileBaseline)
 107         ret = 0;
 108     else if (profile == OMX_VIDEO_AVCProfileMain)
 109         ret = 2;
 110     else if (profile == OMX_VIDEO_AVCProfileHigh)
 111         ret = 4;
 112
 113     return ret;
 114 }
 115
 116 static OMX_U32 OMXAVCLevelToLevelIDC(OMX_VIDEO_AVCLEVELTYPE level)
 117 {
 118     OMX_U32 ret = 11; //default OMX_VIDEO_AVCLevel4
 119
 120     if (level == OMX_VIDEO_AVCLevel1)
 121         ret = 0;
 122     else if (level == OMX_VIDEO_AVCLevel1b)
 123         ret = 1;
 124     else if (level == OMX_VIDEO_AVCLevel11)
 125         ret = 2;
 126     else if (level == OMX_VIDEO_AVCLevel12)
 127         ret = 3;
 128     else if (level == OMX_VIDEO_AVCLevel13)
 129         ret = 4;
 130     else if (level == OMX_VIDEO_AVCLevel2)
 131         ret = 5;
 132     else if (level == OMX_VIDEO_AVCLevel21)
 133         ret = 6;
 134     else if (level == OMX_VIDEO_AVCLevel22)
 135         ret = 7;
 136     else if (level == OMX_VIDEO_AVCLevel3)
 137         ret = 8;
 138     else if (level == OMX_VIDEO_AVCLevel31)
 139         ret = 9;
 140     else if (level == OMX_VIDEO_AVCLevel32)
 141         ret = 10;
 142     else if (level == OMX_VIDEO_AVCLevel4)
 143         ret = 11;
 144     else if (level == OMX_VIDEO_AVCLevel41)
 145         ret = 12;
 146     else if (level == OMX_VIDEO_AVCLevel42)
 147         ret = 13;
 148
 149     return ret;
 150 }
 151
 152 static OMX_U8 *FindDelimiter(OMX_U8 *pBuffer, OMX_U32 size)
 153 {
 154     OMX_U32 i;
 155
 156     for (i = 0; i < size - 3; i++) {
 157         if ((pBuffer[i] == 0x00)   &&
 158             (pBuffer[i + 1] == 0x00) &&
 159             (pBuffer[i + 2] == 0x00) &&
 160             (pBuffer[i + 3] == 0x01))
 161             return (pBuffer + i);
 162     }
 163
 164     return NULL;
 165 }
 166
 167 static void Print_H264Enc_Param(ExynosVideoEncParam *pEncParam)
 168 {
 169     ExynosVideoEncCommonParam *pCommonParam = &pEncParam->commonParam;
 170     ExynosVideoEncH264Param   *pH264Param   = &pEncParam->codecParam.h264;
 171
 172     /* common parameters */
 173     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SourceWidth             : %d", pCommonParam->SourceWidth);
 174     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SourceHeight            : %d", pCommonParam->SourceHeight);
 175     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "IDRPeriod               : %d", pCommonParam->IDRPeriod);
 176     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SliceMode               : %d", pCommonParam->SliceMode);
 177     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "RandomIntraMBRefresh    : %d", pCommonParam->RandomIntraMBRefresh);
 178     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Bitrate                 : %d", pCommonParam->Bitrate);
 179     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp                 : %d", pCommonParam->FrameQp);
 180     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp_P               : %d", pCommonParam->FrameQp_P);
 181     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "QSCodeMax              : %d", pCommonParam->QSCodeMax);
 182     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "QSCodeMin               : %d", pCommonParam->QSCodeMin);
 183     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "PadControlOn            : %d", pCommonParam->PadControlOn);
 184     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "LumaPadVal              : %d", pCommonParam->LumaPadVal);
 185     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CbPadVal                : %d", pCommonParam->CbPadVal);
 186     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CrPadVal                : %d", pCommonParam->CrPadVal);
 187     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameMap                : %d", pCommonParam->FrameMap);
 188
 189     /* H.264 specific parameters */
 190     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "ProfileIDC              : %d", pH264Param->ProfileIDC);
 191     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "LevelIDC                : %d", pH264Param->LevelIDC);
 192     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameQp_B               : %d", pH264Param->FrameQp_B);
 193     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "FrameRate               : %d", pH264Param->FrameRate);
 194     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SliceArgument           : %d", pH264Param->SliceArgument);
 195     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NumberBFrames           : %d", pH264Param->NumberBFrames);
 196     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NumberReferenceFrames   : %d", pH264Param->NumberReferenceFrames);
 197     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "NumberRefForPframes     : %d", pH264Param->NumberRefForPframes);
 198     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "LoopFilterDisable       : %d", pH264Param->LoopFilterDisable);
 199     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "LoopFilterAlphaC0Offset : %d", pH264Param->LoopFilterAlphaC0Offset);
 200     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "LoopFilterBetaOffset    : %d", pH264Param->LoopFilterBetaOffset);
 201     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SymbolMode              : %d", pH264Param->SymbolMode);
 202     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "PictureInterlace        : %d", pH264Param->PictureInterlace);
 203     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Transform8x8Mode        : %d", pH264Param->Transform8x8Mode);
 204     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "DarkDisable             : %d", pH264Param->DarkDisable);
 205     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SmoothDisable           : %d", pH264Param->SmoothDisable);
 206     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "StaticDisable           : %d", pH264Param->StaticDisable);
 207     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "ActivityDisable         : %d", pH264Param->ActivityDisable);
 208
 209     /* rate control related parameters */
 210     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "EnableFRMRateControl    : %d", pCommonParam->EnableFRMRateControl);
 211     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "EnableMBRateControl     : %d", pCommonParam->EnableMBRateControl);
 212     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "CBRPeriodRf             : %d", pCommonParam->CBRPeriodRf);
 213 }
 214
 215 static void Set_H264Enc_Param(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
 216 {
 217     EXYNOS_OMX_BASEPORT           *pExynosInputPort  = NULL;
 218     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = NULL;
 219     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc         = NULL;
 220     EXYNOS_H264ENC_HANDLE         *pH264Enc          = NULL;
 221     EXYNOS_MFC_H264ENC_HANDLE     *pMFCH264Handle    = NULL;
 222
 223     ExynosVideoEncParam       *pEncParam    = NULL;
 224     ExynosVideoEncCommonParam *pCommonParam = NULL;
 225     ExynosVideoEncH264Param   *pH264Param   = NULL;
 226
 227     pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
 228     pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 229     pMFCH264Handle = &pH264Enc->hMFCH264Handle;
 230     pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 231     pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 232
 233     pEncParam = &pMFCH264Handle->encParam;
 234     pCommonParam = &pEncParam->commonParam;
 235     pH264Param = &pEncParam->codecParam.h264;
 236     pEncParam->eCompressionFormat = VIDEO_CODING_AVC;
 237     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "eCompressionFormat: %d", pEncParam->eCompressionFormat);
 238
 239     /* common parameters */
 240     pCommonParam->SourceWidth  = pExynosOutputPort->portDefinition.format.video.nFrameWidth;
 241     pCommonParam->SourceHeight = pExynosOutputPort->portDefinition.format.video.nFrameHeight;
 242     pCommonParam->IDRPeriod    = pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames + 1;
 243     pCommonParam->SliceMode = pH264Enc->AVCSliceFmo.eSliceMode;
 244     pCommonParam->RandomIntraMBRefresh = 0;
 245     pCommonParam->Bitrate      = pExynosOutputPort->portDefinition.format.video.nBitrate;
 246     pCommonParam->FrameQp      = pVideoEnc->quantization.nQpI;
 247     pCommonParam->FrameQp_P    = pVideoEnc->quantization.nQpP;
 248     pCommonParam->QSCodeMax    = 51;
 249     pCommonParam->QSCodeMin    = 10;
 250     pCommonParam->PadControlOn = 0;    /* 0: disable, 1: enable */
 251     pCommonParam->LumaPadVal   = 0;
 252     pCommonParam->CbPadVal     = 0;
 253     pCommonParam->CrPadVal     = 0;
 254
 255     switch ((EXYNOS_OMX_COLOR_FORMATTYPE)pExynosInputPort->portDefinition.format.video.eColorFormat) {
 256     case OMX_COLOR_FormatYUV420SemiPlanar:
 257     case OMX_COLOR_FormatYUV420Planar: /* Converted to NV12 in Exynos_Preprocessor_InputData */
 258     case OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd:
 259 #ifdef USE_METADATABUFFERTYPE
 260     case OMX_COLOR_FormatAndroidOpaque:
 261 #endif
 262         pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12;
 263         break;
 264     case OMX_SEC_COLOR_FormatNV12Tiled:
 265     case OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd:
 266         pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12_TILED;
 267         break;
 268     case OMX_SEC_COLOR_FormatNV21Linear:
 269         pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV21;
 270         break;
 271     default:
 272         pCommonParam->FrameMap = VIDEO_COLORFORMAT_NV12_TILED;
 273         break;
 274     }
 275
 276     /* H.264 specific parameters */
 277     pH264Param->ProfileIDC   = OMXAVCProfileToProfileIDC(pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].eProfile);    /*0: OMX_VIDEO_AVCProfileMain */
 278     pH264Param->LevelIDC     = OMXAVCLevelToLevelIDC(pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].eLevel);    /*40: OMX_VIDEO_AVCLevel4 */
 279     pH264Param->FrameQp_B    = pVideoEnc->quantization.nQpB;
 280     pH264Param->FrameRate    = (pExynosInputPort->portDefinition.format.video.xFramerate) >> 16;
 281     if (pH264Enc->AVCSliceFmo.eSliceMode == OMX_VIDEO_SLICEMODE_AVCDefault)
 282         pH264Param->SliceArgument = 0;    /* Slice mb/byte size number */
 283     else
 284         pH264Param->SliceArgument = pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nSliceHeaderSpacing;
 285
 286     pH264Param->NumberBFrames = 0;    /* 0 ~ 2 */
 287     pH264Param->NumberReferenceFrames = 1;
 288     pH264Param->NumberRefForPframes   = 1;
 289 #ifdef TIZEN_FEATURE_E3250 /* for B2 camera */
 290     pH264Param->LoopFilterDisable     = 0;    /* 1: Loop Filter Disable, 0: Filter Enable */
 291 #else
 292     pH264Param->LoopFilterDisable     = 1;    /* 1: Loop Filter Disable, 0: Filter Enable */
 293 #endif
 294     pH264Param->LoopFilterAlphaC0Offset = 0;
 295     pH264Param->LoopFilterBetaOffset    = 0;
 296     pH264Param->SymbolMode       = 0;    /* 0: CAVLC, 1: CABAC */
 297     pH264Param->PictureInterlace = 0;
 298     pH264Param->Transform8x8Mode = 0;    /* 0: 4x4, 1: allow 8x8 */
 299     pH264Param->DarkDisable     = 1;
 300     pH264Param->SmoothDisable   = 1;
 301     pH264Param->StaticDisable   = 1;
 302     pH264Param->ActivityDisable = 1;
 303
 304     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]: 0x%x", pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]);
 305     /* rate control related parameters */
 306     switch (pVideoEnc->eControlRate[OUTPUT_PORT_INDEX]) {
 307     case OMX_Video_ControlRateDisable:
 308         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode DBR");
 309         pCommonParam->EnableFRMRateControl = 0;    /* 0: Disable, 1: Frame level RC */
 310         pCommonParam->EnableMBRateControl  = 0;    /* 0: Disable, 1:MB level RC */
 311         pCommonParam->CBRPeriodRf          = 100;
 312         break;
 313     case OMX_Video_ControlRateConstant:
 314         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode CBR");
 315         pCommonParam->EnableFRMRateControl = 1;    /* 0: Disable, 1: Frame level RC */
 316         pCommonParam->EnableMBRateControl  = 1;    /* 0: Disable, 1:MB level RC */
 317         pCommonParam->CBRPeriodRf          = 9;
 318         break;
 319     case OMX_Video_ControlRateVariable:
 320     default: /*Android default */
 321         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Video Encode VBR");
 322         pCommonParam->EnableFRMRateControl = 1;    /* 0: Disable, 1: Frame level RC */
 323         pCommonParam->EnableMBRateControl  = 1;    /* 0: Disable, 1:MB level RC */
 324         pCommonParam->CBRPeriodRf          = 100;
 325         break;
 326     }
 327
 328     Print_H264Enc_Param(pEncParam);
 329 }
 330
 331 static void Change_H264Enc_Param(EXYNOS_OMX_BASECOMPONENT *pExynosComponent)
 332 {
 333     EXYNOS_OMX_BASEPORT           *pExynosInputPort  = NULL;
 334     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = NULL;
 335     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc         = NULL;
 336     EXYNOS_H264ENC_HANDLE         *pH264Enc          = NULL;
 337     EXYNOS_MFC_H264ENC_HANDLE     *pMFCH264Handle    = NULL;
 338
 339     ExynosVideoEncOps         *pEncOps      = NULL;
 340     ExynosVideoEncParam       *pEncParam    = NULL;
 341     ExynosVideoEncCommonParam *pCommonParam = NULL;
 342     ExynosVideoEncH264Param   *pH264Param   = NULL;
 343
 344     int setParam = 0;
 345
 346     pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
 347     pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 348     pMFCH264Handle = &pH264Enc->hMFCH264Handle;
 349     pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 350     pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 351     pEncOps = pMFCH264Handle->pEncOps;
 352
 353     pEncParam = &pMFCH264Handle->encParam;
 354     pCommonParam = &pEncParam->commonParam;
 355     pH264Param = &pEncParam->codecParam.h264;
 356
 357     if (pVideoEnc->IntraRefreshVOP == OMX_TRUE) {
 358         setParam = VIDEO_FRAME_I;
 359         pEncOps->Set_FrameType(pH264Enc->hMFCH264Handle.hMFCHandle, setParam);
 360         pVideoEnc->IntraRefreshVOP = OMX_FALSE;
 361     }
 362     if (pCommonParam->IDRPeriod != (int)pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames + 1) {
 363         setParam = pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames + 1;
 364         pEncOps->Set_IDRPeriod(pH264Enc->hMFCH264Handle.hMFCHandle, setParam);
 365     }
 366     if (pCommonParam->Bitrate != (int)pExynosOutputPort->portDefinition.format.video.nBitrate) {
 367         setParam = pExynosOutputPort->portDefinition.format.video.nBitrate;
 368         pEncOps->Set_BitRate(pH264Enc->hMFCH264Handle.hMFCHandle, setParam);
 369     }
 370     if (pH264Param->FrameRate != (int)((pExynosInputPort->portDefinition.format.video.xFramerate) >> 16)) {
 371         setParam = (pExynosInputPort->portDefinition.format.video.xFramerate) >> 16;
 372         pEncOps->Set_FrameRate(pH264Enc->hMFCH264Handle.hMFCHandle, setParam);
 373     }
 374
 375     Set_H264Enc_Param(pExynosComponent);
 376 }
 377
 378 OMX_ERRORTYPE GetCodecInputPrivateData(OMX_PTR codecBuffer, OMX_PTR addr[], OMX_U32 size[])
 379 {
 380     return OMX_ErrorNone;
 381 }
 382
 383 OMX_ERRORTYPE GetCodecOutputPrivateData(OMX_PTR codecBuffer, OMX_PTR *pVirtAddr, OMX_U32 *dataSize)
 384 {
 385     OMX_ERRORTYPE       ret = OMX_ErrorNone;
 386     ExynosVideoBuffer  *pCodecBuffer;
 387
 388     if (codecBuffer == NULL) {
 389         ret = OMX_ErrorBadParameter;
 390         goto EXIT;
 391     }
 392
 393     pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
 394
 395     if (pVirtAddr != NULL)
 396         *pVirtAddr = pCodecBuffer->planes[0].addr;
 397
 398     if (dataSize != NULL)
 399         *dataSize = pCodecBuffer->planes[0].allocSize;
 400
 401     pCodecBuffer = (ExynosVideoBuffer *)codecBuffer;
 402
 403 EXIT:
 404     return ret;
 405 }
 406
 407 OMX_ERRORTYPE H264CodecOpen(EXYNOS_H264ENC_HANDLE *pH264Enc)
 408 {
 409     OMX_ERRORTYPE           ret = OMX_ErrorNone;
 410
 411     ExynosVideoEncOps       *pEncOps    = NULL;
 412     ExynosVideoEncBufferOps *pInbufOps  = NULL;
 413     ExynosVideoEncBufferOps *pOutbufOps = NULL;
 414     enum v4l2_memory         v4l2MemoryType = V4L2_MEMORY_USERPTR;
 415
 416     FunctionIn();
 417
 418     if (pH264Enc == NULL) {
 419         ret = OMX_ErrorBadParameter;
 420         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
 421         goto EXIT;
 422     }
 423
 424     /* alloc ops structure */
 425     pEncOps = (ExynosVideoEncOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncOps));
 426     pInbufOps = (ExynosVideoEncBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncBufferOps));
 427     pOutbufOps = (ExynosVideoEncBufferOps *)Exynos_OSAL_Malloc(sizeof(ExynosVideoEncBufferOps));
 428
 429     if ((pEncOps == NULL) || (pInbufOps == NULL) || (pOutbufOps == NULL)) {
 430         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate encoder ops buffer");
 431         ret = OMX_ErrorInsufficientResources;
 432         goto EXIT;
 433     }
 434
 435     pH264Enc->hMFCH264Handle.pEncOps = pEncOps;
 436     pH264Enc->hMFCH264Handle.pInbufOps = pInbufOps;
 437     pH264Enc->hMFCH264Handle.pOutbufOps = pOutbufOps;
 438
 439     /* function pointer mapping */
 440     pEncOps->nSize = sizeof(ExynosVideoEncOps);
 441     pInbufOps->nSize = sizeof(ExynosVideoEncBufferOps);
 442     pOutbufOps->nSize = sizeof(ExynosVideoEncBufferOps);
 443
 444     Exynos_Video_Register_Encoder(pEncOps, pInbufOps, pOutbufOps);
 445
 446     /* check mandatory functions for encoder ops */
 447     if ((pEncOps->Init == NULL) || (pEncOps->Finalize == NULL) ||
 448         (pEncOps->Set_FrameTag == NULL) || (pEncOps->Get_FrameTag == NULL)) {
 449         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
 450         ret = OMX_ErrorInsufficientResources;
 451         goto EXIT;
 452     }
 453
 454     /* check mandatory functions for buffer ops */
 455     if ((pInbufOps->Setup == NULL) || (pOutbufOps->Setup == NULL) ||
 456         (pInbufOps->Run == NULL) || (pOutbufOps->Run == NULL) ||
 457         (pInbufOps->Stop == NULL) || (pOutbufOps->Stop == NULL) ||
 458         (pInbufOps->Enqueue == NULL) || (pOutbufOps->Enqueue == NULL) ||
 459         (pInbufOps->Dequeue == NULL) || (pOutbufOps->Dequeue == NULL)) {
 460         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Mandatory functions must be supplied");
 461         ret = OMX_ErrorInsufficientResources;
 462         goto EXIT;
 463     }
 464
 465     if (pH264Enc->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
 466 #ifdef USE_DMA_BUF
 467         v4l2MemoryType = V4L2_MEMORY_DMABUF;
 468         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Enc V4L2_MEMORY_DMABUF");
 469 #else
 470         v4l2MemoryType = V4L2_MEMORY_USERPTR;
 471         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Enc V4L2_MEMORY_USEPTR");
 472 #endif
 473     } else {
 474         //v4l2MemoryType = V4L2_MEMORY_MMAP;
 475         v4l2MemoryType = V4L2_MEMORY_DMABUF; //if input port is using Buffer-share mode
 476         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "using Enc V4L2_MEMORY - DMABUF & MMAP");
 477     }
 478
 479     /* alloc context, open, querycap */
 480     pH264Enc->hMFCH264Handle.hMFCHandle = pH264Enc->hMFCH264Handle.pEncOps->Init(v4l2MemoryType);
 481     if (pH264Enc->hMFCH264Handle.hMFCHandle == NULL) {
 482         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to allocate context buffer");
 483         ret = OMX_ErrorInsufficientResources;
 484         goto EXIT;
 485     }
 486
 487     ret = OMX_ErrorNone;
 488
 489 EXIT:
 490     if (ret != OMX_ErrorNone) {
 491         if (pEncOps != NULL) {
 492             Exynos_OSAL_Free(pEncOps);
 493             pH264Enc->hMFCH264Handle.pEncOps = NULL;
 494         }
 495         if (pInbufOps != NULL) {
 496             Exynos_OSAL_Free(pInbufOps);
 497             pH264Enc->hMFCH264Handle.pInbufOps = NULL;
 498         }
 499         if (pOutbufOps != NULL) {
 500             Exynos_OSAL_Free(pOutbufOps);
 501             pH264Enc->hMFCH264Handle.pOutbufOps = NULL;
 502         }
 503     }
 504
 505     FunctionOut();
 506
 507     return ret;
 508 }
 509
 510 OMX_ERRORTYPE H264CodecClose(EXYNOS_H264ENC_HANDLE *pH264Enc)
 511 {
 512     OMX_ERRORTYPE            ret = OMX_ErrorNone;
 513     void                    *hMFCHandle = NULL;
 514     ExynosVideoEncOps       *pEncOps    = NULL;
 515     ExynosVideoEncBufferOps *pInbufOps  = NULL;
 516     ExynosVideoEncBufferOps *pOutbufOps = NULL;
 517
 518     FunctionIn();
 519
 520     if (pH264Enc == NULL) {
 521         ret = OMX_ErrorBadParameter;
 522         goto EXIT;
 523     }
 524
 525     hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle;
 526     pEncOps    = pH264Enc->hMFCH264Handle.pEncOps;
 527     pInbufOps  = pH264Enc->hMFCH264Handle.pInbufOps;
 528     pOutbufOps = pH264Enc->hMFCH264Handle.pOutbufOps;
 529
 530     if (hMFCHandle != NULL) {
 531         pEncOps->Finalize(hMFCHandle);
 532         hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle = NULL;
 533     }
 534     if (pOutbufOps != NULL) {
 535         Exynos_OSAL_Free(pOutbufOps);
 536         pOutbufOps = pH264Enc->hMFCH264Handle.pOutbufOps = NULL;
 537     }
 538     if (pInbufOps != NULL) {
 539         Exynos_OSAL_Free(pInbufOps);
 540         pInbufOps = pH264Enc->hMFCH264Handle.pInbufOps = NULL;
 541     }
 542     if (pEncOps != NULL) {
 543         Exynos_OSAL_Free(pEncOps);
 544         pEncOps = pH264Enc->hMFCH264Handle.pEncOps = NULL;
 545     }
 546
 547     ret = OMX_ErrorNone;
 548
 549 EXIT:
 550     FunctionOut();
 551
 552     return ret;
 553 }
 554
 555 OMX_ERRORTYPE H264CodecStart(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 556 {
 557     OMX_ERRORTYPE            ret = OMX_ErrorNone;
 558     void                    *hMFCHandle = NULL;
 559     ExynosVideoEncBufferOps *pInbufOps  = NULL;
 560     ExynosVideoEncBufferOps *pOutbufOps = NULL;
 561     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
 562     EXYNOS_H264ENC_HANDLE   *pH264Enc = NULL;
 563
 564     FunctionIn();
 565
 566     if (pOMXComponent == NULL) {
 567         ret = OMX_ErrorBadParameter;
 568         goto EXIT;
 569     }
 570
 571     pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
 572     if (pVideoEnc == NULL) {
 573         ret = OMX_ErrorBadParameter;
 574         goto EXIT;
 575     }
 576
 577     pH264Enc = (EXYNOS_H264ENC_HANDLE *)pVideoEnc->hCodecHandle;
 578     if (pH264Enc == NULL) {
 579         ret = OMX_ErrorBadParameter;
 580         goto EXIT;
 581     }
 582
 583     hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle;
 584     pInbufOps  = pH264Enc->hMFCH264Handle.pInbufOps;
 585     pOutbufOps = pH264Enc->hMFCH264Handle.pOutbufOps;
 586
 587     if (nPortIndex == INPUT_PORT_INDEX)
 588         pInbufOps->Run(hMFCHandle);
 589     else if (nPortIndex == OUTPUT_PORT_INDEX)
 590         pOutbufOps->Run(hMFCHandle);
 591
 592     ret = OMX_ErrorNone;
 593
 594 EXIT:
 595     FunctionOut();
 596
 597     return ret;
 598 }
 599
 600 OMX_ERRORTYPE H264CodecStop(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 601 {
 602     OMX_ERRORTYPE            ret = OMX_ErrorNone;
 603
 604         void                    *hMFCHandle = NULL;
 605     ExynosVideoEncBufferOps *pOutbufOps = NULL;
 606     ExynosVideoEncBufferOps *pInbufOps  = NULL;
 607     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
 608     EXYNOS_H264ENC_HANDLE   *pH264Enc = NULL;
 609
 610     FunctionIn();
 611
 612     if (pOMXComponent == NULL) {
 613         ret = OMX_ErrorBadParameter;
 614         goto EXIT;
 615     }
 616
 617     pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
 618     if (pVideoEnc == NULL) {
 619         ret = OMX_ErrorBadParameter;
 620         goto EXIT;
 621     }
 622     pH264Enc = (EXYNOS_H264ENC_HANDLE *)pVideoEnc->hCodecHandle;
 623     if (pH264Enc == NULL) {
 624         ret = OMX_ErrorBadParameter;
 625         goto EXIT;
 626     }
 627     hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle;
 628     pInbufOps  = pH264Enc->hMFCH264Handle.pInbufOps;
 629     pOutbufOps = pH264Enc->hMFCH264Handle.pOutbufOps;
 630
 631     if ((nPortIndex == INPUT_PORT_INDEX) && (pInbufOps != NULL))
 632         pInbufOps->Stop(hMFCHandle);
 633     else if ((nPortIndex == OUTPUT_PORT_INDEX) && (pOutbufOps != NULL))
 634         pOutbufOps->Stop(hMFCHandle);
 635
 636     ret = OMX_ErrorNone;
 637
 638 EXIT:
 639     FunctionOut();
 640
 641     return ret;
 642 }
 643
 644 OMX_ERRORTYPE H264CodecSrcInit(OMX_COMPONENTTYPE *pOMXComponent)
 645 {
 646     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 647     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 648     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
 649     EXYNOS_H264ENC_HANDLE         *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 650     EXYNOS_MFC_H264ENC_HANDLE     *pMFCH264Handle    = &pH264Enc->hMFCH264Handle;
 651     void                          *hMFCHandle = pMFCH264Handle->hMFCHandle;
 652     EXYNOS_OMX_BASEPORT           *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 653
 654     ExynosVideoEncOps       *pEncOps    = pH264Enc->hMFCH264Handle.pEncOps;
 655     ExynosVideoEncBufferOps *pInbufOps  = pH264Enc->hMFCH264Handle.pInbufOps;
 656     ExynosVideoEncParam     *pEncParam    = NULL;
 657
 658     ExynosVideoGeometry      bufferConf;
 659     OMX_U32                  inputBufferNumber = 0;
 660     int i;
 661
 662     FunctionIn();
 663
 664     Set_H264Enc_Param(pExynosComponent);
 665     pEncParam = &pMFCH264Handle->encParam;
 666     if (pEncOps->Set_EncParam) {
 667         if(pEncOps->Set_EncParam(pH264Enc->hMFCH264Handle.hMFCHandle, pEncParam) != VIDEO_ERROR_NONE) {
 668             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
 669             ret = OMX_ErrorInsufficientResources;
 670             goto EXIT;
 671         }
 672     }
 673
 674     if (pMFCH264Handle->bPrependSpsPpsToIdr == OMX_TRUE) {
 675         if (pEncOps->Enable_PrependSpsPpsToIdr)
 676             pEncOps->Enable_PrependSpsPpsToIdr(pH264Enc->hMFCH264Handle.hMFCHandle);
 677     }
 678
 679     /* input buffer info: only 3 config values needed */
 680     Exynos_OSAL_Memset(&bufferConf, 0, sizeof(bufferConf));
 681     bufferConf.eColorFormat = pEncParam->commonParam.FrameMap;;
 682     bufferConf.nFrameWidth = pExynosInputPort->portDefinition.format.video.nFrameWidth;
 683     bufferConf.nFrameHeight = pExynosInputPort->portDefinition.format.video.nFrameHeight;
 684
 685     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "bufferConf, eColorFormat=%d, w=%d, h=%d", bufferConf.eColorFormat, bufferConf.nFrameWidth, bufferConf.nFrameHeight);
 686
 687     if (pExynosInputPort->bufferProcessType & BUFFER_SHARE
 688         ||pH264Enc->hMFCH264Handle.bShareableBuf == OMX_TRUE)
 689         pInbufOps->Set_Shareable(hMFCHandle);
 690
 691     if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
 692         inputBufferNumber = MAX_CAMERA_INPUTBUFFER_NUM; /* Need change to number of camera buffer */
 693     } else if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
 694         inputBufferNumber = MFC_INPUT_BUFFER_NUM_MAX;
 695     }
 696
 697     if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
 698         /* should be done before prepare input buffer */
 699         if (pInbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
 700             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set Enable_Cacheable for input buffer");
 701             ret = OMX_ErrorInsufficientResources;
 702             goto EXIT;
 703         }
 704     }
 705
 706     /* set input buffer geometry */
 707     if (pInbufOps->Set_Geometry) {
 708
 709         if (pInbufOps->Set_Geometry(hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
 710             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for input buffer");
 711             ret = OMX_ErrorInsufficientResources;
 712             goto EXIT;
 713         }
 714     }
 715
 716     /* setup input buffer */
 717     if (pInbufOps->Setup(hMFCHandle, inputBufferNumber) != VIDEO_ERROR_NONE) {
 718         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup input buffer");
 719         ret = OMX_ErrorInsufficientResources;
 720         goto EXIT;
 721     }
 722
 723     ExynosVideoPlane planes[MFC_INPUT_BUFFER_PLANE];
 724     int plane;
 725
 726     if (pExynosInputPort->bufferProcessType & BUFFER_COPY &&
 727         pH264Enc->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
 728        /* Register input buffer */
 729         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
 730             for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
 731                 planes[plane].addr = pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane];
 732                 planes[plane].allocSize = pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[plane];
 733                 planes[plane].fd = pVideoEnc->pMFCEncInputBuffer[i]->fd[plane];
 734             }
 735             if (pInbufOps->Register(hMFCHandle, planes, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
 736                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
 737                 ret = OMX_ErrorInsufficientResources;
 738                 goto EXIT;
 739             }
 740         }
 741     } else if ((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
 742         pH264Enc->hMFCH264Handle.bShareableBuf == OMX_FALSE) {
 743         ExynosVideoBuffer *pBuffer = NULL;
 744
 745         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
 746                 pVideoEnc->pMFCEncInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER));
 747                 /* get input buffer info */
 748                 if (pInbufOps->Get_Buffer) {
 749                     if (pInbufOps->Get_Buffer(pH264Enc->hMFCH264Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
 750                         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
 751                         ret = OMX_ErrorInsufficientResources;
 752                         goto EXIT;
 753                     }
 754                 }
 755
 756                 for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
 757                      pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane] = (void *)pBuffer->planes[plane].addr;
 758                     pVideoEnc->pMFCEncInputBuffer[i]->fd[plane] = pBuffer->planes[plane].fd;
 759                     pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[plane] = pBuffer->planes[plane].allocSize;
 760                     pVideoEnc->pMFCEncInputBuffer[i]->dataSize = 0;
 761                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane]);
 762                 }
 763
 764                 Exynos_CodecBufferEnqueue(pExynosComponent, INPUT_PORT_INDEX, pVideoEnc->pMFCEncInputBuffer[i]);
 765             }
 766     } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
 767         if (pExynosInputPort->bStoreMetaData == OMX_TRUE) {
 768             /*************/
 769             /*    TBD    */
 770             /*************/
 771             /* Does not require any actions. */
 772         } else {
 773 #ifndef TIZEN_FEATURE_E3250 /* slp platform can go into here */
 774             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get input buffer info");
 775             ret = OMX_ErrorNotImplemented;
 776             goto EXIT;
 777 #endif
 778         }
 779     }
 780
 781 EXIT:
 782     FunctionOut();
 783
 784     return ret;
 785 }
 786
 787 OMX_ERRORTYPE H264CodecOutputBufferProcessRun(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 788 {
 789     OMX_ERRORTYPE            ret = OMX_ErrorNone;
 790     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
 791     EXYNOS_H264ENC_HANDLE   *pH264Enc = NULL;
 792
 793     FunctionIn();
 794
 795     if (pOMXComponent == NULL) {
 796         ret = OMX_ErrorBadParameter;
 797         goto EXIT;
 798     }
 799
 800     pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)((EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate)->hComponentHandle;
 801     if (pVideoEnc == NULL) {
 802         ret = OMX_ErrorBadParameter;
 803         goto EXIT;
 804     }
 805     pH264Enc = (EXYNOS_H264ENC_HANDLE *)pVideoEnc->hCodecHandle;
 806     if (pH264Enc == NULL) {
 807         ret = OMX_ErrorBadParameter;
 808         goto EXIT;
 809     }
 810
 811     if (nPortIndex == INPUT_PORT_INDEX) {
 812         if (pH264Enc->bSourceStart == OMX_FALSE) {
 813             Exynos_OSAL_SignalSet(pH264Enc->hSourceStartEvent);
 814             Exynos_OSAL_SleepMillisec(0);
 815         }
 816     }
 817
 818     if (nPortIndex == OUTPUT_PORT_INDEX) {
 819         if (pH264Enc->bDestinationStart == OMX_FALSE) {
 820             Exynos_OSAL_SignalSet(pH264Enc->hDestinationStartEvent);
 821             Exynos_OSAL_SleepMillisec(0);
 822         }
 823     }
 824
 825     ret = OMX_ErrorNone;
 826
 827 EXIT:
 828     FunctionOut();
 829
 830     return ret;
 831 }
 832
 833 OMX_ERRORTYPE H264CodecEnqueueAllBuffer(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 nPortIndex)
 834 {
 835     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 836     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 837     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
 838     EXYNOS_H264ENC_HANDLE         *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 839     void                          *hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle;
 840     int i;
 841
 842     ExynosVideoEncBufferOps *pInbufOps  = pH264Enc->hMFCH264Handle.pInbufOps;
 843     ExynosVideoEncBufferOps *pOutbufOps = pH264Enc->hMFCH264Handle.pOutbufOps;
 844
 845     FunctionIn();
 846
 847     if ((nPortIndex != INPUT_PORT_INDEX) && (nPortIndex != OUTPUT_PORT_INDEX)) {
 848         ret = OMX_ErrorBadPortIndex;
 849         goto EXIT;
 850     }
 851
 852     if ((nPortIndex == INPUT_PORT_INDEX) &&
 853         (pH264Enc->bSourceStart == OMX_TRUE)) {
 854         Exynos_CodecBufferReset(pExynosComponent, INPUT_PORT_INDEX);
 855
 856         for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++)  {
 857             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]);
 858             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
 859             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[1]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1]);
 860
 861             Exynos_CodecBufferEnqueue(pExynosComponent, INPUT_PORT_INDEX, pVideoEnc->pMFCEncInputBuffer[i]);
 862         }
 863
 864         pInbufOps->Clear_Queue(hMFCHandle);
 865     } else if ((nPortIndex == OUTPUT_PORT_INDEX) &&
 866                (pH264Enc->bDestinationStart == OMX_TRUE)) {
 867         ExynosVideoBuffer *pBuffer = NULL;
 868
 869         Exynos_CodecBufferReset(pExynosComponent, OUTPUT_PORT_INDEX);
 870
 871         for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
 872             pOutbufOps->Get_Buffer(hMFCHandle, i, &pBuffer);
 873             Exynos_CodecBufferEnqueue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR)pBuffer);
 874             Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncOutputBuffer[%d]: 0x%x", i, pVideoEnc->pMFCEncOutputBuffer[i]);
 875 //            Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
 876 //            Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[1]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1]);
 877         }
 878         pOutbufOps->Clear_Queue(hMFCHandle);
 879     }
 880
 881 EXIT:
 882     FunctionOut();
 883
 884     return ret;
 885 }
 886
 887 OMX_ERRORTYPE H264CodecSrcSetup(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
 888 {
 889     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 890     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 891     EXYNOS_H264ENC_HANDLE         *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 892     EXYNOS_OMX_BASEPORT           *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
 893     OMX_U32                        oneFrameSize = pSrcInputData->dataLen;
 894
 895     FunctionIn();
 896
 897     if ((oneFrameSize <= 0) && (pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS)) {
 898         OMX_BUFFERHEADERTYPE *OMXBuffer = NULL;
 899         OMXBuffer = Exynos_OutputBufferGetQueue_Direct(pExynosComponent);
 900         if (OMXBuffer == NULL) {
 901             ret = OMX_ErrorUndefined;
 902             goto EXIT;
 903         }
 904
 905         OMXBuffer->nTimeStamp = pSrcInputData->timeStamp;
 906         OMXBuffer->nFlags = pSrcInputData->nFlags;
 907         Exynos_OMX_OutputBufferReturn(pOMXComponent, OMXBuffer);
 908
 909         ret = OMX_ErrorNone;
 910         goto EXIT;
 911     }
 912
 913     if (!((pExynosInputPort->bufferProcessType & BUFFER_COPY) &&
 914         pH264Enc->hMFCH264Handle.bShareableBuf == OMX_FALSE)) {
 915         ret = H264CodecSrcInit(pOMXComponent);
 916         if (ret != OMX_ErrorNone)
 917             goto EXIT;
 918     }
 919
 920
 921     pH264Enc->hMFCH264Handle.bConfiguredMFCSrc = OMX_TRUE;
 922     ret = OMX_ErrorNone;
 923
 924 EXIT:
 925     FunctionOut();
 926
 927     return ret;
 928 }
 929
 930 OMX_ERRORTYPE H264CodecDstSetup(OMX_COMPONENTTYPE *pOMXComponent)
 931 {
 932     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
 933     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
 934     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
 935     EXYNOS_H264ENC_HANDLE         *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
 936     EXYNOS_MFC_H264ENC_HANDLE     *pMFCH264Handle    = &pH264Enc->hMFCH264Handle;
 937     void                          *hMFCHandle = pMFCH264Handle->hMFCHandle;
 938     EXYNOS_OMX_BASEPORT           *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
 939
 940     ExynosVideoEncBufferOps *pOutbufOps = pH264Enc->hMFCH264Handle.pOutbufOps;
 941     ExynosVideoGeometry      bufferConf;
 942     int i,nPlanes, OutBufferSize;
 943
 944     FunctionIn();
 945
 946     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
 947 /*For memory Optimization */
 948         OutBufferSize = 1024*1024*2;//pExynosOutputPort->portDefinition.format.video.nFrameWidth * pExynosOutputPort->portDefinition.format.video.nFrameHeight * 3 / 2;
 949     } else {
 950         OutBufferSize = pExynosOutputPort->extendBufferHeader[0].OMXBufferHeader->nAllocLen;
 951     }
 952
 953     /* set geometry for output (dst) */
 954     if (pOutbufOps->Set_Geometry) {
 955         /* output buffer info: only 2 config values needed */
 956         bufferConf.eCompressionFormat = VIDEO_CODING_AVC;
 957         bufferConf.nSizeImage = OutBufferSize;
 958
 959         if (pOutbufOps->Set_Geometry(pH264Enc->hMFCH264Handle.hMFCHandle, &bufferConf) != VIDEO_ERROR_NONE) {
 960             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to set geometry for output buffer");
 961             ret = OMX_ErrorInsufficientResources;
 962             goto EXIT;
 963         }
 964     }
 965
 966     /* should be done before prepare output buffer */
 967     if (pOutbufOps->Enable_Cacheable(hMFCHandle) != VIDEO_ERROR_NONE) {
 968         ret = OMX_ErrorInsufficientResources;
 969         goto EXIT;
 970     }
 971
 972     if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE
 973         ||pH264Enc->hMFCH264Handle.bShareableBuf == OMX_TRUE)
 974         pOutbufOps->Set_Shareable(hMFCHandle);
 975
 976     int SetupBufferNumber = 0;
 977     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY)
 978         SetupBufferNumber = MFC_OUTPUT_BUFFER_NUM_MAX;
 979     else
 980         SetupBufferNumber = pExynosOutputPort->portDefinition.nBufferCountActual;
 981     Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "SetupBufferNumber:%d", SetupBufferNumber);
 982
 983     if (pOutbufOps->Setup(pH264Enc->hMFCH264Handle.hMFCHandle, SetupBufferNumber) != VIDEO_ERROR_NONE) {
 984         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to setup output buffer");
 985         ret = OMX_ErrorInsufficientResources;
 986         goto EXIT;
 987     }
 988
 989     OMX_U32 dataLen[MFC_OUTPUT_BUFFER_PLANE] = {0};
 990     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
 991         if (pH264Enc->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
 992             /* Register input buffer */
 993             for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
 994                 ExynosVideoPlane plane;
 995                 pVideoEnc->pMFCEncOutputBuffer[i] = (CODEC_ENC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER));
 996                 pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[0] =
 997                     (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, OutBufferSize, NORMAL_MEMORY);
 998                 if (pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[0] == NULL) {
 999                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc output buffer");
1000                     ret = OMX_ErrorInsufficientResources;
1001                     goto EXIT;
1002                 }
1003                 pVideoEnc->pMFCEncOutputBuffer[i]->fd[0] =
1004                     Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[0]);
1005                 pVideoEnc->pMFCEncOutputBuffer[i]->bufferSize[0] = OutBufferSize;
1006
1007                 plane.addr = pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[0];
1008                 plane.fd = pVideoEnc->pMFCEncOutputBuffer[i]->fd[0];
1009                 plane.allocSize = pVideoEnc->pMFCEncOutputBuffer[i]->bufferSize[0];
1010
1011                 if (pOutbufOps->Register(hMFCHandle, &plane, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1012                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register output buffer");
1013                     ret = OMX_ErrorInsufficientResources;
1014                     goto EXIT;
1015                 }
1016                 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr,
1017                                     (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1018             }
1019         }else if (pH264Enc->hMFCH264Handle.bShareableBuf == OMX_FALSE) {
1020             /* Register input buffer */
1021             for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
1022                 ExynosVideoBuffer *pBuffer = NULL;
1023
1024                 pVideoEnc->pMFCEncOutputBuffer[i] = (CODEC_ENC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER));
1025
1026                 if (pOutbufOps->Get_Buffer) {
1027                      if (pOutbufOps->Get_Buffer(pH264Enc->hMFCH264Handle.hMFCHandle, i, &pBuffer) != VIDEO_ERROR_NONE) {
1028                          Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to get Output buffer info");
1029                          ret = OMX_ErrorInsufficientResources;
1030                          goto EXIT;
1031                      }
1032                 }
1033
1034                 for (nPlanes = 0; nPlanes < MFC_OUTPUT_BUFFER_PLANE; nPlanes++) {
1035                     pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[nPlanes] = (void *)pBuffer->planes[nPlanes].addr;
1036                     pVideoEnc->pMFCEncOutputBuffer[i]->fd[nPlanes] = pBuffer->planes[nPlanes].fd;
1037                     pVideoEnc->pMFCEncOutputBuffer[i]->bufferSize[nPlanes] = pBuffer->planes[nPlanes].allocSize;
1038                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "pVideoEnc->pMFCEncOutputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[nPlanes]);
1039                 }
1040
1041                 pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr,
1042                                     (unsigned int *)dataLen, MFC_OUTPUT_BUFFER_PLANE, NULL);
1043             }
1044         }
1045
1046         /* start header encoding */
1047         if (pOutbufOps->Run(hMFCHandle) != VIDEO_ERROR_NONE) {
1048             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to run output buffer");
1049             ret = OMX_ErrorInsufficientResources;
1050             goto EXIT;
1051         }
1052     } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1053         /* Register input buffer */
1054         /*************/
1055         /*    TBD    */
1056         /*************/
1057         ExynosVideoPlane plane;
1058         for (i = 0; i < pExynosOutputPort->portDefinition.nBufferCountActual; i++) {
1059             plane.addr = pExynosOutputPort->extendBufferHeader[i].OMXBufferHeader->pBuffer;
1060             plane.fd = pExynosOutputPort->extendBufferHeader[i].buf_fd[0];
1061             plane.allocSize = pExynosOutputPort->extendBufferHeader[i].OMXBufferHeader->nAllocLen;
1062             if (pOutbufOps->Register(hMFCHandle, &plane, MFC_OUTPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1063                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
1064                 ret = OMX_ErrorInsufficientResources;
1065                 goto EXIT;
1066             }
1067         }
1068     }
1069
1070     pH264Enc->hMFCH264Handle.bConfiguredMFCDst = OMX_TRUE;
1071
1072     ret = OMX_ErrorNone;
1073
1074 EXIT:
1075     FunctionOut();
1076
1077     return ret;
1078 }
1079
1080 OMX_ERRORTYPE Exynos_H264Enc_GetParameter(
1081     OMX_IN OMX_HANDLETYPE hComponent,
1082     OMX_IN OMX_INDEXTYPE  nParamIndex,
1083     OMX_INOUT OMX_PTR     pComponentParameterStructure)
1084 {
1085     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1086     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1087     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1088
1089     FunctionIn();
1090
1091     if (hComponent == NULL || pComponentParameterStructure == NULL) {
1092         ret = OMX_ErrorBadParameter;
1093         goto EXIT;
1094     }
1095     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1096     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1097     if (ret != OMX_ErrorNone) {
1098         goto EXIT;
1099     }
1100     if (pOMXComponent->pComponentPrivate == NULL) {
1101         ret = OMX_ErrorBadParameter;
1102         goto EXIT;
1103     }
1104
1105     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1106     if (pExynosComponent->currentState == OMX_StateInvalid ) {
1107         ret = OMX_ErrorInvalidState;
1108         goto EXIT;
1109     }
1110
1111     switch (nParamIndex) {
1112     case OMX_IndexParamVideoAvc:
1113     {
1114         OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
1115         OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
1116         EXYNOS_H264ENC_HANDLE   *pH264Enc = NULL;
1117
1118         ret = Exynos_OMX_Check_SizeVersion(pDstAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1119         if (ret != OMX_ErrorNone) {
1120             goto EXIT;
1121         }
1122
1123         if (pDstAVCComponent->nPortIndex >= ALL_PORT_NUM) {
1124             ret = OMX_ErrorBadPortIndex;
1125             goto EXIT;
1126         }
1127
1128         pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1129         pSrcAVCComponent = &pH264Enc->AVCComponent[pDstAVCComponent->nPortIndex];
1130
1131         Exynos_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1132     }
1133         break;
1134
1135     case  OMX_IndexParamVideoSliceFMO:
1136     {
1137         OMX_VIDEO_PARAM_AVCSLICEFMO *pDstSliceFmo = (OMX_VIDEO_PARAM_AVCSLICEFMO *)pComponentParameterStructure;
1138         OMX_VIDEO_PARAM_AVCSLICEFMO *pSrcSliceFmo = NULL;
1139         EXYNOS_H264ENC_HANDLE       *pH264Enc = NULL;
1140
1141         pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1142         pSrcSliceFmo = &pH264Enc->AVCSliceFmo;
1143
1144         Exynos_OSAL_Memcpy(pDstSliceFmo, pSrcSliceFmo, sizeof(OMX_VIDEO_PARAM_AVCSLICEFMO));
1145     }
1146         break;
1147
1148     case OMX_IndexParamStandardComponentRole:
1149     {
1150         OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
1151         ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1152         if (ret != OMX_ErrorNone) {
1153             goto EXIT;
1154         }
1155
1156         Exynos_OSAL_Strcpy((char *)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H264_ENC_ROLE);
1157     }
1158         break;
1159     case OMX_IndexParamVideoProfileLevelQuerySupported:
1160     {
1161         OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
1162         EXYNOS_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
1163         OMX_U32 maxProfileLevelNum = 0;
1164
1165         ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1166         if (ret != OMX_ErrorNone) {
1167             goto EXIT;
1168         }
1169
1170         if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1171             ret = OMX_ErrorBadPortIndex;
1172             goto EXIT;
1173         }
1174
1175         pProfileLevel = supportedAVCProfileLevels;
1176         maxProfileLevelNum = sizeof(supportedAVCProfileLevels) / sizeof(EXYNOS_OMX_VIDEO_PROFILELEVEL);
1177
1178         if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
1179             ret = OMX_ErrorNoMore;
1180             goto EXIT;
1181         }
1182
1183         pProfileLevel += pDstProfileLevel->nProfileIndex;
1184         pDstProfileLevel->eProfile = pProfileLevel->profile;
1185         pDstProfileLevel->eLevel = pProfileLevel->level;
1186     }
1187         break;
1188     case OMX_IndexParamVideoProfileLevelCurrent:
1189     {
1190         OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)pComponentParameterStructure;
1191         OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = NULL;
1192         EXYNOS_H264ENC_HANDLE *pH264Enc = NULL;
1193
1194         ret = Exynos_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1195         if (ret != OMX_ErrorNone) {
1196             goto EXIT;
1197         }
1198
1199         if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1200             ret = OMX_ErrorBadPortIndex;
1201             goto EXIT;
1202         }
1203
1204         pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1205         pSrcAVCComponent = &pH264Enc->AVCComponent[pDstProfileLevel->nPortIndex];
1206
1207         pDstProfileLevel->eProfile = pSrcAVCComponent->eProfile;
1208         pDstProfileLevel->eLevel = pSrcAVCComponent->eLevel;
1209     }
1210         break;
1211     case OMX_IndexParamVideoErrorCorrection:
1212     {
1213         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1214         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
1215         EXYNOS_H264ENC_HANDLE *pH264Enc = NULL;
1216
1217         ret = Exynos_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1218         if (ret != OMX_ErrorNone) {
1219             goto EXIT;
1220         }
1221
1222         if (pDstErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
1223             ret = OMX_ErrorBadPortIndex;
1224             goto EXIT;
1225         }
1226
1227         pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1228         pSrcErrorCorrectionType = &pH264Enc->errorCorrectionType[OUTPUT_PORT_INDEX];
1229
1230         pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1231         pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1232         pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1233         pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1234         pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1235     }
1236         break;
1237     default:
1238         ret = Exynos_OMX_VideoEncodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
1239         break;
1240     }
1241 EXIT:
1242     FunctionOut();
1243
1244     return ret;
1245 }
1246
1247 OMX_ERRORTYPE Exynos_H264Enc_SetParameter(
1248     OMX_IN OMX_HANDLETYPE hComponent,
1249     OMX_IN OMX_INDEXTYPE  nIndex,
1250     OMX_IN OMX_PTR        pComponentParameterStructure)
1251 {
1252     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1253     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1254     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1255
1256     FunctionIn();
1257
1258     if (hComponent == NULL || pComponentParameterStructure == NULL) {
1259         ret = OMX_ErrorBadParameter;
1260         goto EXIT;
1261     }
1262     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1263     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1264     if (ret != OMX_ErrorNone) {
1265         goto EXIT;
1266     }
1267     if (pOMXComponent->pComponentPrivate == NULL) {
1268         ret = OMX_ErrorBadParameter;
1269         goto EXIT;
1270     }
1271
1272     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1273     if (pExynosComponent->currentState == OMX_StateInvalid ) {
1274         ret = OMX_ErrorInvalidState;
1275         goto EXIT;
1276     }
1277
1278     switch (nIndex) {
1279     case OMX_IndexParamVideoAvc:
1280     {
1281         OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
1282         OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)pComponentParameterStructure;
1283         EXYNOS_H264ENC_HANDLE   *pH264Enc = NULL;
1284
1285         ret = Exynos_OMX_Check_SizeVersion(pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1286         if (ret != OMX_ErrorNone) {
1287             goto EXIT;
1288         }
1289
1290         if (pSrcAVCComponent->nPortIndex >= ALL_PORT_NUM) {
1291             ret = OMX_ErrorBadPortIndex;
1292             goto EXIT;
1293         }
1294
1295         pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1296         pDstAVCComponent = &pH264Enc->AVCComponent[pSrcAVCComponent->nPortIndex];
1297
1298         Exynos_OSAL_Memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1299     }
1300         break;
1301     case  OMX_IndexParamVideoSliceFMO:
1302     {
1303         OMX_VIDEO_PARAM_AVCSLICEFMO *pDstSliceFmo = NULL;
1304         OMX_VIDEO_PARAM_AVCSLICEFMO *pSrcSliceFmo = (OMX_VIDEO_PARAM_AVCSLICEFMO *)pComponentParameterStructure;
1305         EXYNOS_H264ENC_HANDLE       *pH264Enc = NULL;
1306
1307         pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1308         pDstSliceFmo = &pH264Enc->AVCSliceFmo;
1309
1310         Exynos_OSAL_Memcpy(pDstSliceFmo, pSrcSliceFmo, sizeof(OMX_VIDEO_PARAM_AVCSLICEFMO));
1311     }
1312         break;
1313
1314     case OMX_IndexParamStandardComponentRole:
1315     {
1316         OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
1317
1318         ret = Exynos_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1319         if (ret != OMX_ErrorNone) {
1320             goto EXIT;
1321         }
1322
1323         if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) {
1324             ret = OMX_ErrorIncorrectStateOperation;
1325             goto EXIT;
1326         }
1327
1328         if (!Exynos_OSAL_Strcmp((char*)pComponentRole->cRole, EXYNOS_OMX_COMPONENT_H264_ENC_ROLE)) {
1329             pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
1330         } else {
1331             ret = OMX_ErrorBadParameter;
1332             goto EXIT;
1333         }
1334     }
1335         break;
1336     case OMX_IndexParamVideoProfileLevelCurrent:
1337     {
1338         OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
1339         OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = NULL;
1340         EXYNOS_H264ENC_HANDLE *pH264Enc = NULL;
1341
1342         ret = Exynos_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
1343         if (ret != OMX_ErrorNone)
1344             goto EXIT;
1345
1346         if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
1347             ret = OMX_ErrorBadPortIndex;
1348             goto EXIT;
1349         }
1350
1351         pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1352
1353         pDstAVCComponent = &pH264Enc->AVCComponent[pSrcProfileLevel->nPortIndex];
1354         pDstAVCComponent->eProfile = pSrcProfileLevel->eProfile;
1355         pDstAVCComponent->eLevel = pSrcProfileLevel->eLevel;
1356     }
1357         break;
1358     case OMX_IndexParamVideoErrorCorrection:
1359     {
1360         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
1361         OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
1362         EXYNOS_H264ENC_HANDLE *pH264Enc = NULL;
1363
1364         ret = Exynos_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1365         if (ret != OMX_ErrorNone) {
1366             goto EXIT;
1367         }
1368
1369         if (pSrcErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
1370             ret = OMX_ErrorBadPortIndex;
1371             goto EXIT;
1372         }
1373
1374         pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1375         pDstErrorCorrectionType = &pH264Enc->errorCorrectionType[OUTPUT_PORT_INDEX];
1376
1377         pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
1378         pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
1379         pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
1380         pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
1381         pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
1382     }
1383         break;
1384 #ifdef USE_H264_PREPEND_SPS_PPS
1385     case OMX_IndexParamPrependSPSPPSToIDR:
1386     {
1387         EXYNOS_H264ENC_HANDLE *pH264Enc = NULL;
1388
1389         pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1390         pH264Enc->hMFCH264Handle.bPrependSpsPpsToIdr = OMX_TRUE;
1391     }
1392         break;
1393 #endif
1394 #ifdef TIZEN_FEATURE_E3250
1395     case OMX_IndexParamSharedOutputFD:
1396     {
1397         EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
1398         pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1399
1400         pVideoEnc->bSharedOutputFD = OMX_TRUE;
1401     }
1402         break;
1403 #endif
1404
1405     default:
1406         ret = Exynos_OMX_VideoEncodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
1407         break;
1408     }
1409 EXIT:
1410     FunctionOut();
1411
1412     return ret;
1413 }
1414
1415 OMX_ERRORTYPE Exynos_H264Enc_GetConfig(
1416     OMX_HANDLETYPE hComponent,
1417     OMX_INDEXTYPE nIndex,
1418     OMX_PTR pComponentConfigStructure)
1419 {
1420     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1421     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1422     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1423     EXYNOS_H264ENC_HANDLE    *pH264Enc         = NULL;
1424
1425     FunctionIn();
1426
1427     if (hComponent == NULL || pComponentConfigStructure == NULL) {
1428         ret = OMX_ErrorBadParameter;
1429         goto EXIT;
1430     }
1431     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1432     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1433     if (ret != OMX_ErrorNone) {
1434         goto EXIT;
1435     }
1436     if (pOMXComponent->pComponentPrivate == NULL) {
1437         ret = OMX_ErrorBadParameter;
1438         goto EXIT;
1439     }
1440     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1441     if (pExynosComponent->currentState == OMX_StateInvalid) {
1442         ret = OMX_ErrorInvalidState;
1443         goto EXIT;
1444     }
1445     pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1446
1447     switch (nIndex) {
1448     case OMX_IndexConfigVideoAVCIntraPeriod:
1449     {
1450         OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pAVCIntraPeriod = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD *)pComponentConfigStructure;
1451         OMX_U32           portIndex = pAVCIntraPeriod->nPortIndex;
1452
1453         if ((portIndex != OUTPUT_PORT_INDEX)) {
1454             ret = OMX_ErrorBadPortIndex;
1455             goto EXIT;
1456         } else {
1457             pAVCIntraPeriod->nIDRPeriod = pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames + 1;
1458             pAVCIntraPeriod->nPFrames = pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames;
1459         }
1460     }
1461         break;
1462     default:
1463         ret = Exynos_OMX_VideoEncodeGetConfig(hComponent, nIndex, pComponentConfigStructure);
1464         break;
1465     }
1466
1467 EXIT:
1468     FunctionOut();
1469
1470     return ret;
1471 }
1472
1473 OMX_ERRORTYPE Exynos_H264Enc_SetConfig(
1474     OMX_HANDLETYPE hComponent,
1475     OMX_INDEXTYPE nIndex,
1476     OMX_PTR pComponentConfigStructure)
1477 {
1478     OMX_ERRORTYPE                  ret              = OMX_ErrorNone;
1479     OMX_COMPONENTTYPE             *pOMXComponent    = NULL;
1480     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = NULL;
1481     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc        = NULL;
1482     EXYNOS_H264ENC_HANDLE         *pH264Enc         = NULL;
1483
1484     FunctionIn();
1485
1486     if (hComponent == NULL || pComponentConfigStructure == NULL) {
1487         ret = OMX_ErrorBadParameter;
1488         goto EXIT;
1489     }
1490     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1491     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1492     if (ret != OMX_ErrorNone) {
1493         goto EXIT;
1494     }
1495     if (pOMXComponent->pComponentPrivate == NULL) {
1496         ret = OMX_ErrorBadParameter;
1497         goto EXIT;
1498     }
1499     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1500     if (pExynosComponent->currentState == OMX_StateInvalid) {
1501         ret = OMX_ErrorInvalidState;
1502         goto EXIT;
1503     }
1504
1505     pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1506     pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1507
1508     switch (nIndex) {
1509     case OMX_IndexConfigVideoIntraPeriod:
1510     {
1511         OMX_U32 nPFrames = (*((OMX_U32 *)pComponentConfigStructure)) - 1;
1512
1513         pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames = nPFrames;
1514
1515         ret = OMX_ErrorNone;
1516     }
1517         break;
1518     case OMX_IndexConfigVideoAVCIntraPeriod:
1519     {
1520         OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pAVCIntraPeriod = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD *)pComponentConfigStructure;
1521         OMX_U32           portIndex = pAVCIntraPeriod->nPortIndex;
1522
1523         if ((portIndex != OUTPUT_PORT_INDEX)) {
1524             ret = OMX_ErrorBadPortIndex;
1525             goto EXIT;
1526         } else {
1527             if (pAVCIntraPeriod->nIDRPeriod == (pAVCIntraPeriod->nPFrames + 1))
1528                 pH264Enc->AVCComponent[OUTPUT_PORT_INDEX].nPFrames = pAVCIntraPeriod->nPFrames;
1529             else {
1530                 ret = OMX_ErrorBadParameter;
1531                 goto EXIT;
1532             }
1533         }
1534     }
1535         break;
1536     default:
1537         ret = Exynos_OMX_VideoEncodeSetConfig(hComponent, nIndex, pComponentConfigStructure);
1538         break;
1539     }
1540
1541 EXIT:
1542     if (ret == OMX_ErrorNone)
1543         pVideoEnc->configChange = OMX_TRUE;
1544
1545     FunctionOut();
1546
1547     return ret;
1548 }
1549
1550 OMX_ERRORTYPE Exynos_H264Enc_GetExtensionIndex(
1551     OMX_IN OMX_HANDLETYPE  hComponent,
1552     OMX_IN OMX_STRING      cParameterName,
1553     OMX_OUT OMX_INDEXTYPE *pIndexType)
1554 {
1555     OMX_ERRORTYPE             ret              = OMX_ErrorNone;
1556     OMX_COMPONENTTYPE        *pOMXComponent    = NULL;
1557     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
1558
1559     FunctionIn();
1560
1561     if (hComponent == NULL) {
1562         ret = OMX_ErrorBadParameter;
1563         goto EXIT;
1564     }
1565     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
1566     ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
1567     if (ret != OMX_ErrorNone) {
1568         goto EXIT;
1569     }
1570     if (pOMXComponent->pComponentPrivate == NULL) {
1571         ret = OMX_ErrorBadParameter;
1572         goto EXIT;
1573     }
1574     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1575     if ((cParameterName == NULL) || (pIndexType == NULL)) {
1576         ret = OMX_ErrorBadParameter;
1577         goto EXIT;
1578     }
1579     if (pExynosComponent->currentState == OMX_StateInvalid) {
1580         ret = OMX_ErrorInvalidState;
1581         goto EXIT;
1582     }
1583     if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_CONFIG_VIDEO_INTRAPERIOD) == 0) {
1584         *pIndexType = OMX_IndexConfigVideoIntraPeriod;
1585         ret = OMX_ErrorNone;
1586 #ifdef TIZEN_FEATURE_E3250
1587     } else if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_ENC_SHARED_OUTPUT_FD) == 0) {
1588         *pIndexType = (OMX_INDEXTYPE) OMX_IndexParamSharedOutputFD;
1589         goto EXIT;
1590 #endif
1591 #ifdef USE_H264_PREPEND_SPS_PPS
1592     } else if (Exynos_OSAL_Strcmp(cParameterName, EXYNOS_INDEX_PARAM_PREPEND_SPSPPS_TO_IDR) == 0) {
1593         *pIndexType = OMX_IndexParamPrependSPSPPSToIDR;
1594         goto EXIT;
1595 #endif
1596     } else {
1597         ret = Exynos_OMX_VideoEncodeGetExtensionIndex(hComponent, cParameterName, pIndexType);
1598     }
1599
1600 EXIT:
1601     FunctionOut();
1602
1603     return ret;
1604 }
1605
1606 OMX_ERRORTYPE Exynos_H264Enc_ComponentRoleEnum(OMX_HANDLETYPE hComponent, OMX_U8 *cRole, OMX_U32 nIndex)
1607 {
1608     OMX_ERRORTYPE               ret              = OMX_ErrorNone;
1609
1610     FunctionIn();
1611
1612     if ((hComponent == NULL) || (cRole == NULL)) {
1613         ret = OMX_ErrorBadParameter;
1614         goto EXIT;
1615     }
1616     if (nIndex == (MAX_COMPONENT_ROLE_NUM-1)) {
1617         Exynos_OSAL_Strcpy((char *)cRole, EXYNOS_OMX_COMPONENT_H264_ENC_ROLE);
1618         ret = OMX_ErrorNone;
1619     } else {
1620         ret = OMX_ErrorNoMore;
1621     }
1622
1623 EXIT:
1624     FunctionOut();
1625
1626     return ret;
1627 }
1628
1629 /* MFC Init */
1630 OMX_ERRORTYPE Exynos_H264Enc_Init(OMX_COMPONENTTYPE *pOMXComponent)
1631 {
1632     OMX_ERRORTYPE             ret = OMX_ErrorNone;
1633     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1634     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1635     EXYNOS_OMX_BASEPORT      *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1636     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1637     EXYNOS_H264ENC_HANDLE    *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;;
1638     OMX_COLOR_FORMATTYPE      eColorFormat;
1639
1640     int i = 0;
1641
1642     FunctionIn();
1643
1644     CSC_METHOD csc_method = CSC_METHOD_SW;
1645     pH264Enc->hMFCH264Handle.bConfiguredMFCSrc = OMX_FALSE;
1646     pH264Enc->hMFCH264Handle.bConfiguredMFCDst = OMX_FALSE;
1647     pVideoEnc->bFirstOutput = OMX_FALSE;
1648     pExynosComponent->bUseFlagEOF = OMX_TRUE;
1649     pExynosComponent->bSaveFlagEOS = OMX_FALSE;
1650
1651     eColorFormat = pExynosInputPort->portDefinition.format.video.eColorFormat;
1652     if (pExynosInputPort->bStoreMetaData == OMX_TRUE) {
1653 #ifndef TIZEN_FEATURE_E3250 /* we do not use OMX_COLOR_FormatAndroidOpaque */
1654         if (eColorFormat == OMX_COLOR_FormatAndroidOpaque) {
1655             pExynosInputPort->bufferProcessType = BUFFER_COPY;
1656         } else {
1657             pExynosInputPort->bufferProcessType = BUFFER_SHARE;
1658         }
1659 #endif
1660     } else {
1661         if (eColorFormat == (OMX_COLOR_FORMATTYPE)OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd ||
1662             eColorFormat == (OMX_COLOR_FORMATTYPE)OMX_SEC_COLOR_FormatNV12T_DmaBuf_Fd) {
1663             pExynosInputPort->bufferProcessType = BUFFER_SHARE;
1664         } else {
1665             pExynosInputPort->bufferProcessType = BUFFER_COPY;
1666         }
1667     }
1668
1669 #ifdef TIZEN_FEATURE_E3250
1670     if (pVideoEnc->bSharedOutputFD == OMX_TRUE) {
1671         pExynosOutputPort->bufferProcessType = BUFFER_SHARE;
1672     } else {
1673         pExynosOutputPort->bufferProcessType = BUFFER_COPY;
1674     }
1675 #endif
1676
1677     /* H.264 Codec Open */
1678     ret = H264CodecOpen(pH264Enc);
1679     if (ret != OMX_ErrorNone) {
1680         goto EXIT;
1681     }
1682
1683     if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1684         Exynos_OSAL_SemaphoreCreate(&pExynosInputPort->codecSemID);
1685         Exynos_OSAL_QueueCreate(&pExynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1686
1687         if (pH264Enc->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
1688             for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1689                 pVideoEnc->pMFCEncInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER));
1690                 /* Use ION Allocator */
1691                 /*Alloc Y-Buffer */
1692                 pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, DEFAULT_MFC_INPUT_YBUFFER_SIZE, NORMAL_MEMORY);
1693                 pVideoEnc->pMFCEncInputBuffer[i]->fd[0] = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
1694                 pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[0] = DEFAULT_MFC_INPUT_YBUFFER_SIZE;
1695                 /*Alloc C-Buffer */
1696                 pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, DEFAULT_MFC_INPUT_CBUFFER_SIZE, NORMAL_MEMORY);
1697                 pVideoEnc->pMFCEncInputBuffer[i]->fd[1] = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1]);
1698                 pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[1] = DEFAULT_MFC_INPUT_CBUFFER_SIZE;
1699
1700                 pVideoEnc->pMFCEncInputBuffer[i]->dataSize = 0;
1701
1702                 if ((pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0] == NULL) ||
1703                     (pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1] == NULL)) {
1704                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
1705                     ret = OMX_ErrorInsufficientResources;
1706                     goto EXIT;
1707                 }
1708
1709                 /* MFC input buffers are 1 plane. */
1710                 pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[2] = NULL;
1711                 pVideoEnc->pMFCEncInputBuffer[i]->fd[2] = -1;
1712                 pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[2] = 0;
1713
1714                 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]);
1715                 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
1716                 Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[1]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1]);
1717
1718                 Exynos_CodecBufferEnqueue(pExynosComponent, INPUT_PORT_INDEX, pVideoEnc->pMFCEncInputBuffer[i]);
1719             }
1720         } else {
1721             ret = H264CodecSrcInit(pOMXComponent);
1722             if (ret != OMX_ErrorNone)
1723                 goto EXIT;
1724         }
1725     } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1726         /*************/
1727         /*    TBD    */
1728         /*************/
1729         /* Does not require any actions. */
1730     }
1731
1732     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1733         Exynos_OSAL_SemaphoreCreate(&pExynosOutputPort->codecSemID);
1734         Exynos_OSAL_QueueCreate(&pExynosOutputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
1735     } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1736         /*************/
1737         /*    TBD    */
1738         /*************/
1739         /* Does not require any actions. */
1740     }
1741
1742     pH264Enc->bSourceStart = OMX_FALSE;
1743     Exynos_OSAL_SignalCreate(&pH264Enc->hSourceStartEvent);
1744     pH264Enc->bDestinationStart = OMX_FALSE;
1745     Exynos_OSAL_SignalCreate(&pH264Enc->hDestinationStartEvent);
1746
1747     Exynos_OSAL_Memset(pExynosComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
1748     Exynos_OSAL_Memset(pExynosComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
1749     pH264Enc->hMFCH264Handle.indexTimestamp = 0;
1750     pH264Enc->hMFCH264Handle.outputIndexTimestamp = 0;
1751
1752     pExynosComponent->getAllDelayBuffer = OMX_FALSE;
1753
1754 #if 0//defined(USE_CSC_GSCALER)
1755
1756     csc_method = CSC_METHOD_HW; //in case of Use ION buffer.
1757 #endif
1758     pVideoEnc->csc_handle = csc_init(csc_method);
1759     if (pVideoEnc->csc_handle == NULL) {
1760         ret = OMX_ErrorInsufficientResources;
1761         goto EXIT;
1762     }
1763     pVideoEnc->csc_set_format = OMX_FALSE;
1764
1765 EXIT:
1766     FunctionOut();
1767
1768     return ret;
1769 }
1770
1771 /* MFC Terminate */
1772 OMX_ERRORTYPE Exynos_H264Enc_Terminate(OMX_COMPONENTTYPE *pOMXComponent)
1773 {
1774     OMX_ERRORTYPE                  ret              = OMX_ErrorNone;
1775     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1776     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc        = ((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle);
1777     EXYNOS_OMX_BASEPORT      *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1778     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
1779     EXYNOS_H264ENC_HANDLE    *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1780
1781     int i = 0;
1782
1783     FunctionIn();
1784
1785     if (pVideoEnc->csc_handle != NULL) {
1786         csc_deinit(pVideoEnc->csc_handle);
1787         pVideoEnc->csc_handle = NULL;
1788     }
1789
1790     Exynos_OSAL_SignalTerminate(pH264Enc->hDestinationStartEvent);
1791     pH264Enc->hDestinationStartEvent = NULL;
1792     pH264Enc->bDestinationStart = OMX_FALSE;
1793     Exynos_OSAL_SignalTerminate(pH264Enc->hSourceStartEvent);
1794     pH264Enc->hSourceStartEvent = NULL;
1795     pH264Enc->bSourceStart = OMX_FALSE;
1796
1797     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
1798         for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
1799             if (pVideoEnc->pMFCEncOutputBuffer[i] != NULL) {
1800 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
1801                 if (pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[0] != NULL)
1802                     Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncOutputBuffer[i]->pVirAddr[0]);
1803 #endif
1804                 Exynos_OSAL_Free(pVideoEnc->pMFCEncOutputBuffer[i]);
1805                 pVideoEnc->pMFCEncOutputBuffer[i] = NULL;
1806             }
1807         }
1808
1809         Exynos_OSAL_QueueTerminate(&pExynosOutputPort->codecBufferQ);
1810         Exynos_OSAL_SemaphoreTerminate(pExynosOutputPort->codecSemID);
1811     } else if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
1812         /*************/
1813         /*    TBD    */
1814         /*************/
1815         /* Does not require any actions. */
1816     }
1817
1818     if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
1819         if (pH264Enc->hMFCH264Handle.bShareableBuf == OMX_TRUE) {
1820             for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
1821                 if (pVideoEnc->pMFCEncInputBuffer[i] != NULL) {
1822 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
1823                     for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
1824                         if (pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane] != NULL)
1825                             Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[plane]);
1826                     }
1827 #endif
1828                     Exynos_OSAL_Free(pVideoEnc->pMFCEncInputBuffer[i]);
1829                     pVideoEnc->pMFCEncInputBuffer[i] = NULL;
1830                 }
1831             }
1832         }
1833
1834         Exynos_OSAL_QueueTerminate(&pExynosInputPort->codecBufferQ);
1835         Exynos_OSAL_SemaphoreTerminate(pExynosInputPort->codecSemID);
1836     } else if (pExynosInputPort->bufferProcessType & BUFFER_SHARE) {
1837         /*************/
1838         /*    TBD    */
1839         /*************/
1840         /* Does not require any actions. */
1841     }
1842     H264CodecClose(pH264Enc);
1843
1844     FunctionOut();
1845
1846     return ret;
1847 }
1848
1849 OMX_ERRORTYPE Exynos_H264Enc_SrcIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
1850 {
1851     OMX_ERRORTYPE               ret = OMX_ErrorNone;
1852     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1853     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1854     EXYNOS_H264ENC_HANDLE         *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1855     void                          *hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle;
1856     EXYNOS_OMX_BASEPORT *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1857     OMX_U32  oneFrameSize = pSrcInputData->dataLen;
1858     ExynosVideoEncOps       *pEncOps    = pH264Enc->hMFCH264Handle.pEncOps;
1859     ExynosVideoEncBufferOps *pInbufOps  = pH264Enc->hMFCH264Handle.pInbufOps;
1860     ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
1861
1862     FunctionIn();
1863
1864     if (pH264Enc->hMFCH264Handle.bConfiguredMFCSrc == OMX_FALSE) {
1865         ret = H264CodecSrcSetup(pOMXComponent, pSrcInputData);
1866 //        if ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)
1867         if (ret != OMX_ErrorNone)
1868             goto EXIT;
1869     }
1870     if (pH264Enc->hMFCH264Handle.bConfiguredMFCDst == OMX_FALSE) {
1871         ret = H264CodecDstSetup(pOMXComponent);
1872     }
1873     if (pVideoEnc->configChange == OMX_TRUE) {
1874         Change_H264Enc_Param(pExynosComponent);
1875         pVideoEnc->configChange = OMX_FALSE;
1876     }
1877
1878     if ((pSrcInputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS) {
1879         OMX_U32 pMFCYUVDataSize[MFC_INPUT_BUFFER_PLANE]  = {0, };
1880         ExynosVideoPlane planes[MFC_INPUT_BUFFER_PLANE];
1881         int plane;
1882
1883         pExynosComponent->timeStamp[pH264Enc->hMFCH264Handle.indexTimestamp] = pSrcInputData->timeStamp;
1884         pExynosComponent->nFlags[pH264Enc->hMFCH264Handle.indexTimestamp] = pSrcInputData->nFlags;
1885         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "input timestamp %lld us (%.2f secs), Tag: %d, nFlags: 0x%x", pSrcInputData->timeStamp, pSrcInputData->timeStamp / 1E6, pH264Enc->hMFCH264Handle.indexTimestamp, pSrcInputData->nFlags);
1886         pEncOps->Set_FrameTag(hMFCHandle, pH264Enc->hMFCH264Handle.indexTimestamp);
1887         pH264Enc->hMFCH264Handle.indexTimestamp++;
1888         pH264Enc->hMFCH264Handle.indexTimestamp %= MAX_TIMESTAMP;
1889
1890         /* queue work for input buffer */
1891         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Exynos_H264Enc_SrcIn(): oneFrameSize: %d, bufferHeader: 0x%x", oneFrameSize, pSrcInputData->bufferHeader);
1892             pMFCYUVDataSize[0] = pExynosInputPort->portDefinition.format.video.nFrameWidth * pExynosInputPort->portDefinition.format.video.nFrameHeight;
1893             pMFCYUVDataSize[1] = pMFCYUVDataSize[0]/2;
1894
1895 //#define INPUT_FILE_DUMP
1896 #ifdef INPUT_FILE_DUMP
1897             {
1898                 FILE *pf;
1899                 char filename[100];
1900                 static int tmp_cnt=0;
1901                 int w = pExynosInputPort->portDefinition.format.video.nFrameWidth;
1902                 int h = pExynosInputPort->portDefinition.format.video.nFrameHeight;
1903
1904                 memset(filename, 0x00, sizeof(filename));
1905                 sprintf(filename, "/tmp/enc_dump_%d_%d_%d.yuv", w, h, ++tmp_cnt);
1906                 pf = fopen(filename, "wb");
1907                 if (pf == NULL) {
1908                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "[input dump] filepoint NULL!");
1909                 } else {
1910                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "[input dump] fwrite[%d] ", tmp_cnt);
1911                     fwrite(pSrcInputData->buffer.multiPlaneBuffer.dataBuffer[0], sizeof(char), h * w, pf);
1912                     fwrite(pSrcInputData->buffer.multiPlaneBuffer.dataBuffer[1], sizeof(char), h * w / 2, pf);
1913                 }
1914                 fclose(pf);
1915             }
1916 #endif
1917
1918         codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)pSrcInputData->buffer.multiPlaneBuffer.dataBuffer,
1919                                     (unsigned int *)pMFCYUVDataSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
1920 //#ifdef USE_METADATABUFFERTYPE
1921         if ((codecReturn == VIDEO_ERROR_NOBUFFERS) &&
1922             /*(pExynosInputPort->bStoreMetaData == OMX_TRUE) &&*/
1923             (pExynosInputPort->bufferProcessType & BUFFER_SHARE)) {
1924             OMX_U32 nAllocLen[MFC_INPUT_BUFFER_PLANE] = {0, 0};
1925             nAllocLen[0] = ALIGN_TO_16B(pExynosInputPort->portDefinition.format.video.nFrameWidth) *
1926                                 ALIGN_TO_16B(pExynosInputPort->portDefinition.format.video.nFrameHeight);
1927             nAllocLen[1] = ALIGN(nAllocLen[0]/2,256);
1928             for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
1929                 planes[plane].addr = pSrcInputData->buffer.multiPlaneBuffer.dataBuffer[plane];
1930                 planes[plane].allocSize = nAllocLen[plane];
1931                 planes[plane].fd = pSrcInputData->buffer.multiPlaneBuffer.fd[plane];
1932             }
1933
1934             /* Register input buffer */
1935             if (pInbufOps->Register(pH264Enc->hMFCH264Handle.hMFCHandle,
1936                         planes, MFC_INPUT_BUFFER_PLANE) != VIDEO_ERROR_NONE) {
1937                 Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Register input buffer");
1938                 ret = OMX_ErrorInsufficientResources;
1939                 goto EXIT;
1940             }
1941
1942             codecReturn = pInbufOps->Enqueue(hMFCHandle, (unsigned char **)pSrcInputData->buffer.multiPlaneBuffer.dataBuffer,
1943                                         (unsigned int *)pMFCYUVDataSize, MFC_INPUT_BUFFER_PLANE, pSrcInputData->bufferHeader);
1944
1945         }
1946 //#endif
1947         if (codecReturn != VIDEO_ERROR_NONE) {
1948             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - pInbufOps->Enqueue", __FUNCTION__, __LINE__);
1949             ret = (OMX_ERRORTYPE)OMX_ErrorCodecEncode;
1950             goto EXIT;
1951         }
1952         H264CodecStart(pOMXComponent, INPUT_PORT_INDEX);
1953         if (pH264Enc->bSourceStart == OMX_FALSE) {
1954             pH264Enc->bSourceStart = OMX_TRUE;
1955             Exynos_OSAL_SignalSet(pH264Enc->hSourceStartEvent);
1956             Exynos_OSAL_SleepMillisec(0);
1957         }
1958         if (pH264Enc->bDestinationStart == OMX_FALSE) {
1959             pH264Enc->bDestinationStart = OMX_TRUE;
1960             Exynos_OSAL_SignalSet(pH264Enc->hDestinationStartEvent);
1961             Exynos_OSAL_SleepMillisec(0);
1962         }
1963     }
1964
1965     ret = OMX_ErrorNone;
1966
1967 EXIT:
1968     FunctionOut();
1969
1970     return ret;
1971 }
1972
1973 OMX_ERRORTYPE Exynos_H264Enc_SrcOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
1974 {
1975     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
1976     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
1977     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
1978     EXYNOS_H264ENC_HANDLE         *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
1979     void                          *hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle;
1980     EXYNOS_OMX_BASEPORT     *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
1981     ExynosVideoEncBufferOps *pInbufOps  = pH264Enc->hMFCH264Handle.pInbufOps;
1982     ExynosVideoBuffer       *pVideoBuffer;
1983
1984     FunctionIn();
1985
1986     pVideoBuffer = pInbufOps->Dequeue(hMFCHandle);
1987
1988     pSrcOutputData->dataLen       = 0;
1989     pSrcOutputData->usedDataLen   = 0;
1990     pSrcOutputData->remainDataLen = 0;
1991     pSrcOutputData->nFlags    = 0;
1992     pSrcOutputData->timeStamp = 0;
1993
1994     if (pVideoBuffer == NULL) {
1995         pSrcOutputData->buffer.singlePlaneBuffer.dataBuffer = NULL;
1996         pSrcOutputData->allocSize  = 0;
1997         pSrcOutputData->pPrivate = NULL;
1998         pSrcOutputData->bufferHeader = NULL;
1999     } else {
2000         int plane = 0;
2001         for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
2002             pSrcOutputData->buffer.multiPlaneBuffer.dataBuffer[plane] = pVideoBuffer->planes[plane].addr;
2003             pSrcOutputData->buffer.multiPlaneBuffer.fd[plane] = pVideoBuffer->planes[plane].fd;
2004         }
2005         pSrcOutputData->allocSize = pVideoBuffer->planes[0].allocSize +
2006                                         pVideoBuffer->planes[1].allocSize +
2007                                         pVideoBuffer->planes[2].allocSize;
2008
2009         if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2010             int i = 0;
2011             while (pSrcOutputData->buffer.multiPlaneBuffer.dataBuffer[0] != pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]) {
2012                 i++;
2013                 if (i >= MFC_INPUT_BUFFER_NUM_MAX) {
2014                     Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - Lost buffer", __FUNCTION__, __LINE__);
2015                     ret = (OMX_ERRORTYPE)OMX_ErrorCodecEncode;
2016                     goto EXIT;
2017                 }
2018             }
2019             pVideoEnc->pMFCEncInputBuffer[i]->dataSize = 0;
2020             pSrcOutputData->pPrivate = pVideoEnc->pMFCEncInputBuffer[i];
2021         }
2022
2023         /* For Share Buffer */
2024         pSrcOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE*)pVideoBuffer->pPrivate;
2025     }
2026
2027     ret = OMX_ErrorNone;
2028
2029 EXIT:
2030     FunctionOut();
2031
2032     return ret;
2033 }
2034
2035 OMX_ERRORTYPE Exynos_H264Enc_DstIn(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2036 {
2037     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
2038     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2039     EXYNOS_H264ENC_HANDLE         *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2040     void                          *hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle;
2041     ExynosVideoEncBufferOps *pOutbufOps = pH264Enc->hMFCH264Handle.pOutbufOps;
2042     OMX_U32 dataLen = 0;
2043     ExynosVideoErrorType codecReturn = VIDEO_ERROR_NONE;
2044
2045     FunctionIn();
2046
2047     if (pDstInputData->buffer.singlePlaneBuffer.dataBuffer == NULL) {
2048         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to find input buffer");
2049         ret = OMX_ErrorBadParameter;
2050         goto EXIT;
2051     }
2052
2053     codecReturn = pOutbufOps->Enqueue(hMFCHandle, (unsigned char **)&pDstInputData->buffer.singlePlaneBuffer.dataBuffer,
2054                      (unsigned int *)&dataLen, MFC_OUTPUT_BUFFER_PLANE, pDstInputData->bufferHeader);
2055
2056     if (codecReturn != VIDEO_ERROR_NONE) {
2057         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - pOutbufOps->Enqueue", __FUNCTION__, __LINE__);
2058         ret = (OMX_ERRORTYPE)OMX_ErrorCodecEncode;
2059         goto EXIT;
2060     }
2061     H264CodecStart(pOMXComponent, OUTPUT_PORT_INDEX);
2062
2063     ret = OMX_ErrorNone;
2064
2065 EXIT:
2066     FunctionOut();
2067
2068     return ret;
2069 }
2070
2071 OMX_ERRORTYPE Exynos_H264Enc_DstOut(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2072 {
2073     OMX_ERRORTYPE                  ret = OMX_ErrorNone;
2074     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2075     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2076     EXYNOS_H264ENC_HANDLE         *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2077     void                          *hMFCHandle = pH264Enc->hMFCH264Handle.hMFCHandle;
2078     ExynosVideoEncOps       *pEncOps    = pH264Enc->hMFCH264Handle.pEncOps;
2079     ExynosVideoEncBufferOps *pOutbufOps = pH264Enc->hMFCH264Handle.pOutbufOps;
2080     ExynosVideoBuffer       *pVideoBuffer;
2081     ExynosVideoFrameStatusType displayStatus = VIDEO_FRAME_STATUS_UNKNOWN;
2082     OMX_S32 indexTimestamp = 0;
2083
2084     FunctionIn();
2085
2086     if (pH264Enc->bDestinationStart == OMX_FALSE) {
2087         ret = OMX_ErrorNone;
2088         goto EXIT;
2089     }
2090
2091     if ((pVideoBuffer = pOutbufOps->Dequeue(hMFCHandle)) == NULL) {
2092         ret = OMX_ErrorNone;
2093         goto EXIT;
2094     }
2095
2096     pH264Enc->hMFCH264Handle.outputIndexTimestamp++;
2097     pH264Enc->hMFCH264Handle.outputIndexTimestamp %= MAX_TIMESTAMP;
2098
2099     pDstOutputData->buffer.singlePlaneBuffer.dataBuffer = pVideoBuffer->planes[0].addr;
2100     pDstOutputData->buffer.singlePlaneBuffer.fd = pVideoBuffer->planes[0].fd;
2101     pDstOutputData->allocSize   = pVideoBuffer->planes[0].allocSize;
2102     pDstOutputData->dataLen     = pVideoBuffer->planes[0].dataSize;
2103     pDstOutputData->remainDataLen = pVideoBuffer->planes[0].dataSize;
2104     pDstOutputData->usedDataLen = 0;
2105     pDstOutputData->pPrivate = pVideoBuffer;
2106     /* For Share Buffer */
2107     pDstOutputData->bufferHeader = (OMX_BUFFERHEADERTYPE *)pVideoBuffer->pPrivate;
2108
2109     if (pVideoEnc->bFirstOutput == OMX_FALSE) {
2110         if (pVideoEnc->bSharedOutputFD == OMX_FALSE) {
2111             OMX_U8 *p = NULL;
2112             int iSpsSize = 0;
2113             int iPpsSize = 0;
2114
2115             /* Calculate sps/pps size if needed */
2116             p = FindDelimiter((OMX_U8 *)(pDstOutputData->buffer.singlePlaneBuffer.dataBuffer + 4),
2117                                 pDstOutputData->dataLen - 4);
2118
2119             iSpsSize = (unsigned int)p - (unsigned int)pDstOutputData->buffer.singlePlaneBuffer.dataBuffer;
2120             pH264Enc->hMFCH264Handle.headerData.pHeaderSPS =
2121                 (OMX_PTR)pDstOutputData->buffer.singlePlaneBuffer.dataBuffer;
2122             pH264Enc->hMFCH264Handle.headerData.SPSLen = iSpsSize;
2123
2124             iPpsSize = pDstOutputData->dataLen - iSpsSize;
2125             pH264Enc->hMFCH264Handle.headerData.pHeaderPPS =
2126                 (OMX_U8 *)pDstOutputData->buffer.singlePlaneBuffer.dataBuffer + iSpsSize;
2127             pH264Enc->hMFCH264Handle.headerData.PPSLen = iPpsSize;
2128         }
2129         pDstOutputData->timeStamp = 0;
2130         pDstOutputData->nFlags |= OMX_BUFFERFLAG_CODECCONFIG;
2131         pDstOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
2132         pVideoEnc->bFirstOutput = OMX_TRUE;
2133     } else {
2134         indexTimestamp = pEncOps->Get_FrameTag(pH264Enc->hMFCH264Handle.hMFCHandle);
2135         if ((indexTimestamp < 0) || (indexTimestamp >= MAX_TIMESTAMP)) {
2136             pDstOutputData->timeStamp = pExynosComponent->timeStamp[pH264Enc->hMFCH264Handle.outputIndexTimestamp];
2137             pDstOutputData->nFlags = pExynosComponent->nFlags[pH264Enc->hMFCH264Handle.outputIndexTimestamp];
2138         } else {
2139             pDstOutputData->timeStamp = pExynosComponent->timeStamp[indexTimestamp];
2140             pDstOutputData->nFlags = pExynosComponent->nFlags[indexTimestamp];
2141         }
2142
2143         pDstOutputData->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
2144         if (pVideoBuffer->frameType == VIDEO_FRAME_I)
2145             pDstOutputData->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
2146     }
2147
2148     if ((displayStatus == VIDEO_FRAME_STATUS_CHANGE_RESOL) ||
2149         ((pDstOutputData->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
2150         Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%x displayStatus:%d, nFlags0x%x", pExynosComponent, displayStatus, pDstOutputData->nFlags);
2151         pDstOutputData->remainDataLen = 0;
2152     }
2153
2154     ret = OMX_ErrorNone;
2155
2156 EXIT:
2157     FunctionOut();
2158
2159     return ret;
2160 }
2161
2162 OMX_ERRORTYPE Exynos_H264Enc_srcInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcInputData)
2163 {
2164     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2165     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2166     EXYNOS_OMX_BASEPORT      *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2167
2168     FunctionIn();
2169
2170     if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2171         ret = OMX_ErrorNone;
2172         goto EXIT;
2173     }
2174     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2175         ret = OMX_ErrorNone;
2176         goto EXIT;
2177     }
2178
2179     ret = Exynos_H264Enc_SrcIn(pOMXComponent, pSrcInputData);
2180     if (ret != OMX_ErrorNone) {
2181         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - SrcIn -> event is thrown to client", __FUNCTION__, __LINE__);
2182         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2183                                                 pExynosComponent->callbackData,
2184                                                 OMX_EventError, ret, 0, NULL);
2185     }
2186
2187 EXIT:
2188     FunctionOut();
2189
2190     return ret;
2191 }
2192
2193 OMX_ERRORTYPE Exynos_H264Enc_srcOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pSrcOutputData)
2194 {
2195     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2196     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2197     EXYNOS_H264ENC_HANDLE    *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2198     EXYNOS_OMX_BASEPORT      *pExynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2199
2200     FunctionIn();
2201
2202     if ((!CHECK_PORT_ENABLED(pExynosInputPort)) || (!CHECK_PORT_POPULATED(pExynosInputPort))) {
2203         ret = OMX_ErrorNone;
2204         goto EXIT;
2205     }
2206
2207     if (pExynosInputPort->bufferProcessType & BUFFER_COPY) {
2208         if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, INPUT_PORT_INDEX)) {
2209             ret = OMX_ErrorNone;
2210             goto EXIT;
2211         }
2212     }
2213     if ((pH264Enc->bSourceStart == OMX_FALSE) &&
2214        (!CHECK_PORT_BEING_FLUSHED(pExynosInputPort))) {
2215         Exynos_OSAL_SignalWait(pH264Enc->hSourceStartEvent, DEF_MAX_WAIT_TIME);
2216         Exynos_OSAL_SignalReset(pH264Enc->hSourceStartEvent);
2217     }
2218
2219     ret = Exynos_H264Enc_SrcOut(pOMXComponent, pSrcOutputData);
2220     if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2221         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - SrcOut -> event is thrown to client", __FUNCTION__, __LINE__);
2222         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2223                                                 pExynosComponent->callbackData,
2224                                                 OMX_EventError, ret, 0, NULL);
2225     }
2226
2227 EXIT:
2228     FunctionOut();
2229
2230     return ret;
2231 }
2232
2233 OMX_ERRORTYPE Exynos_H264Enc_dstInputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstInputData)
2234 {
2235     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2236     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2237     EXYNOS_H264ENC_HANDLE    *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2238     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2239
2240     FunctionIn();
2241
2242     if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2243         ret = OMX_ErrorNone;
2244         goto EXIT;
2245     }
2246     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2247         ret = OMX_ErrorNone;
2248         goto EXIT;
2249     }
2250     if (pExynosOutputPort->bufferProcessType & BUFFER_SHARE) {
2251         if ((pH264Enc->bDestinationStart == OMX_FALSE) &&
2252            (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2253             Exynos_OSAL_SignalWait(pH264Enc->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2254             Exynos_OSAL_SignalReset(pH264Enc->hDestinationStartEvent);
2255         }
2256     }
2257     if (pH264Enc->hMFCH264Handle.bConfiguredMFCDst == OMX_TRUE) {
2258         ret = Exynos_H264Enc_DstIn(pOMXComponent, pDstInputData);
2259         if (ret != OMX_ErrorNone) {
2260             Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - DstIn -> event is thrown to client", __FUNCTION__, __LINE__);
2261             pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2262                                                 pExynosComponent->callbackData,
2263                                                 OMX_EventError, ret, 0, NULL);
2264         }
2265     }
2266
2267 EXIT:
2268     FunctionOut();
2269
2270     return ret;
2271 }
2272
2273 OMX_ERRORTYPE Exynos_H264Enc_dstOutputBufferProcess(OMX_COMPONENTTYPE *pOMXComponent, EXYNOS_OMX_DATA *pDstOutputData)
2274 {
2275     OMX_ERRORTYPE             ret = OMX_ErrorNone;
2276     EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2277     EXYNOS_H264ENC_HANDLE    *pH264Enc = (EXYNOS_H264ENC_HANDLE *)((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle;
2278     EXYNOS_OMX_BASEPORT      *pExynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2279
2280     FunctionIn();
2281
2282     if ((!CHECK_PORT_ENABLED(pExynosOutputPort)) || (!CHECK_PORT_POPULATED(pExynosOutputPort))) {
2283         ret = OMX_ErrorNone;
2284         goto EXIT;
2285     }
2286     if (OMX_FALSE == Exynos_Check_BufferProcess_State(pExynosComponent, OUTPUT_PORT_INDEX)) {
2287         ret = OMX_ErrorNone;
2288         goto EXIT;
2289     }
2290
2291     if (pExynosOutputPort->bufferProcessType & BUFFER_COPY) {
2292         if ((pH264Enc->bDestinationStart == OMX_FALSE) &&
2293            (!CHECK_PORT_BEING_FLUSHED(pExynosOutputPort))) {
2294             Exynos_OSAL_SignalWait(pH264Enc->hDestinationStartEvent, DEF_MAX_WAIT_TIME);
2295             Exynos_OSAL_SignalReset(pH264Enc->hDestinationStartEvent);
2296         }
2297     }
2298     ret = Exynos_H264Enc_DstOut(pOMXComponent, pDstOutputData);
2299     if ((ret != OMX_ErrorNone) && (pExynosComponent->currentState == OMX_StateExecuting)) {
2300         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: %d: Failed - DstOut -> event is thrown to client", __FUNCTION__, __LINE__);
2301         pExynosComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
2302                                                 pExynosComponent->callbackData,
2303                                                 OMX_EventError, ret, 0, NULL);
2304     }
2305
2306 EXIT:
2307     FunctionOut();
2308
2309     return ret;
2310 }
2311
2312 OSCL_EXPORT_REF OMX_ERRORTYPE Exynos_OMX_ComponentInit(
2313     OMX_HANDLETYPE hComponent,
2314     OMX_STRING     componentName)
2315 {
2316     OMX_ERRORTYPE                  ret              = OMX_ErrorNone;
2317     OMX_COMPONENTTYPE             *pOMXComponent    = NULL;
2318     EXYNOS_OMX_BASECOMPONENT      *pExynosComponent = NULL;
2319     EXYNOS_OMX_BASEPORT           *pExynosPort      = NULL;
2320     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc        = NULL;
2321     EXYNOS_H264ENC_HANDLE         *pH264Enc         = NULL;
2322     int i = 0;
2323
2324     FunctionIn();
2325
2326     if ((hComponent == NULL) || (componentName == NULL)) {
2327         ret = OMX_ErrorBadParameter;
2328         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
2329         goto EXIT;
2330     }
2331     if (Exynos_OSAL_Strcmp(EXYNOS_OMX_COMPONENT_H264_ENC, componentName) != 0) {
2332         ret = OMX_ErrorBadParameter;
2333         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorBadParameter, componentName:%s, Line:%d", componentName, __LINE__);
2334         goto EXIT;
2335     }
2336
2337     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2338     ret = Exynos_OMX_VideoEncodeComponentInit(pOMXComponent);
2339     if (ret != OMX_ErrorNone) {
2340         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_Error, Line:%d", __LINE__);
2341         goto EXIT;
2342     }
2343     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2344     pExynosComponent->codecType = HW_VIDEO_ENC_CODEC;
2345
2346     pExynosComponent->componentName = (OMX_STRING)Exynos_OSAL_Malloc(MAX_OMX_COMPONENT_NAME_SIZE);
2347     if (pExynosComponent->componentName == NULL) {
2348         Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2349         ret = OMX_ErrorInsufficientResources;
2350         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2351         goto EXIT;
2352     }
2353     Exynos_OSAL_Memset(pExynosComponent->componentName, 0, MAX_OMX_COMPONENT_NAME_SIZE);
2354
2355     pH264Enc = Exynos_OSAL_Malloc(sizeof(EXYNOS_H264ENC_HANDLE));
2356     if (pH264Enc == NULL) {
2357         Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2358         ret = OMX_ErrorInsufficientResources;
2359         Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
2360         goto EXIT;
2361     }
2362     Exynos_OSAL_Memset(pH264Enc, 0, sizeof(EXYNOS_H264ENC_HANDLE));
2363     pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2364     pVideoEnc->hCodecHandle = (OMX_HANDLETYPE)pH264Enc;
2365     pVideoEnc->quantization.nQpI = 20;
2366     pVideoEnc->quantization.nQpP = 20;
2367     pVideoEnc->quantization.nQpB = 20;
2368     pVideoEnc->bSharedOutputFD = OMX_FALSE;
2369
2370     Exynos_OSAL_Strcpy(pExynosComponent->componentName, EXYNOS_OMX_COMPONENT_H264_ENC);
2371
2372     /* In case of BUFFER_COPY mode
2373             bShareableBuf = TRUE means MemoryType is V4L2_MEMORY_USERPTR
2374             bShareableBuf = FALSE means MemoryType is V4L2_MEMORY_MMAP
2375          In case of BUFFER_SHARE
2376             bShareableBuf should be TRUE, FALSE is ignored
2377     */
2378     pH264Enc->hMFCH264Handle.bShareableBuf = OMX_FALSE; //Check bStoreMetaData in Init function
2379     /* Set componentVersion */
2380     pExynosComponent->componentVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2381     pExynosComponent->componentVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2382     pExynosComponent->componentVersion.s.nRevision     = REVISION_NUMBER;
2383     pExynosComponent->componentVersion.s.nStep         = STEP_NUMBER;
2384     /* Set specVersion */
2385     pExynosComponent->specVersion.s.nVersionMajor = VERSIONMAJOR_NUMBER;
2386     pExynosComponent->specVersion.s.nVersionMinor = VERSIONMINOR_NUMBER;
2387     pExynosComponent->specVersion.s.nRevision     = REVISION_NUMBER;
2388     pExynosComponent->specVersion.s.nStep         = STEP_NUMBER;
2389
2390     /* Input port */
2391     pExynosPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
2392     pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2393     pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2394     pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2395     pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
2396     pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
2397     Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2398     Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "raw/video");
2399 #ifdef TIZEN_FEATURE_E3250
2400     pExynosPort->portDefinition.format.video.eColorFormat = OMX_SEC_COLOR_FormatNV12L_DmaBuf_Fd;
2401 #else
2402     pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
2403 #endif
2404     pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2405     pExynosPort->bufferProcessType = BUFFER_COPY;
2406     pExynosPort->portWayType = WAY2_PORT;
2407
2408     /* Output port */
2409     pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
2410     pExynosPort->portDefinition.format.video.nFrameWidth = DEFAULT_FRAME_WIDTH;
2411     pExynosPort->portDefinition.format.video.nFrameHeight= DEFAULT_FRAME_HEIGHT;
2412     pExynosPort->portDefinition.format.video.nStride = 0; /*DEFAULT_FRAME_WIDTH;*/
2413     pExynosPort->portDefinition.nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
2414     pExynosPort->portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
2415     Exynos_OSAL_Memset(pExynosPort->portDefinition.format.video.cMIMEType, 0, MAX_OMX_MIMETYPE_SIZE);
2416     Exynos_OSAL_Strcpy(pExynosPort->portDefinition.format.video.cMIMEType, "video/avc");
2417     pExynosPort->portDefinition.format.video.eColorFormat = OMX_COLOR_FormatUnused;
2418     pExynosPort->portDefinition.bEnabled = OMX_TRUE;
2419     pExynosPort->bufferProcessType = BUFFER_COPY;
2420     pExynosPort->portWayType = WAY2_PORT;
2421
2422     for(i = 0; i < ALL_PORT_NUM; i++) {
2423         INIT_SET_SIZE_VERSION(&pH264Enc->AVCComponent[i], OMX_VIDEO_PARAM_AVCTYPE);
2424         pH264Enc->AVCComponent[i].nPortIndex = i;
2425         pH264Enc->AVCComponent[i].eProfile   = OMX_VIDEO_AVCProfileBaseline;
2426         pH264Enc->AVCComponent[i].eLevel     = OMX_VIDEO_AVCLevel31;
2427
2428         pH264Enc->AVCComponent[i].nPFrames = 20;
2429     }
2430
2431     pOMXComponent->GetParameter      = &Exynos_H264Enc_GetParameter;
2432     pOMXComponent->SetParameter      = &Exynos_H264Enc_SetParameter;
2433     pOMXComponent->GetConfig         = &Exynos_H264Enc_GetConfig;
2434     pOMXComponent->SetConfig         = &Exynos_H264Enc_SetConfig;
2435     pOMXComponent->GetExtensionIndex = &Exynos_H264Enc_GetExtensionIndex;
2436     pOMXComponent->ComponentRoleEnum = &Exynos_H264Enc_ComponentRoleEnum;
2437     pOMXComponent->ComponentDeInit   = &Exynos_OMX_ComponentDeinit;
2438
2439     pExynosComponent->exynos_codec_componentInit      = &Exynos_H264Enc_Init;
2440     pExynosComponent->exynos_codec_componentTerminate = &Exynos_H264Enc_Terminate;
2441
2442     pVideoEnc->exynos_codec_srcInputProcess  = &Exynos_H264Enc_srcInputBufferProcess;
2443     pVideoEnc->exynos_codec_srcOutputProcess = &Exynos_H264Enc_srcOutputBufferProcess;
2444     pVideoEnc->exynos_codec_dstInputProcess  = &Exynos_H264Enc_dstInputBufferProcess;
2445     pVideoEnc->exynos_codec_dstOutputProcess = &Exynos_H264Enc_dstOutputBufferProcess;
2446
2447     pVideoEnc->exynos_codec_start         = &H264CodecStart;
2448     pVideoEnc->exynos_codec_stop          = &H264CodecStop;
2449     pVideoEnc->exynos_codec_bufferProcessRun = &H264CodecOutputBufferProcessRun;
2450     pVideoEnc->exynos_codec_enqueueAllBuffer = &H264CodecEnqueueAllBuffer;
2451
2452     pVideoEnc->exynos_checkInputFrame        = NULL;
2453     pVideoEnc->exynos_codec_getCodecInputPrivateData  = &GetCodecInputPrivateData;
2454     pVideoEnc->exynos_codec_getCodecOutputPrivateData = &GetCodecOutputPrivateData;
2455
2456 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2457     pVideoEnc->hSharedMemory = Exynos_OSAL_SharedMemory_Open();
2458     if (pVideoEnc->hSharedMemory == NULL) {
2459         Exynos_OSAL_Free(pH264Enc);
2460         pH264Enc = ((EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle)->hCodecHandle = NULL;
2461         Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2462         ret = OMX_ErrorInsufficientResources;
2463         goto EXIT;
2464     }
2465 #endif
2466     pExynosComponent->currentState = OMX_StateLoaded;
2467
2468     ret = OMX_ErrorNone;
2469
2470 EXIT:
2471     FunctionOut();
2472
2473     return ret;
2474 }
2475
2476 OMX_ERRORTYPE Exynos_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent)
2477 {
2478     OMX_ERRORTYPE            ret = OMX_ErrorNone;
2479     OMX_COMPONENTTYPE          *pOMXComponent = NULL;
2480     EXYNOS_OMX_BASECOMPONENT   *pExynosComponent = NULL;
2481     EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = NULL;
2482     EXYNOS_H264ENC_HANDLE      *pH264Enc         = NULL;
2483
2484     FunctionIn();
2485
2486     if (hComponent == NULL) {
2487         ret = OMX_ErrorBadParameter;
2488         goto EXIT;
2489     }
2490     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
2491     pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
2492     pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
2493 #ifndef TIZEN_FEATURE_E3250 /* do not use ion */
2494     Exynos_OSAL_SharedMemory_Close(pVideoEnc->hSharedMemory);
2495 #endif
2496     Exynos_OSAL_Free(pExynosComponent->componentName);
2497     pExynosComponent->componentName = NULL;
2498
2499     pH264Enc = (EXYNOS_H264ENC_HANDLE *)pVideoEnc->hCodecHandle;
2500     if (pH264Enc != NULL) {
2501         Exynos_OSAL_Free(pH264Enc);
2502         pH264Enc = pVideoEnc->hCodecHandle = NULL;
2503     }
2504
2505     ret = Exynos_OMX_VideoEncodeComponentDeinit(pOMXComponent);
2506     if (ret != OMX_ErrorNone) {
2507         goto EXIT;
2508     }
2509
2510     ret = OMX_ErrorNone;
2511
2512 EXIT:
2513     FunctionOut();
2514
2515     return ret;
2516 }