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