Home | History | Annotate | Download | only in videocodec 
      1 /*
      2 * Copyright (c) 2009-2011 Intel Corporation.  All rights reserved.
      3 *
      4 * Licensed under the Apache License, Version 2.0 (the "License");
      5 * you may not use this file except in compliance with the License.
      6 * You may obtain a copy of the License at
      7 *
      8 * http://www.apache.org/licenses/LICENSE-2.0
      9 *
     10 * Unless required by applicable law or agreed to in writing, software
     11 * distributed under the License is distributed on an "AS IS" BASIS,
     12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 * See the License for the specific language governing permissions and
     14 * limitations under the License.
     15 */
     16 
     17 
     18 #define LOG_TAG "OMXVideoEncoderBase"
     19 #include "OMXVideoEncoderBase.h"
     20 #include "IntelMetadataBuffer.h"
     21 #include <cutils/properties.h>
     22 #include <wrs_omxil_core/log.h>
     23 
     24 static const char *RAW_MIME_TYPE = "video/raw";
     25 
     26 OMXVideoEncoderBase::OMXVideoEncoderBase()
     27     :mVideoEncoder(NULL)
     28     ,mEncoderParams(NULL)
     29     ,mFrameInputCount(0)
     30     ,mFrameOutputCount(0)
     31     ,mFirstFrame(OMX_TRUE)
     32     ,mFrameRetrieved(OMX_TRUE)
     33     ,mStoreMetaDataInBuffers(OMX_FALSE)
     34     ,mSyncEncoding(OMX_TRUE)
     35     ,mOmxLogLevel(0)
     36     ,mBlackFramePointer(NULL) {
     37     mEncoderParams = new VideoParamsCommon();
     38     if (!mEncoderParams) LOGE("OMX_ErrorInsufficientResources");
     39 
     40     char logLevelProp[128];
     41     if (property_get("omxenc.debug", logLevelProp, NULL)) {
     42         mOmxLogLevel = atoi(logLevelProp);
     43         LOGD("Debug level is %d", mOmxLogLevel);
     44     }
     45 
     46     LOGV("OMXVideoEncoderBase::OMXVideoEncoderBase end");
     47 }
     48 
     49 OMXVideoEncoderBase::~OMXVideoEncoderBase() {
     50 
     51     // destroy ports
     52     if (this->ports) {
     53         if (this->ports[INPORT_INDEX]) {
     54             delete this->ports[INPORT_INDEX];
     55             this->ports[INPORT_INDEX] = NULL;
     56         }
     57 
     58         if (this->ports[OUTPORT_INDEX]) {
     59             delete this->ports[OUTPORT_INDEX];
     60             this->ports[OUTPORT_INDEX] = NULL;
     61         }
     62     }
     63 
     64     if (mBlackFramePointer) {
     65         free(mBlackFramePointer);
     66         mBlackFramePointer = NULL;
     67     }
     68     // Release video encoder object
     69     if(mVideoEncoder) {
     70         releaseVideoEncoder(mVideoEncoder);
     71         mVideoEncoder = NULL;
     72     }
     73 
     74     if(mEncoderParams) {
     75         delete mEncoderParams;
     76         mEncoderParams = NULL;
     77     }
     78 
     79 }
     80 
     81 OMX_ERRORTYPE OMXVideoEncoderBase::InitInputPort(void) {
     82     this->ports[INPORT_INDEX] = new PortVideo;
     83     if (this->ports[INPORT_INDEX] == NULL) {
     84         return OMX_ErrorInsufficientResources;
     85     }
     86 
     87     PortVideo *port = static_cast<PortVideo *>(this->ports[INPORT_INDEX]);
     88 
     89     // OMX_PARAM_PORTDEFINITIONTYPE
     90     OMX_PARAM_PORTDEFINITIONTYPE paramPortDefinitionInput;
     91     memset(&paramPortDefinitionInput, 0, sizeof(paramPortDefinitionInput));
     92     SetTypeHeader(&paramPortDefinitionInput, sizeof(paramPortDefinitionInput));
     93     paramPortDefinitionInput.nPortIndex = INPORT_INDEX;
     94     paramPortDefinitionInput.eDir = OMX_DirInput;
     95     paramPortDefinitionInput.nBufferCountActual = INPORT_ACTUAL_BUFFER_COUNT;
     96     paramPortDefinitionInput.nBufferCountMin = INPORT_MIN_BUFFER_COUNT;
     97     paramPortDefinitionInput.nBufferSize = INPORT_BUFFER_SIZE;
     98     paramPortDefinitionInput.bEnabled = OMX_TRUE;
     99     paramPortDefinitionInput.bPopulated = OMX_FALSE;
    100     paramPortDefinitionInput.eDomain = OMX_PortDomainVideo;
    101     paramPortDefinitionInput.format.video.cMIMEType = (OMX_STRING)RAW_MIME_TYPE;
    102     paramPortDefinitionInput.format.video.pNativeRender = NULL;
    103     paramPortDefinitionInput.format.video.nFrameWidth = 176;
    104     paramPortDefinitionInput.format.video.nFrameHeight = 144;
    105     paramPortDefinitionInput.format.video.nStride = 0;
    106     paramPortDefinitionInput.format.video.nSliceHeight = 0;
    107     paramPortDefinitionInput.format.video.nBitrate = 64000;
    108     paramPortDefinitionInput.format.video.xFramerate = 15 << 16;
    109     paramPortDefinitionInput.format.video.bFlagErrorConcealment = OMX_FALSE;
    110     paramPortDefinitionInput.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
    111     paramPortDefinitionInput.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
    112     paramPortDefinitionInput.format.video.pNativeWindow = NULL;
    113     paramPortDefinitionInput.bBuffersContiguous = OMX_FALSE;
    114     paramPortDefinitionInput.nBufferAlignment = 0;
    115 
    116     // Nothing specific to initialize input port.
    117     InitInputPortFormatSpecific(&paramPortDefinitionInput);
    118 
    119     port->SetPortDefinition(&paramPortDefinitionInput, true);
    120 
    121     // Set port buffer 4k aligned
    122     port->SetMemAlignment(4096);
    123 
    124     // OMX_VIDEO_PARAM_PORTFORMATTYPE
    125     OMX_VIDEO_PARAM_PORTFORMATTYPE paramPortFormat;
    126     memset(&paramPortFormat, 0, sizeof(paramPortFormat));
    127     SetTypeHeader(&paramPortFormat, sizeof(paramPortFormat));
    128     paramPortFormat.nPortIndex = INPORT_INDEX;
    129     paramPortFormat.nIndex = 0;
    130     paramPortFormat.eCompressionFormat = paramPortDefinitionInput.format.video.eCompressionFormat;
    131     paramPortFormat.eColorFormat = paramPortDefinitionInput.format.video.eColorFormat;
    132     paramPortFormat.xFramerate = paramPortDefinitionInput.format.video.xFramerate;
    133 
    134     port->SetPortVideoParam(&paramPortFormat, true);
    135 
    136     return OMX_ErrorNone;
    137 }
    138 
    139 
    140 OMX_ERRORTYPE OMXVideoEncoderBase::InitOutputPort(void) {
    141     this->ports[OUTPORT_INDEX] = new PortVideo;
    142     if (this->ports[OUTPORT_INDEX] == NULL) {
    143         return OMX_ErrorInsufficientResources;
    144     }
    145 
    146     PortVideo *port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
    147 
    148     // OMX_VIDEO_PARAM_BITRATETYPE
    149     memset(&mParamBitrate, 0, sizeof(mParamBitrate));
    150     SetTypeHeader(&mParamBitrate, sizeof(mParamBitrate));
    151     mParamBitrate.nPortIndex = OUTPORT_INDEX;
    152     mParamBitrate.eControlRate = OMX_Video_ControlRateVariable;
    153     mParamBitrate.nTargetBitrate = 192000; // to be overridden
    154 
    155     // OMX_VIDEO_CONFIG_PRI_INFOTYPE
    156     memset(&mConfigPriInfo, 0, sizeof(mConfigPriInfo));
    157     SetTypeHeader(&mConfigPriInfo, sizeof(mConfigPriInfo));
    158     mConfigPriInfo.nPortIndex = OUTPORT_INDEX;
    159     mConfigPriInfo.nCapacity = 0;
    160     mConfigPriInfo.nHolder = NULL;
    161 
    162     // OMX_VIDEO_CONFIG_INTEL_BITRATETYPE
    163     memset(&mConfigIntelBitrate, 0, sizeof(mConfigIntelBitrate));
    164     SetTypeHeader(&mConfigIntelBitrate, sizeof(mConfigIntelBitrate));
    165     mConfigIntelBitrate.nPortIndex = OUTPORT_INDEX;
    166     mConfigIntelBitrate.nMaxEncodeBitrate = 0; // Maximum bitrate
    167     mConfigIntelBitrate.nTargetPercentage = 95; // Target bitrate as percentage of maximum bitrate; e.g. 95 is 95%
    168     mConfigIntelBitrate.nWindowSize = 0; // Window size in milliseconds allowed for bitrate to reach target
    169     mConfigIntelBitrate.nInitialQP = 0;  // Initial QP for I frames
    170     mConfigIntelBitrate.nMinQP = 0;
    171     mConfigIntelBitrate.nMaxQP = 0;
    172     mConfigIntelBitrate.nFrameRate = 0;
    173     mConfigIntelBitrate.nTemporalID = 0;
    174 
    175     // OMX_VIDEO_CONFIG_BITRATETYPE
    176     memset(&mConfigBitrate, 0, sizeof(mConfigBitrate));
    177     SetTypeHeader(&mConfigBitrate, sizeof(mConfigBitrate));
    178     mConfigBitrate.nPortIndex = OUTPORT_INDEX;
    179     mConfigBitrate.nEncodeBitrate = 0; // Maximum bitrate
    180 
    181     // OMX_VIDEO_CONFIG_INTEL_AIR
    182     memset(&mConfigIntelAir, 0, sizeof(mConfigIntelAir));
    183     SetTypeHeader(&mConfigIntelAir, sizeof(mConfigIntelAir));
    184     mConfigIntelAir.nPortIndex = OUTPORT_INDEX;
    185     mConfigIntelAir.bAirEnable = OMX_FALSE;
    186     mConfigIntelAir.bAirAuto = OMX_FALSE;
    187     mConfigIntelAir.nAirMBs = 0;
    188     mConfigIntelAir.nAirThreshold = 0;
    189 
    190     // OMX_VIDEO_CONFIG_INTEL_AIR
    191     memset(&mParamVideoRefresh, 0, sizeof(mParamVideoRefresh));
    192     SetTypeHeader(&mParamVideoRefresh, sizeof(mParamVideoRefresh));
    193     mParamVideoRefresh.nPortIndex = OUTPORT_INDEX;
    194     mParamVideoRefresh.eRefreshMode = OMX_VIDEO_IntraRefreshAdaptive;
    195     mParamVideoRefresh.nAirMBs = 0;
    196     mParamVideoRefresh.nAirRef = 0;
    197     mParamVideoRefresh.nCirMBs = 0;
    198 
    199     // OMX_CONFIG_FRAMERATETYPE
    200     memset(&mConfigFramerate, 0, sizeof(mConfigFramerate));
    201     SetTypeHeader(&mConfigFramerate, sizeof(mConfigFramerate));
    202     mConfigFramerate.nPortIndex = OUTPORT_INDEX;
    203     mConfigFramerate.xEncodeFramerate =  0; // Q16 format
    204 
    205     // OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL
    206     memset(&mParamIntelAdaptiveSliceControl, 0, sizeof(mParamIntelAdaptiveSliceControl));
    207     SetTypeHeader(&mParamIntelAdaptiveSliceControl, sizeof(mParamIntelAdaptiveSliceControl));
    208     mParamIntelAdaptiveSliceControl.nPortIndex = OUTPORT_INDEX;
    209     mParamIntelAdaptiveSliceControl.bEnable = OMX_FALSE;
    210     mParamIntelAdaptiveSliceControl.nMinPSliceNumber = 5;
    211     mParamIntelAdaptiveSliceControl.nNumPFramesToSkip = 8;
    212     mParamIntelAdaptiveSliceControl.nSliceSizeThreshold = 1200;
    213 
    214     // OMX_VIDEO_PARAM_PROFILELEVELTYPE
    215     memset(&mParamProfileLevel, 0, sizeof(mParamProfileLevel));
    216     SetTypeHeader(&mParamProfileLevel, sizeof(mParamProfileLevel));
    217     mParamProfileLevel.nPortIndex = OUTPORT_INDEX;
    218     mParamProfileLevel.eProfile = 0; // undefined profile, to be overridden
    219     mParamProfileLevel.eLevel = 0; // undefined level, to be overridden
    220 
    221     // OMX_PARAM_PORTDEFINITIONTYPE
    222     OMX_PARAM_PORTDEFINITIONTYPE paramPortDefinitionOutput;
    223     memset(&paramPortDefinitionOutput, 0, sizeof(paramPortDefinitionOutput));
    224     SetTypeHeader(&paramPortDefinitionOutput, sizeof(paramPortDefinitionOutput));
    225     paramPortDefinitionOutput.nPortIndex = OUTPORT_INDEX;
    226     paramPortDefinitionOutput.eDir = OMX_DirOutput;
    227     paramPortDefinitionOutput.nBufferCountActual = OUTPORT_ACTUAL_BUFFER_COUNT; // to be overridden
    228     paramPortDefinitionOutput.nBufferCountMin = OUTPORT_MIN_BUFFER_COUNT;
    229     paramPortDefinitionOutput.nBufferSize = OUTPORT_BUFFER_SIZE; // to be overridden
    230     paramPortDefinitionOutput.bEnabled = OMX_TRUE;
    231     paramPortDefinitionOutput.bPopulated = OMX_FALSE;
    232     paramPortDefinitionOutput.eDomain = OMX_PortDomainVideo;
    233     paramPortDefinitionOutput.format.video.cMIMEType = NULL; // to be overridden
    234     paramPortDefinitionOutput.format.video.pNativeRender = NULL;
    235     paramPortDefinitionOutput.format.video.nFrameWidth = 176;
    236     paramPortDefinitionOutput.format.video.nFrameHeight = 144;
    237     paramPortDefinitionOutput.format.video.nStride = 176;
    238     paramPortDefinitionOutput.format.video.nSliceHeight = 144;
    239     paramPortDefinitionOutput.format.video.nBitrate = 64000;
    240     paramPortDefinitionOutput.format.video.xFramerate = 15 << 16;
    241     paramPortDefinitionOutput.format.video.bFlagErrorConcealment = OMX_FALSE;
    242     paramPortDefinitionOutput.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused; // to be overridden
    243     paramPortDefinitionOutput.format.video.eColorFormat = OMX_COLOR_FormatUnused;
    244     paramPortDefinitionOutput.format.video.pNativeWindow = NULL;
    245     paramPortDefinitionOutput.bBuffersContiguous = OMX_FALSE;
    246     paramPortDefinitionOutput.nBufferAlignment = 0;
    247 
    248     InitOutputPortFormatSpecific(&paramPortDefinitionOutput);
    249 
    250     port->SetPortDefinition(&paramPortDefinitionOutput, true);
    251     port->SetPortBitrateParam(&mParamBitrate, true);
    252 
    253     // OMX_VIDEO_PARAM_PORTFORMATTYPE
    254     OMX_VIDEO_PARAM_PORTFORMATTYPE paramPortFormat;
    255     memset(&paramPortFormat, 0, sizeof(paramPortFormat));
    256     SetTypeHeader(&paramPortFormat, sizeof(paramPortFormat));
    257     paramPortFormat.nPortIndex = OUTPORT_INDEX;
    258     paramPortFormat.nIndex = 0;
    259     paramPortFormat.eCompressionFormat = paramPortDefinitionOutput.format.video.eCompressionFormat;
    260     paramPortFormat.eColorFormat = paramPortDefinitionOutput.format.video.eColorFormat;
    261     paramPortFormat.xFramerate = paramPortDefinitionOutput.format.video.xFramerate;
    262 
    263     port->SetPortVideoParam(&paramPortFormat, true);
    264     return OMX_ErrorNone;
    265 }
    266 
    267 OMX_ERRORTYPE OMXVideoEncoderBase::InitInputPortFormatSpecific(OMX_PARAM_PORTDEFINITIONTYPE *) {
    268     // no format specific to initialize input
    269     return OMX_ErrorNone;
    270 }
    271 
    272 OMX_ERRORTYPE OMXVideoEncoderBase::SetVideoEncoderParam() {
    273 
    274     Encode_Status ret = ENCODE_SUCCESS;
    275     PortVideo *port_in = NULL;
    276     const OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionInput = NULL;
    277     LOGV("OMXVideoEncoderBase::SetVideoEncoderParam called\n");
    278 
    279     port_in = static_cast<PortVideo *>(ports[INPORT_INDEX]);
    280     paramPortDefinitionInput = port_in->GetPortDefinition();
    281     mEncoderParams->resolution.height = paramPortDefinitionInput->format.video.nFrameHeight;
    282     mEncoderParams->resolution.width = paramPortDefinitionInput->format.video.nFrameWidth;
    283 
    284     mEncoderParams->frameRate.frameRateDenom = 1;
    285     if(mConfigFramerate.xEncodeFramerate != 0) {
    286         mEncoderParams->frameRate.frameRateNum = mConfigFramerate.xEncodeFramerate;
    287     } else {
    288         mEncoderParams->frameRate.frameRateNum = paramPortDefinitionInput->format.video.xFramerate >> 16;
    289         mConfigFramerate.xEncodeFramerate = paramPortDefinitionInput->format.video.xFramerate >> 16;
    290     }
    291 
    292     if(mEncoderParams->intraPeriod == 0) {
    293         OMX_U32 intraPeriod = mEncoderParams->frameRate.frameRateNum / 2;
    294         mEncoderParams->intraPeriod = (intraPeriod < 15) ? 15 : intraPeriod;   // Limit intra frame period to ensure video quality for low bitrate application.
    295     }
    296 
    297     if (paramPortDefinitionInput->format.video.eColorFormat == OMX_COLOR_FormatAndroidOpaque)
    298         mEncoderParams->rawFormat = RAW_FORMAT_OPAQUE;
    299     else
    300         mEncoderParams->rawFormat = RAW_FORMAT_NV12;
    301 
    302     LOGV("frameRate.frameRateDenom = %d\n", mEncoderParams->frameRate.frameRateDenom);
    303     LOGV("frameRate.frameRateNum = %d\n", mEncoderParams->frameRate.frameRateNum);
    304     LOGV("intraPeriod = %d\n ", mEncoderParams->intraPeriod);
    305     mEncoderParams->rcParams.initQP = mConfigIntelBitrate.nInitialQP;
    306     mEncoderParams->rcParams.minQP = mConfigIntelBitrate.nMinQP;
    307     mEncoderParams->rcParams.maxQP = 0;
    308     mEncoderParams->rcParams.I_minQP = 0;
    309     mEncoderParams->rcParams.I_maxQP = 0;
    310     mEncoderParams->rcParams.windowSize = mConfigIntelBitrate.nWindowSize;
    311     mEncoderParams->rcParams.targetPercentage = mConfigIntelBitrate.nTargetPercentage;
    312     mEncoderParams->rcParams.enableIntraFrameQPControl = 0;
    313 
    314     mEncoderParams->rcParams.bitRate = mParamBitrate.nTargetBitrate;
    315     if ((mParamBitrate.eControlRate == OMX_Video_ControlRateConstant )||
    316             (mParamBitrate.eControlRate == OMX_Video_ControlRateConstantSkipFrames)) {
    317         LOGV("%s(), eControlRate == OMX_Video_Intel_ControlRateConstant", __func__);
    318         mEncoderParams->rcMode = RATE_CONTROL_CBR;
    319     } else if ((mParamBitrate.eControlRate == OMX_Video_ControlRateVariable) ||
    320             (mParamBitrate.eControlRate == OMX_Video_ControlRateVariableSkipFrames)) {
    321         LOGV("%s(), eControlRate == OMX_Video_Intel_ControlRateVariable", __func__);
    322         mEncoderParams->rcMode = RATE_CONTROL_VBR;
    323     } else if (mParamBitrate.eControlRate == (OMX_VIDEO_CONTROLRATETYPE)OMX_Video_Intel_ControlRateVideoConferencingMode) {
    324         LOGV("%s(), eControlRate == OMX_Video_Intel_ControlRateVideoConferencingMode ", __func__);
    325         mEncoderParams->rcMode = RATE_CONTROL_VCM;
    326         if(mConfigIntelBitrate.nMaxEncodeBitrate >0)
    327             mEncoderParams->rcParams.bitRate = mConfigIntelBitrate.nMaxEncodeBitrate;
    328         if(mConfigIntelAir.bAirEnable == OMX_TRUE) {
    329             mEncoderParams->airParams.airAuto = mConfigIntelAir.bAirAuto;
    330             mEncoderParams->airParams.airMBs = mConfigIntelAir.nAirMBs;
    331             mEncoderParams->airParams.airThreshold = mConfigIntelAir.nAirThreshold;
    332             mEncoderParams->refreshType = VIDEO_ENC_AIR;
    333         } else {
    334             mEncoderParams->refreshType = VIDEO_ENC_NONIR;
    335         }
    336         LOGV("refreshType = %d\n", mEncoderParams->refreshType);
    337     } else {
    338         mEncoderParams->rcMode = RATE_CONTROL_NONE;
    339     }
    340 
    341     ret = mVideoEncoder->setParameters(mEncoderParams);
    342     CHECK_ENCODE_STATUS("setParameters");
    343     return OMX_ErrorNone;
    344 }
    345 
    346 OMX_ERRORTYPE OMXVideoEncoderBase::ProcessorInit(void) {
    347     OMX_ERRORTYPE ret = OMX_ErrorNone;
    348     ret = SetVideoEncoderParam();
    349     CHECK_STATUS("SetVideoEncoderParam");
    350 
    351     Encode_Status status = mVideoEncoder->start();
    352     if (status != ENCODE_SUCCESS) {
    353         LOGE("Start failed, status = 0x%08x\n", status);
    354         return OMX_ErrorUndefined;
    355     }
    356 
    357     return OMX_ErrorNone;
    358 }
    359 
    360 OMX_ERRORTYPE OMXVideoEncoderBase::ProcessorDeinit(void) {
    361     if(mVideoEncoder) {
    362         mVideoEncoder->stop();
    363     }
    364 
    365     return OMX_ErrorNone;
    366 }
    367 
    368 OMX_ERRORTYPE OMXVideoEncoderBase::ProcessorStop(void) {
    369 
    370     this->ports[INPORT_INDEX]->ReturnAllRetainedBuffers();
    371     return OMX_ErrorNone;
    372 }
    373 OMX_ERRORTYPE OMXVideoEncoderBase:: ProcessorProcess(
    374     OMX_BUFFERHEADERTYPE **,
    375     buffer_retain_t *,
    376     OMX_U32) {
    377 
    378     LOGV("OMXVideoEncoderBase:: ProcessorProcess \n");
    379     return OMX_ErrorNone;
    380 }
    381 
    382 OMX_ERRORTYPE OMXVideoEncoderBase::ProcessorFlush(OMX_U32 portIndex) {
    383     LOGV("OMXVideoEncoderBase::ProcessorFlush\n");
    384     if (portIndex == INPORT_INDEX || portIndex == OMX_ALL) {
    385         this->ports[INPORT_INDEX]->ReturnAllRetainedBuffers();
    386         mVideoEncoder->flush();
    387     }
    388     return OMX_ErrorNone;
    389 }
    390 
    391 OMX_ERRORTYPE OMXVideoEncoderBase::BuildHandlerList(void) {
    392     OMXComponentCodecBase::BuildHandlerList();
    393     AddHandler(OMX_IndexParamVideoPortFormat, GetParamVideoPortFormat, SetParamVideoPortFormat);
    394     AddHandler(OMX_IndexParamVideoBitrate, GetParamVideoBitrate, SetParamVideoBitrate);
    395     AddHandler((OMX_INDEXTYPE)OMX_IndexIntelPrivateInfo, GetIntelPrivateInfo, SetIntelPrivateInfo);
    396     AddHandler((OMX_INDEXTYPE)OMX_IndexConfigIntelBitrate, GetConfigIntelBitrate, SetConfigIntelBitrate);
    397     AddHandler((OMX_INDEXTYPE)OMX_IndexConfigIntelAIR, GetConfigIntelAIR, SetConfigIntelAIR);
    398     AddHandler((OMX_INDEXTYPE)OMX_IndexParamVideoIntraRefresh, GetParamVideoIntraRefresh, SetParamVideoIntraRefresh);
    399     AddHandler(OMX_IndexConfigVideoFramerate, GetConfigVideoFramerate, SetConfigVideoFramerate);
    400     AddHandler(OMX_IndexConfigVideoIntraVOPRefresh, GetConfigVideoIntraVOPRefresh, SetConfigVideoIntraVOPRefresh);
    401     //AddHandler(OMX_IndexParamIntelAdaptiveSliceControl, GetParamIntelAdaptiveSliceControl, SetParamIntelAdaptiveSliceControl);
    402     //AddHandler(OMX_IndexParamVideoProfileLevelQuerySupported, GetParamVideoProfileLevelQuerySupported, SetParamVideoProfileLevelQuerySupported);
    403     AddHandler((OMX_INDEXTYPE)OMX_IndexStoreMetaDataInBuffers, GetStoreMetaDataInBuffers, SetStoreMetaDataInBuffers);
    404     AddHandler((OMX_INDEXTYPE)OMX_IndexExtSyncEncoding, GetSyncEncoding, SetSyncEncoding);
    405     AddHandler((OMX_INDEXTYPE)OMX_IndexExtPrependSPSPPS, GetPrependSPSPPS, SetPrependSPSPPS);
    406     AddHandler((OMX_INDEXTYPE)OMX_IndexExtTemporalLayer, GetTemporalLayer,SetTemporalLayer);
    407     AddHandler((OMX_INDEXTYPE)OMX_IndexConfigVideoBitrate, GetConfigVideoBitrate, SetConfigVideoBitrate);
    408     AddHandler((OMX_INDEXTYPE)OMX_IndexExtRequestBlackFramePointer, GetBlackFramePointer, GetBlackFramePointer);
    409     return OMX_ErrorNone;
    410 }
    411 
    412 OMX_ERRORTYPE OMXVideoEncoderBase::GetParamVideoPortFormat(OMX_PTR pStructure) {
    413     OMX_ERRORTYPE ret;
    414     OMX_U32 index;
    415     OMX_VIDEO_PARAM_PORTFORMATTYPE *p = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pStructure;
    416 
    417     CHECK_TYPE_HEADER(p);
    418     CHECK_PORT_INDEX_RANGE(p);
    419     CHECK_ENUMERATION_RANGE(p->nIndex, 2);
    420 
    421     PortVideo *port = NULL;
    422     port = static_cast<PortVideo *>(this->ports[p->nPortIndex]);
    423     index = p->nIndex;
    424     memcpy(p, port->GetPortVideoParam(), sizeof(*p));
    425     // port supports OMX_COLOR_FormatYUV420SemiPlanar & OMX_COLOR_FormatAndroidOpaque
    426     if (index == 1) {
    427         p->nIndex = 1;
    428         p->eColorFormat = OMX_COLOR_FormatAndroidOpaque;
    429     }
    430     return OMX_ErrorNone;
    431 }
    432 
    433 OMX_ERRORTYPE OMXVideoEncoderBase::SetParamVideoPortFormat(OMX_PTR pStructure) {
    434     OMX_ERRORTYPE ret;
    435     OMX_VIDEO_PARAM_PORTFORMATTYPE *p = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pStructure;
    436 
    437     CHECK_TYPE_HEADER(p);
    438     CHECK_PORT_INDEX_RANGE(p);
    439     CHECK_SET_PARAM_STATE();
    440 
    441     // TODO: do we need to check if port is enabled?
    442     PortVideo *port = NULL;
    443     port = static_cast<PortVideo *>(this->ports[p->nPortIndex]);
    444 #if 0
    445     if (p->eColorFormat ==  OMX_COLOR_FormatAndroidOpaque) {
    446         p->nIndex = 0;
    447         p->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
    448     }
    449 #endif
    450     port->SetPortVideoParam(p, false);
    451     return OMX_ErrorNone;
    452 }
    453 
    454 OMX_ERRORTYPE OMXVideoEncoderBase::GetParamVideoBitrate(OMX_PTR pStructure) {
    455     OMX_ERRORTYPE ret;
    456     OMX_VIDEO_PARAM_BITRATETYPE *p = (OMX_VIDEO_PARAM_BITRATETYPE *)pStructure;
    457 
    458     CHECK_TYPE_HEADER(p);
    459     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    460     memcpy(p, &mParamBitrate, sizeof(*p));
    461     return OMX_ErrorNone;
    462 }
    463 
    464 OMX_ERRORTYPE OMXVideoEncoderBase::SetParamVideoBitrate(OMX_PTR pStructure) {
    465     OMX_ERRORTYPE ret;
    466     OMX_VIDEO_PARAM_BITRATETYPE *p = (OMX_VIDEO_PARAM_BITRATETYPE *)pStructure;
    467     CHECK_TYPE_HEADER(p);
    468     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    469     CHECK_SET_PARAM_STATE();
    470     OMX_U32 index = p->nPortIndex;
    471     PortVideo *port = NULL;
    472     // This disables other type of bitrate control mechanism
    473     // TODO: check if it is desired
    474 
    475     // TODO: can we override  mParamBitrate.nPortIndex (See SetPortBitrateParam)
    476     mParamBitrate.eControlRate = p->eControlRate;
    477     mParamBitrate.nTargetBitrate = p->nTargetBitrate;
    478 
    479     port = static_cast<PortVideo *>(ports[index]);
    480     ret = port->SetPortBitrateParam(p, false);
    481     return OMX_ErrorNone;
    482 }
    483 
    484 OMX_ERRORTYPE OMXVideoEncoderBase::GetIntelPrivateInfo(OMX_PTR pStructure) {
    485     OMX_ERRORTYPE ret;
    486     OMX_VIDEO_CONFIG_PRI_INFOTYPE *p = (OMX_VIDEO_CONFIG_PRI_INFOTYPE *)pStructure;
    487 
    488     CHECK_TYPE_HEADER(p);
    489     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    490     memcpy(p, &mConfigPriInfo, sizeof(*p));
    491     return OMX_ErrorNone;
    492 }
    493 
    494 OMX_ERRORTYPE OMXVideoEncoderBase::SetIntelPrivateInfo(OMX_PTR pStructure) {
    495     OMX_ERRORTYPE ret;
    496     OMX_VIDEO_CONFIG_PRI_INFOTYPE *p = (OMX_VIDEO_CONFIG_PRI_INFOTYPE *)pStructure;
    497     CHECK_TYPE_HEADER(p);
    498     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    499 
    500     // OMX_VIDEO_CONFIG_PRI_INFOTYPE is static parameter?
    501     CHECK_SET_PARAM_STATE();
    502 
    503     // TODO: can we override  mConfigPriInfo.nPortIndex (See SetPortPrivateInfoParam)
    504 
    505     if(p->nHolder != NULL) {
    506         // TODO: do we need to free nHolder?
    507         if (mConfigPriInfo.nHolder) {
    508             free(mConfigPriInfo.nHolder);
    509         }
    510         mConfigPriInfo.nCapacity = p->nCapacity;
    511         // TODO: nCapacity is in 8-bit unit or 32-bit unit?
    512         // TODO: check memory allocation
    513         mConfigPriInfo.nHolder = (OMX_PTR)malloc(sizeof(OMX_U32) * p->nCapacity);
    514         memcpy(mConfigPriInfo.nHolder, p->nHolder, sizeof(OMX_U32) * p->nCapacity);
    515     } else {
    516         mConfigPriInfo.nCapacity = 0;
    517         mConfigPriInfo.nHolder = NULL;
    518     }
    519 
    520     return OMX_ErrorNone;
    521 }
    522 
    523 OMX_ERRORTYPE OMXVideoEncoderBase::GetConfigIntelBitrate(OMX_PTR pStructure) {
    524     OMX_ERRORTYPE ret;
    525     OMX_VIDEO_CONFIG_INTEL_BITRATETYPE *p = (OMX_VIDEO_CONFIG_INTEL_BITRATETYPE *)pStructure;
    526 
    527     CHECK_TYPE_HEADER(p);
    528     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    529     memcpy(p, &mConfigIntelBitrate, sizeof(*p));
    530     return OMX_ErrorNone;
    531 }
    532 
    533 OMX_ERRORTYPE OMXVideoEncoderBase::SetConfigIntelBitrate(OMX_PTR pStructure) {
    534     OMX_ERRORTYPE ret;
    535     Encode_Status retStatus = ENCODE_SUCCESS;
    536     if (mParamBitrate.eControlRate == OMX_Video_ControlRateMax){
    537         LOGE("SetConfigIntelBitrate failed. Feature is disabled.");
    538         return OMX_ErrorUnsupportedIndex;
    539     }
    540     OMX_VIDEO_CONFIG_INTEL_BITRATETYPE *p = (OMX_VIDEO_CONFIG_INTEL_BITRATETYPE *)pStructure;
    541     CHECK_TYPE_HEADER(p);
    542     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    543 
    544     // set in either Loaded state (ComponentSetParam) or Executing state (ComponentSetConfig)
    545     mConfigIntelBitrate = *p;
    546 
    547     // return OMX_ErrorNone if not in Executing state
    548     // TODO: return OMX_ErrorIncorrectStateOperation?
    549     CHECK_SET_CONFIG_STATE();
    550 
    551     VideoConfigBitRate configBitRate;
    552     configBitRate.rcParams.bitRate = mConfigIntelBitrate.nMaxEncodeBitrate;
    553     configBitRate.rcParams.initQP = mConfigIntelBitrate.nInitialQP;
    554     configBitRate.rcParams.minQP = mConfigIntelBitrate.nMinQP;
    555     configBitRate.rcParams.maxQP = mConfigIntelBitrate.nMaxQP;
    556     configBitRate.rcParams.I_minQP = 0;
    557     configBitRate.rcParams.I_maxQP = 0;
    558     configBitRate.rcParams.windowSize = mConfigIntelBitrate.nWindowSize;
    559     configBitRate.rcParams.targetPercentage = mConfigIntelBitrate.nTargetPercentage;
    560     configBitRate.rcParams.enableIntraFrameQPControl = 0;
    561     configBitRate.rcParams.temporalFrameRate = mConfigIntelBitrate.nFrameRate;
    562     configBitRate.rcParams.temporalID = mConfigIntelBitrate.nTemporalID;
    563     retStatus = mVideoEncoder->setConfig(&configBitRate);
    564     if(retStatus != ENCODE_SUCCESS) {
    565         LOGW("failed to set IntelBitrate");
    566     }
    567     return OMX_ErrorNone;
    568 }
    569 
    570 OMX_ERRORTYPE OMXVideoEncoderBase::GetConfigIntelAIR(OMX_PTR pStructure) {
    571     OMX_ERRORTYPE ret;
    572     OMX_VIDEO_CONFIG_INTEL_AIR *p = (OMX_VIDEO_CONFIG_INTEL_AIR *)pStructure;
    573 
    574     CHECK_TYPE_HEADER(p);
    575     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    576     memcpy(p, &mConfigIntelAir, sizeof(*p));
    577     return OMX_ErrorNone;
    578 }
    579 
    580 OMX_ERRORTYPE OMXVideoEncoderBase::SetConfigIntelAIR(OMX_PTR pStructure) {
    581     OMX_ERRORTYPE ret;
    582     Encode_Status retStatus = ENCODE_SUCCESS;
    583 
    584     OMX_VIDEO_CONFIG_INTEL_AIR *p = (OMX_VIDEO_CONFIG_INTEL_AIR *)pStructure;
    585     CHECK_TYPE_HEADER(p);
    586     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    587 
    588     // set in either Loaded  state (ComponentSetParam) or Executing state (ComponentSetConfig)
    589     mConfigIntelAir = *p;
    590 
    591     // return OMX_ErrorNone if not in Executing state
    592     // TODO: return OMX_ErrorIncorrectStateOperation?
    593     CHECK_SET_CONFIG_STATE();
    594 
    595     VideoConfigAIR configAIR;
    596     VideoConfigIntraRefreshType configIntraRefreshType;
    597     if(mConfigIntelAir.bAirEnable == OMX_TRUE) {
    598         configAIR.airParams.airAuto = mConfigIntelAir.bAirAuto;
    599         configAIR.airParams.airMBs = mConfigIntelAir.nAirMBs;
    600         configAIR.airParams.airThreshold = mConfigIntelAir.nAirThreshold;
    601         configIntraRefreshType.refreshType = VIDEO_ENC_AIR;
    602     } else {
    603         configIntraRefreshType.refreshType = VIDEO_ENC_NONIR;
    604     }
    605 
    606     retStatus = mVideoEncoder->setConfig(&configAIR);
    607     if(retStatus != ENCODE_SUCCESS) {
    608         LOGW("Failed to set AIR config");
    609     }
    610 
    611     retStatus = mVideoEncoder->setConfig(&configIntraRefreshType);
    612     if(retStatus != ENCODE_SUCCESS) {
    613         LOGW("Failed to set refresh config");
    614     }
    615     return OMX_ErrorNone;
    616 }
    617 
    618 OMX_ERRORTYPE OMXVideoEncoderBase::GetParamVideoIntraRefresh(OMX_PTR pStructure) {
    619     OMX_ERRORTYPE ret;
    620     OMX_VIDEO_PARAM_INTRAREFRESHTYPE *p = (OMX_VIDEO_PARAM_INTRAREFRESHTYPE *)pStructure;
    621 
    622     CHECK_TYPE_HEADER(p);
    623     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    624     memcpy(p, &mParamVideoRefresh, sizeof(*p));
    625     return OMX_ErrorNone;
    626 }
    627 
    628 OMX_ERRORTYPE OMXVideoEncoderBase::SetParamVideoIntraRefresh(OMX_PTR pStructure) {
    629     OMX_ERRORTYPE ret;
    630     Encode_Status retStatus = ENCODE_SUCCESS;
    631 
    632     OMX_VIDEO_PARAM_INTRAREFRESHTYPE *p = (OMX_VIDEO_PARAM_INTRAREFRESHTYPE *)pStructure;
    633     CHECK_TYPE_HEADER(p);
    634     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    635 
    636     // set in either Loaded  state (ComponentSetParam) or Executing state (ComponentSetConfig)
    637     mParamVideoRefresh = *p;
    638 
    639     // return OMX_ErrorNone if not in Executing state
    640     // TODO: return OMX_ErrorIncorrectStateOperation?
    641     CHECK_SET_PARAM_STATE();
    642 
    643     VideoConfigIntraRefreshType configIntraRefreshType;
    644     configIntraRefreshType.refreshType = (VideoIntraRefreshType)(mParamVideoRefresh.eRefreshMode + 1);
    645     if(configIntraRefreshType.refreshType == VIDEO_ENC_CIR){
    646      VideoConfigCIR configCIR;
    647         VideoConfigIntraRefreshType configIntraRefreshType;
    648         configCIR.cirParams.cir_num_mbs = mParamVideoRefresh.nCirMBs;
    649         configIntraRefreshType.refreshType = VIDEO_ENC_CIR;
    650 
    651         retStatus = mVideoEncoder->setConfig(&configCIR);
    652         if(retStatus != ENCODE_SUCCESS) {
    653             LOGW("Failed to set CIR config");
    654         }
    655     }else{
    656         VideoConfigAIR configAIR;
    657 
    658         configAIR.airParams.airMBs = mParamVideoRefresh.nAirMBs;
    659         configAIR.airParams.airThreshold = mParamVideoRefresh.nAirRef;
    660 
    661         retStatus = mVideoEncoder->setConfig(&configAIR);
    662         if(retStatus != ENCODE_SUCCESS) {
    663             LOGW("Failed to set AIR config");
    664         }
    665 
    666     }
    667 
    668     retStatus = mVideoEncoder->setConfig(&configIntraRefreshType);
    669     if(retStatus != ENCODE_SUCCESS) {
    670         LOGW("Failed to set refresh config");
    671     }
    672 
    673     return OMX_ErrorNone;
    674 }
    675 
    676 OMX_ERRORTYPE OMXVideoEncoderBase::GetConfigVideoFramerate(OMX_PTR pStructure) {
    677     OMX_ERRORTYPE ret;
    678     OMX_CONFIG_FRAMERATETYPE *p = (OMX_CONFIG_FRAMERATETYPE *)pStructure;
    679 
    680     CHECK_TYPE_HEADER(p);
    681     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    682     memcpy(p, &mConfigFramerate, sizeof(*p));
    683     return OMX_ErrorNone;
    684 }
    685 
    686 OMX_ERRORTYPE OMXVideoEncoderBase::SetConfigVideoFramerate(OMX_PTR pStructure) {
    687     OMX_ERRORTYPE ret;
    688     Encode_Status retStatus = ENCODE_SUCCESS;
    689     if (mParamBitrate.eControlRate == OMX_Video_ControlRateMax){
    690         LOGE("SetConfigVideoFramerate failed. Feature is disabled.");
    691         return OMX_ErrorUnsupportedIndex;
    692     }
    693     OMX_CONFIG_FRAMERATETYPE *p = (OMX_CONFIG_FRAMERATETYPE *)pStructure;
    694     CHECK_TYPE_HEADER(p);
    695     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    696 
    697     // set in either Loaded state  (ComponentSetParam) or Executing state (ComponentSetConfig)
    698     mConfigFramerate = *p;
    699 
    700     // return OMX_ErrorNone if not in Executing state
    701     // TODO, return OMX_ErrorIncorrectStateOperation?
    702     CHECK_SET_CONFIG_STATE();
    703 
    704     VideoConfigFrameRate framerate;
    705     framerate.frameRate.frameRateDenom = 1;
    706     framerate.frameRate.frameRateNum = mConfigFramerate.xEncodeFramerate >> 16;
    707     retStatus = mVideoEncoder->setConfig(&framerate);
    708     if(retStatus != ENCODE_SUCCESS) {
    709         LOGW("Failed to set frame rate config");
    710     }
    711     return OMX_ErrorNone;
    712 }
    713 
    714 OMX_ERRORTYPE OMXVideoEncoderBase::GetConfigVideoIntraVOPRefresh(OMX_PTR) {
    715     LOGW("GetConfigVideoIntraVOPRefresh is not supported.");
    716     return OMX_ErrorUnsupportedSetting;
    717 }
    718 
    719 OMX_ERRORTYPE OMXVideoEncoderBase::SetConfigVideoIntraVOPRefresh(OMX_PTR pStructure) {
    720     OMX_ERRORTYPE ret;
    721     Encode_Status retStatus = ENCODE_SUCCESS;
    722     OMX_CONFIG_INTRAREFRESHVOPTYPE *p = (OMX_CONFIG_INTRAREFRESHVOPTYPE *)pStructure;
    723     CHECK_TYPE_HEADER(p);
    724     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    725 
    726     // return OMX_ErrorNone if not in Executing state
    727     // TODO: return OMX_ErrorIncorrectStateOperation?
    728     CHECK_SET_CONFIG_STATE();
    729 
    730     if(p->IntraRefreshVOP == OMX_TRUE) {
    731         VideoParamConfigSet configIDRRequest;
    732         configIDRRequest.type = VideoConfigTypeIDRRequest;
    733         retStatus = mVideoEncoder->setConfig(&configIDRRequest);
    734         if(retStatus != ENCODE_SUCCESS) {
    735             LOGW("Failed to set refresh config");
    736         }
    737     }
    738 
    739     return OMX_ErrorNone;
    740 }
    741 
    742 OMX_ERRORTYPE OMXVideoEncoderBase::GetParamIntelAdaptiveSliceControl(OMX_PTR pStructure) {
    743 
    744     OMX_ERRORTYPE ret;
    745     OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL *p = (OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL *)pStructure;
    746 
    747     CHECK_TYPE_HEADER(p);
    748     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    749     memcpy(p, &mParamIntelAdaptiveSliceControl, sizeof(*p));
    750 
    751     return OMX_ErrorNone;
    752 }
    753 
    754 OMX_ERRORTYPE OMXVideoEncoderBase::SetParamIntelAdaptiveSliceControl(OMX_PTR pStructure) {
    755 
    756     OMX_ERRORTYPE ret;
    757     if (mParamBitrate.eControlRate == OMX_Video_ControlRateMax) {
    758         LOGE("SetParamIntelAdaptiveSliceControl failed. Feature is disabled.");
    759         return OMX_ErrorUnsupportedIndex;
    760     }
    761     OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL *p = (OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL *)pStructure;
    762     CHECK_TYPE_HEADER(p);
    763     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    764 
    765     // set only in Loaded state (ComponentSetParam)
    766     CHECK_SET_PARAM_STATE();
    767 
    768     mParamIntelAdaptiveSliceControl = *p;
    769 
    770     return OMX_ErrorNone;
    771 }
    772 
    773 /*
    774 OMX_ERRORTYPE OMXVideoEncoderBase::GetParamVideoProfileLevelQuerySupported(OMX_PTR pStructure) {
    775     OMX_ERRORTYPE ret;
    776     OMX_VIDEO_PARAM_PROFILELEVELTYPE *p = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pStructure;
    777 
    778     CHECK_TYPE_HEADER(p);
    779     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    780 
    781     // assign values instead of memory coping to avoid nProfileIndex being overridden
    782     p->eProfile = mParamProfileLevel.eProfile;
    783     p->eLevel = mParamProfileLevel.eLevel;
    784 
    785     return OMX_ErrorNone;
    786 }
    787 
    788 OMX_ERRORTYPE OMXVideoEncoderBase::SetParamVideoProfileLevelQuerySupported(OMX_PTR pStructure) {
    789     LOGW("SetParamVideoProfileLevelQuerySupported is not supported.");
    790     return OMX_ErrorUnsupportedSetting;
    791 }
    792 */
    793 
    794 OMX_ERRORTYPE OMXVideoEncoderBase::GetStoreMetaDataInBuffers(OMX_PTR pStructure) {
    795     OMX_ERRORTYPE ret;
    796     StoreMetaDataInBuffersParams *p = (StoreMetaDataInBuffersParams *)pStructure;
    797 
    798     CHECK_TYPE_HEADER(p);
    799     CHECK_PORT_INDEX(p, INPORT_INDEX);
    800 
    801     p->bStoreMetaData = mStoreMetaDataInBuffers;
    802 
    803     return OMX_ErrorNone;
    804 };
    805 OMX_ERRORTYPE OMXVideoEncoderBase::SetStoreMetaDataInBuffers(OMX_PTR pStructure) {
    806     OMX_ERRORTYPE ret;
    807     StoreMetaDataInBuffersParams *p = (StoreMetaDataInBuffersParams *)pStructure;
    808     VideoParamsStoreMetaDataInBuffers StoreMetaDataInBuffers;
    809     PortVideo *port = static_cast<PortVideo *>(this->ports[INPORT_INDEX]);
    810 
    811     CHECK_TYPE_HEADER(p);
    812     CHECK_PORT_INDEX(p, INPORT_INDEX);
    813 
    814     LOGD("SetStoreMetaDataInBuffers (enabled = %x)", p->bStoreMetaData);
    815     if(mStoreMetaDataInBuffers == p->bStoreMetaData)
    816         return OMX_ErrorNone;
    817 
    818     StoreMetaDataInBuffers.isEnabled = p->bStoreMetaData;
    819     if (mVideoEncoder->setParameters(&StoreMetaDataInBuffers) != ENCODE_SUCCESS)
    820         return OMX_ErrorNotReady;
    821 
    822     mStoreMetaDataInBuffers = p->bStoreMetaData;
    823 
    824     if(mStoreMetaDataInBuffers){
    825         // for input port buffer
    826         OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionInput;
    827         const OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionInput_get;
    828 
    829         paramPortDefinitionInput_get = port->GetPortDefinition();
    830         paramPortDefinitionInput = (OMX_PARAM_PORTDEFINITIONTYPE *)paramPortDefinitionInput_get;
    831         paramPortDefinitionInput->nBufferSize = IntelMetadataBuffer::GetMaxBufferSize();
    832     }
    833     else
    834     {
    835         const OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionInput_get;
    836 
    837         paramPortDefinitionInput_get = port->GetPortDefinition();
    838         port->SetPortDefinition(paramPortDefinitionInput_get, true);
    839     }
    840 
    841     LOGD("SetStoreMetaDataInBuffers success");
    842     return OMX_ErrorNone;
    843 };
    844 
    845 OMX_ERRORTYPE OMXVideoEncoderBase::GetSyncEncoding(OMX_PTR pStructure) {
    846     OMX_BOOL* syncEncoding = static_cast<OMX_BOOL*>(pStructure);
    847 
    848     *syncEncoding = mSyncEncoding;
    849 
    850     return OMX_ErrorNone;
    851 };
    852 
    853 OMX_ERRORTYPE OMXVideoEncoderBase::SetSyncEncoding(OMX_PTR pStructure) {
    854     CHECK_SET_PARAM_STATE();
    855 
    856     mSyncEncoding = *(static_cast<OMX_BOOL*>(pStructure));
    857 
    858     LOGD("SetSyncEncoding %d", mSyncEncoding);
    859 
    860     return OMX_ErrorNone;
    861 };
    862 
    863 OMX_ERRORTYPE OMXVideoEncoderBase::GetPrependSPSPPS(OMX_PTR) {
    864     return OMX_ErrorNone;
    865 };
    866 
    867 OMX_ERRORTYPE OMXVideoEncoderBase::SetPrependSPSPPS(OMX_PTR) {
    868     LOGD("SetPrependSPSPPS success");
    869     return OMX_ErrorNone;
    870 };
    871 
    872 OMX_ERRORTYPE OMXVideoEncoderBase::GetTemporalLayer(OMX_PTR pStructure) {
    873     OMX_ERRORTYPE ret;
    874     OMX_VIDEO_PARAM_INTEL_TEMPORAL_LAYER* p = static_cast<OMX_VIDEO_PARAM_INTEL_TEMPORAL_LAYER*>(pStructure);
    875 
    876     CHECK_TYPE_HEADER(p);
    877     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    878     memcpy(p, &mTemporalLayer, sizeof(*p));
    879     return OMX_ErrorNone;
    880 }
    881 
    882 OMX_ERRORTYPE OMXVideoEncoderBase::SetTemporalLayer(OMX_PTR pStructure) {
    883     OMX_ERRORTYPE ret;
    884     OMX_VIDEO_PARAM_INTEL_TEMPORAL_LAYER *p = (OMX_VIDEO_PARAM_INTEL_TEMPORAL_LAYER *)pStructure;
    885     VideoParamsTemporalLayer TemporalLayer;
    886     OMX_U32 i;
    887 
    888     CHECK_TYPE_HEADER(p);
    889     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    890 
    891     LOGE("SetTemporalLayer (enabled = %d)", p->nNumberOfTemporalLayer);
    892 
    893     TemporalLayer.numberOfLayer = p->nNumberOfTemporalLayer;
    894     TemporalLayer.nPeriodicity = p->nPeriodicity;
    895     for(i=0;i<p->nPeriodicity;i++)
    896         TemporalLayer.nLayerID[i] = p->nLayerID[i];
    897 
    898     if (mVideoEncoder->setParameters(&TemporalLayer) != ENCODE_SUCCESS)
    899         return OMX_ErrorNotReady;
    900 
    901     LOGE("SetTemporalLayer success");
    902     return OMX_ErrorNone;
    903 }
    904 
    905 OMX_ERRORTYPE OMXVideoEncoderBase::GetBlackFramePointer(OMX_PTR pStructure) {
    906     OMX_ERRORTYPE ret;
    907     OMX_VIDEO_INTEL_REQUEST_BALCK_FRAME_POINTER *p = (OMX_VIDEO_INTEL_REQUEST_BALCK_FRAME_POINTER *)pStructure;
    908 
    909     CHECK_TYPE_HEADER(p);
    910     CHECK_PORT_INDEX(p, INPORT_INDEX);
    911 
    912     PortVideo *port_in = static_cast<PortVideo *>(ports[INPORT_INDEX]);
    913     const OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionInput = port_in->GetPortDefinition();
    914     OMX_U32 width = paramPortDefinitionInput->format.video.nFrameWidth;
    915     OMX_U32 height = paramPortDefinitionInput->format.video.nFrameHeight;
    916     OMX_U32 lumaSize = width * height;
    917     OMX_U32 bufferSize = width * height * 3 / 2;
    918 
    919     if(mBlackFramePointer) {
    920         free(mBlackFramePointer);
    921         mBlackFramePointer = NULL;
    922     } else {
    923         mBlackFramePointer = (OMX_PTR)memalign(4096, bufferSize); // align to page size
    924         if(!mBlackFramePointer) {
    925             return OMX_ErrorInsufficientResources;
    926         }
    927         memset(mBlackFramePointer, 0x0, lumaSize);
    928         memset((OMX_PTR)((uint64_t)mBlackFramePointer + lumaSize), 0x80, lumaSize / 2);
    929         p->nFramePointer = (OMX_U32)mBlackFramePointer;
    930     }
    931     return OMX_ErrorNone;
    932 }
    933 
    934 OMX_ERRORTYPE OMXVideoEncoderBase::SetBlackFramePointer(OMX_PTR) {
    935     return OMX_ErrorUnsupportedSetting;
    936 }
    937 
    938 OMX_ERRORTYPE OMXVideoEncoderBase::GetConfigVideoBitrate(OMX_PTR pStructure) {
    939 
    940     OMX_ERRORTYPE ret;
    941     OMX_VIDEO_CONFIG_BITRATETYPE *p = (OMX_VIDEO_CONFIG_BITRATETYPE *)pStructure;
    942 
    943     CHECK_TYPE_HEADER(p);
    944     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    945     memcpy(p, &mConfigBitrate, sizeof(*p));
    946     return OMX_ErrorNone;
    947 }
    948 OMX_ERRORTYPE OMXVideoEncoderBase::SetConfigVideoBitrate(OMX_PTR pStructure){
    949     OMX_ERRORTYPE ret;
    950     Encode_Status retStatus = ENCODE_SUCCESS;
    951     if (mParamBitrate.eControlRate == OMX_Video_ControlRateMax){
    952         LOGE("SetConfigIntelBitrate failed. Feature is disabled.");
    953         return OMX_ErrorUnsupportedIndex;
    954     }
    955     OMX_VIDEO_CONFIG_BITRATETYPE *p = (OMX_VIDEO_CONFIG_BITRATETYPE *)pStructure;
    956     CHECK_TYPE_HEADER(p);
    957     CHECK_PORT_INDEX(p, OUTPORT_INDEX);
    958 
    959     // set in either Loaded state (ComponentSetParam) or Executing state (ComponentSetConfig)
    960     mConfigBitrate = *p;
    961 
    962     // return OMX_ErrorNone if not in Executing state
    963     // TODO: return OMX_ErrorIncorrectStateOperation?
    964     // CHECK_SET_CONFIG_STATE();
    965 
    966     VideoConfigBitRate configBitRate;
    967     configBitRate.rcParams.bitRate = mConfigBitrate.nEncodeBitrate;
    968     configBitRate.rcParams.temporalID = 0;
    969     retStatus = mVideoEncoder->setConfig(&configBitRate);
    970     if(retStatus != ENCODE_SUCCESS) {
    971         LOGW("failed to set IntelBitrate");
    972     }
    973     return OMX_ErrorNone;
    974 }
    975