OMX_ERRORTYPE OMXVideoEncoderBase::GetBlackFramePointer(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_INTEL_REQUEST_BALCK_FRAME_POINTER *p = (OMX_VIDEO_INTEL_REQUEST_BALCK_FRAME_POINTER *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, INPORT_INDEX);
PortVideo *port_in = static_cast<PortVideo *>(ports[INPORT_INDEX]);
const OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionInput = port_in->GetPortDefinition();
OMX_U32 width = paramPortDefinitionInput->format.video.nFrameWidth;
OMX_U32 height = paramPortDefinitionInput->format.video.nFrameHeight;
OMX_U32 lumaSize = width * height;
OMX_U32 bufferSize = width * height * 3 / 2;
if(mBlackFramePointer) {
free(mBlackFramePointer);
mBlackFramePointer = NULL;
} else {
mBlackFramePointer = (OMX_PTR)memalign(4096, bufferSize); // align to page size
if(!mBlackFramePointer) {
return OMX_ErrorInsufficientResources;
}
memset(mBlackFramePointer, 0x0, lumaSize);
memset((OMX_PTR)((uint64_t)mBlackFramePointer + lumaSize), 0x80, lumaSize / 2);
p->nFramePointer = (OMX_U32)mBlackFramePointer;
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::SetIntelPrivateInfo(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_CONFIG_PRI_INFOTYPE *p = (OMX_VIDEO_CONFIG_PRI_INFOTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
// OMX_VIDEO_CONFIG_PRI_INFOTYPE is static parameter?
CHECK_SET_PARAM_STATE();
// TODO: can we override mConfigPriInfo.nPortIndex (See SetPortPrivateInfoParam)
if(p->nHolder != NULL) {
// TODO: do we need to free nHolder?
if (mConfigPriInfo.nHolder) {
free(mConfigPriInfo.nHolder);
}
mConfigPriInfo.nCapacity = p->nCapacity;
// TODO: nCapacity is in 8-bit unit or 32-bit unit?
// TODO: check memory allocation
mConfigPriInfo.nHolder = (OMX_PTR)malloc(sizeof(OMX_U32) * p->nCapacity);
memcpy(mConfigPriInfo.nHolder, p->nHolder, sizeof(OMX_U32) * p->nCapacity);
} else {
mConfigPriInfo.nCapacity = 0;
mConfigPriInfo.nHolder = NULL;
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::SetConfigVideoBitrate(OMX_PTR pStructure){
OMX_ERRORTYPE ret;
Encode_Status retStatus = ENCODE_SUCCESS;
if (mParamBitrate.eControlRate == OMX_Video_ControlRateMax){
LOGE("SetConfigIntelBitrate failed. Feature is disabled.");
return OMX_ErrorUnsupportedIndex;
}
OMX_VIDEO_CONFIG_BITRATETYPE *p = (OMX_VIDEO_CONFIG_BITRATETYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
// set in either Loaded state (ComponentSetParam) or Executing state (ComponentSetConfig)
mConfigBitrate = *p;
// return OMX_ErrorNone if not in Executing state
// TODO: return OMX_ErrorIncorrectStateOperation?
// CHECK_SET_CONFIG_STATE();
VideoConfigBitRate configBitRate;
if (mVideoEncoder->getConfig(&configBitRate) != ENCODE_SUCCESS) {
/* Ignoring the error here sucks, but prior to this change
* we were just using an uninitialized chunk of memory anyway
* so we aren't making anything worse and it makes this change safer.
*/
LOGW("failed to get IntelBitrate");
}
configBitRate.rcParams.bitRate = mConfigBitrate.nEncodeBitrate;
configBitRate.rcParams.temporalID = 0;
retStatus = mVideoEncoder->setConfig(&configBitRate);
if(retStatus != ENCODE_SUCCESS) {
LOGW("failed to set IntelBitrate");
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::SetConfigVideoFramerate(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
Encode_Status retStatus = ENCODE_SUCCESS;
if (mParamBitrate.eControlRate == OMX_Video_ControlRateMax){
LOGE("SetConfigVideoFramerate failed. Feature is disabled.");
return OMX_ErrorUnsupportedIndex;
}
OMX_CONFIG_FRAMERATETYPE *p = (OMX_CONFIG_FRAMERATETYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
// set in either Loaded state (ComponentSetParam) or Executing state (ComponentSetConfig)
mConfigFramerate = *p;
// return OMX_ErrorNone if not in Executing state
// TODO, return OMX_ErrorIncorrectStateOperation?
CHECK_SET_CONFIG_STATE();
VideoConfigFrameRate framerate;
framerate.frameRate.frameRateDenom = 1;
framerate.frameRate.frameRateNum = mConfigFramerate.xEncodeFramerate >> 16;
retStatus = mVideoEncoder->setConfig(&framerate);
if(retStatus != ENCODE_SUCCESS) {
LOGW("Failed to set frame rate config");
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderAVCSecure::SetMaxOutputBufferCount(OMX_PARAM_PORTDEFINITIONTYPE *p) {
OMX_ERRORTYPE ret;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
p->nBufferCountActual = OUTPORT_NATIVE_BUFFER_COUNT;
return OMXVideoDecoderBase::SetMaxOutputBufferCount(p);
}
OMX_ERRORTYPE OMXVideoEncoderBase::GetParamVideoIntraRefresh(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_INTRAREFRESHTYPE *p = (OMX_VIDEO_PARAM_INTRAREFRESHTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
memcpy(p, &mParamVideoRefresh, sizeof(*p));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderMPEG4::GetParamVideoMpeg4(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_MPEG4TYPE *p = (OMX_VIDEO_PARAM_MPEG4TYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
memcpy(p, &mParamMpeg4, sizeof(*p));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::GetTemporalLayer(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_INTEL_TEMPORAL_LAYER* p = static_cast<OMX_VIDEO_PARAM_INTEL_TEMPORAL_LAYER*>(pStructure);
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
memcpy(p, &mTemporalLayer, sizeof(*p));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::GetConfigIntelAIR(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_CONFIG_INTEL_AIR *p = (OMX_VIDEO_CONFIG_INTEL_AIR *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
memcpy(p, &mConfigIntelAir, sizeof(*p));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::GetIntelPrivateInfo(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_CONFIG_PRI_INFOTYPE *p = (OMX_VIDEO_CONFIG_PRI_INFOTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
memcpy(p, &mConfigPriInfo, sizeof(*p));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderAVCSecure::GetParamVideoAvc(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_AVCTYPE *p = (OMX_VIDEO_PARAM_AVCTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, INPORT_INDEX);
memcpy(p, &mParamAvc, sizeof(*p));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::GetParamVideoBitrate(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_BITRATETYPE *p = (OMX_VIDEO_PARAM_BITRATETYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
memcpy(p, &mParamBitrate, sizeof(*p));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderH263::GetParamVideoH263(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_H263TYPE *p = (OMX_VIDEO_PARAM_H263TYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, INPORT_INDEX);
memcpy(p, &mParamH263, sizeof(*p));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::GetConfigVideoFramerate(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_CONFIG_FRAMERATETYPE *p = (OMX_CONFIG_FRAMERATETYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
memcpy(p, &mConfigFramerate, sizeof(*p));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::GetParamIntelAdaptiveSliceControl(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL *p = (OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
memcpy(p, &mParamIntelAdaptiveSliceControl, sizeof(*p));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::GetStoreMetaDataInBuffers(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
StoreMetaDataInBuffersParams *p = (StoreMetaDataInBuffersParams *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, INPORT_INDEX);
p->bStoreMetaData = mStoreMetaDataInBuffers;
return OMX_ErrorNone;
};
OMX_ERRORTYPE OMXVideoDecoderWMV::SetParamVideoWmv(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_WMVTYPE *p = (OMX_VIDEO_PARAM_WMVTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, INPORT_INDEX);
CHECK_SET_PARAM_STATE();
// TODO: do we need to check if port is enabled?
memcpy(&mParamWmv, p, sizeof(mParamWmv));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderMPEG4::SetParamVideoMpeg4(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_MPEG4TYPE *p = (OMX_VIDEO_PARAM_MPEG4TYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
CHECK_SET_PARAM_STATE();
// TODO: do we need to check if port is enabled?
// TODO: see SetPortMpeg4Param implementation - Can we make simple copy????
memcpy(&mParamMpeg4, p, sizeof(mParamMpeg4));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderAVCSecure::GetParamVideoAVCProfileLevel(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_PROFILELEVELTYPE *p = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, INPORT_INDEX);
CHECK_ENUMERATION_RANGE(p->nProfileIndex,1);
p->eProfile = mParamAvc.eProfile;
p->eLevel = mParamAvc.eLevel;
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderAVCSecure::SetParamVideoAvc(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_AVCTYPE *p = (OMX_VIDEO_PARAM_AVCTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, INPORT_INDEX);
CHECK_SET_PARAM_STATE();
// TODO: do we need to check if port is enabled?
// TODO: see SetPortAvcParam implementation - Can we make simple copy????
memcpy(&mParamAvc, p, sizeof(mParamAvc));
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderBase::SetErrorReportMode(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_CONFIG_INTEL_ERROR_REPORT *p = (OMX_VIDEO_CONFIG_INTEL_ERROR_REPORT *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
mErrorReportEnabled = p->bEnable;
LOGD("Error reporting is %s", mErrorReportEnabled ? "enabled" : "disabled");
mVideoDecoder->enableErrorReport(mErrorReportEnabled);
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::SetParamVideoIntraRefresh(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
Encode_Status retStatus = ENCODE_SUCCESS;
OMX_VIDEO_PARAM_INTRAREFRESHTYPE *p = (OMX_VIDEO_PARAM_INTRAREFRESHTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
// set in either Loaded state (ComponentSetParam) or Executing state (ComponentSetConfig)
mParamVideoRefresh = *p;
// return OMX_ErrorNone if not in Executing state
// TODO: return OMX_ErrorIncorrectStateOperation?
CHECK_SET_PARAM_STATE();
VideoConfigIntraRefreshType configIntraRefreshType;
configIntraRefreshType.refreshType = (VideoIntraRefreshType)(mParamVideoRefresh.eRefreshMode + 1);
if(configIntraRefreshType.refreshType == VIDEO_ENC_CIR){
VideoConfigCIR configCIR;
VideoConfigIntraRefreshType configIntraRefreshType;
configCIR.cirParams.cir_num_mbs = mParamVideoRefresh.nCirMBs;
configIntraRefreshType.refreshType = VIDEO_ENC_CIR;
retStatus = mVideoEncoder->setConfig(&configCIR);
if(retStatus != ENCODE_SUCCESS) {
LOGW("Failed to set CIR config");
}
}else{
VideoConfigAIR configAIR;
configAIR.airParams.airMBs = mParamVideoRefresh.nAirMBs;
configAIR.airParams.airThreshold = mParamVideoRefresh.nAirRef;
retStatus = mVideoEncoder->setConfig(&configAIR);
if(retStatus != ENCODE_SUCCESS) {
LOGW("Failed to set AIR config");
}
}
retStatus = mVideoEncoder->setConfig(&configIntraRefreshType);
if(retStatus != ENCODE_SUCCESS) {
LOGW("Failed to set refresh config");
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::SetParamIntelAdaptiveSliceControl(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
if (mParamBitrate.eControlRate == OMX_Video_ControlRateMax) {
LOGE("SetParamIntelAdaptiveSliceControl failed. Feature is disabled.");
return OMX_ErrorUnsupportedIndex;
}
OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL *p = (OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
// set only in Loaded state (ComponentSetParam)
CHECK_SET_PARAM_STATE();
mParamIntelAdaptiveSliceControl = *p;
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::SetParamVideoBitrate(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_BITRATETYPE *p = (OMX_VIDEO_PARAM_BITRATETYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
CHECK_SET_PARAM_STATE();
OMX_U32 index = p->nPortIndex;
PortVideo *port = NULL;
// This disables other type of bitrate control mechanism
// TODO: check if it is desired
// TODO: can we override mParamBitrate.nPortIndex (See SetPortBitrateParam)
mParamBitrate.eControlRate = p->eControlRate;
mParamBitrate.nTargetBitrate = p->nTargetBitrate;
port = static_cast<PortVideo *>(ports[index]);
ret = port->SetPortBitrateParam(p, false);
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderAVC::SetParamIntelAVCDecodeSettings(OMX_PTR pStructure) {
LOGW("SetParamIntelAVCDecodeSettings");
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_INTEL_AVC_DECODE_SETTINGS *p = (OMX_VIDEO_PARAM_INTEL_AVC_DECODE_SETTINGS *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, INPORT_INDEX);
CHECK_SET_PARAM_STATE();
if(p->nMaxNumberOfReferenceFrame == 0) {
// TODO: check if we just return in this case.
p->nMaxNumberOfReferenceFrame = NUM_REFERENCE_FRAME;
}
LOGI("Maximum width = %u, height = %u, dpb = %u", p->nMaxWidth, p->nMaxHeight, p->nMaxNumberOfReferenceFrame);
mDecodeSettings = *p;
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::SetStoreMetaDataInBuffers(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
StoreMetaDataInBuffersParams *p = (StoreMetaDataInBuffersParams *)pStructure;
VideoParamsStoreMetaDataInBuffers StoreMetaDataInBuffers;
PortVideo *port = static_cast<PortVideo *>(this->ports[INPORT_INDEX]);
PortVideo *output_port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
uint32_t maxSize = 0;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, INPORT_INDEX);
LOGD("SetStoreMetaDataInBuffers (enabled = %x)", p->bStoreMetaData);
if(mStoreMetaDataInBuffers == p->bStoreMetaData)
return OMX_ErrorNone;
StoreMetaDataInBuffers.isEnabled = p->bStoreMetaData;
if (mVideoEncoder->setParameters(&StoreMetaDataInBuffers) != ENCODE_SUCCESS)
return OMX_ErrorNotReady;
mStoreMetaDataInBuffers = p->bStoreMetaData;
if(mStoreMetaDataInBuffers){
// for input port buffer
OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionInput;
const OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionInput_get;
paramPortDefinitionInput_get = port->GetPortDefinition();
paramPortDefinitionInput = (OMX_PARAM_PORTDEFINITIONTYPE *)paramPortDefinitionInput_get;
paramPortDefinitionInput->nBufferSize = IntelMetadataBuffer::GetMaxBufferSize();
}
else
{
const OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionInput_get;
paramPortDefinitionInput_get = port->GetPortDefinition();
port->SetPortDefinition(paramPortDefinitionInput_get, true);
}
LOGD("SetStoreMetaDataInBuffers success");
return OMX_ErrorNone;
};
OMX_ERRORTYPE OMXVideoEncoderMPEG4::GetParamVideoProfileLevelQuerySupported(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_PROFILELEVELTYPE *p = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
struct ProfileLevelTable {
OMX_U32 profile;
OMX_U32 level;
} plTable[] = {
{OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level5},
};
OMX_U32 count = sizeof(plTable)/sizeof(ProfileLevelTable);
CHECK_ENUMERATION_RANGE(p->nProfileIndex,count);
p->eProfile = plTable[p->nProfileIndex].profile;
p->eLevel = plTable[p->nProfileIndex].level;
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::SetConfigVideoIntraVOPRefresh(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
Encode_Status retStatus = ENCODE_SUCCESS;
OMX_CONFIG_INTRAREFRESHVOPTYPE *p = (OMX_CONFIG_INTRAREFRESHVOPTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
// return OMX_ErrorNone if not in Executing state
// TODO: return OMX_ErrorIncorrectStateOperation?
CHECK_SET_CONFIG_STATE();
if(p->IntraRefreshVOP == OMX_TRUE) {
VideoParamConfigSet configIDRRequest;
configIDRRequest.type = VideoConfigTypeIDRRequest;
retStatus = mVideoEncoder->setConfig(&configIDRRequest);
if(retStatus != ENCODE_SUCCESS) {
LOGW("Failed to set refresh config");
}
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::SetTemporalLayer(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_INTEL_TEMPORAL_LAYER *p = (OMX_VIDEO_PARAM_INTEL_TEMPORAL_LAYER *)pStructure;
VideoParamsTemporalLayer TemporalLayer;
OMX_U32 i;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, OUTPORT_INDEX);
LOGE("SetTemporalLayer (enabled = %d)", p->nNumberOfTemporalLayer);
TemporalLayer.numberOfLayer = p->nNumberOfTemporalLayer;
TemporalLayer.nPeriodicity = p->nPeriodicity;
for(i=0;i<p->nPeriodicity;i++)
TemporalLayer.nLayerID[i] = p->nLayerID[i];
if (mVideoEncoder->setParameters(&TemporalLayer) != ENCODE_SUCCESS)
return OMX_ErrorNotReady;
LOGE("SetTemporalLayer success");
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderAVCSecure::GetParamVideoAVCProfileLevel(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_PROFILELEVELTYPE *p = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX(p, INPORT_INDEX);
struct ProfileLevelTable {
OMX_U32 profile;
OMX_U32 level;
} plTable[] = {
{OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel42},
{OMX_VIDEO_AVCProfileMain, OMX_VIDEO_AVCLevel42},
{OMX_VIDEO_AVCProfileHigh, OMX_VIDEO_AVCLevel42}
};
OMX_U32 count = sizeof(plTable)/sizeof(ProfileLevelTable);
CHECK_ENUMERATION_RANGE(p->nProfileIndex,count);
p->eProfile = plTable[p->nProfileIndex].profile;
p->eLevel = plTable[p->nProfileIndex].level;
return OMX_ErrorNone;
}
