OMX_ERRORTYPE OMXVideoDecoderBase::SetNativeBufferModeSpecific(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
EnableAndroidNativeBuffersParams *param = (EnableAndroidNativeBuffersParams*)pStructure;
CHECK_TYPE_HEADER(param);
CHECK_PORT_INDEX_RANGE(param);
CHECK_SET_PARAM_STATE();
if (!param->enable) {
mWorkingMode = RAWDATA_MODE;
return OMX_ErrorNone;
}
mWorkingMode = GRAPHICBUFFER_MODE;
PortVideo *port = NULL;
port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
OMX_PARAM_PORTDEFINITIONTYPE port_def;
memcpy(&port_def,port->GetPortDefinition(),sizeof(port_def));
port_def.nBufferCountMin = mNativeBufferCount;
if (mEnableAdaptivePlayback) {
SetMaxOutputBufferCount(&port_def);
} else {
port_def.nBufferCountActual = mNativeBufferCount;
}
port_def.format.video.cMIMEType = (OMX_STRING)VA_VED_RAW_MIME_TYPE;
port_def.format.video.eColorFormat = OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar;
port_def.format.video.nFrameHeight = (port_def.format.video.nFrameHeight + 0x1f) & ~0x1f;
port_def.format.video.eColorFormat = GetOutputColorFormat(
port_def.format.video.nFrameWidth);
port->SetPortDefinition(&port_def,true);
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 OMXVideoDecoderVP9Hybrid::SetNativeBufferModeSpecific(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
android::EnableAndroidNativeBuffersParams *param =
(android::EnableAndroidNativeBuffersParams*)pStructure;
CHECK_TYPE_HEADER(param);
CHECK_PORT_INDEX_RANGE(param);
CHECK_SET_PARAM_STATE();
if (!param->enable) {
mWorkingMode = RAWDATA_MODE;
LOGI("Raw data mode is used");
return OMX_ErrorNone;
}
mWorkingMode = GRAPHICBUFFER_MODE;
PortVideo *port = NULL;
port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
OMX_PARAM_PORTDEFINITIONTYPE port_def;
memcpy(&port_def,port->GetPortDefinition(),sizeof(port_def));
port_def.nBufferCountMin = mNativeBufferCount - 4;
port_def.nBufferCountActual = mNativeBufferCount;
port_def.format.video.cMIMEType = (OMX_STRING)VA_VED_RAW_MIME_TYPE;
// add borders for libvpx decode need.
port_def.format.video.nFrameWidth += VPX_DECODE_BORDER * 2;
mDecodedImageWidth = port_def.format.video.nFrameWidth;
mDecodedImageHeight = port_def.format.video.nFrameHeight;
// make heigth 32bit align
port_def.format.video.nFrameHeight = (port_def.format.video.nFrameHeight + 0x1f) & ~0x1f;
port_def.format.video.eColorFormat = GetOutputColorFormat(port_def.format.video.nFrameWidth);
port->SetPortDefinition(&port_def,true);
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderAVCSecure::SetExtAllocateNativeHandle(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
android:: EnableAndroidNativeBuffersParams *p = (android::EnableAndroidNativeBuffersParams *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_SET_PARAM_STATE();
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderBase::SetDecoderVppBufferNum(OMX_PTR pStructure) {
CHECK_SET_PARAM_STATE();
int32_t num = 0;
num = *(static_cast<int32_t*>(pStructure));
mVppBufferNum = num;
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoEncoderBase::SetSyncEncoding(OMX_PTR pStructure) {
CHECK_SET_PARAM_STATE();
mSyncEncoding = *(static_cast<OMX_BOOL*>(pStructure));
LOGD("SetSyncEncoding %d", mSyncEncoding);
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::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::SetDecoderRotation(OMX_PTR pStructure) {
CHECK_SET_PARAM_STATE();
int32_t rotationDegrees = 0;
if (pStructure) {
rotationDegrees = *(static_cast<int32_t*>(pStructure));
mRotationDegrees = rotationDegrees;
LOGI("Rotation Degree = %d", rotationDegrees);
return OMX_ErrorNone;
} else {
return OMX_ErrorBadParameter;
}
}
OMX_ERRORTYPE OMXVideoDecoderBase::SetParamVideoPortFormat(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_PORTFORMATTYPE *p = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX_RANGE(p);
CHECK_SET_PARAM_STATE();
// TODO: do we need to check if port is enabled?
PortVideo *port = NULL;
port = static_cast<PortVideo *>(this->ports[p->nPortIndex]);
port->SetPortVideoParam(p, false);
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 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::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 OMXVideoEncoderBase::SetParamVideoPortFormat(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_VIDEO_PARAM_PORTFORMATTYPE *p = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX_RANGE(p);
CHECK_SET_PARAM_STATE();
// TODO: do we need to check if port is enabled?
PortVideo *port = NULL;
port = static_cast<PortVideo *>(this->ports[p->nPortIndex]);
#if 0
if (p->eColorFormat == OMX_COLOR_FormatAndroidOpaque) {
p->nIndex = 0;
p->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
}
#endif
port->SetPortVideoParam(p, false);
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderBase::SetNativeBufferUsageSpecific(OMX_PTR) {
CHECK_SET_PARAM_STATE();
return OMX_ErrorBadParameter;
}
