OMX_ERRORTYPE OMXVideoDecoderBase::SetNativeBufferModeSpecific(OMX_PTR pStructure) {
#if 0
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 = 1;
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.eColorFormat = GetOutputColorFormat(
port_def.format.video.nFrameWidth,
port_def.format.video.nFrameHeight);
port->SetPortDefinition(&port_def,true);
#endif
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 OMXVideoDecoderBase::InitOutputPort(void) {
this->ports[OUTPORT_INDEX] = new PortVideo;
if (this->ports[OUTPORT_INDEX] == NULL) {
return OMX_ErrorInsufficientResources;
}
PortVideo *port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
// OMX_PARAM_PORTDEFINITIONTYPE
OMX_PARAM_PORTDEFINITIONTYPE paramPortDefinitionOutput;
memset(¶mPortDefinitionOutput, 0, sizeof(paramPortDefinitionOutput));
SetTypeHeader(¶mPortDefinitionOutput, sizeof(paramPortDefinitionOutput));
paramPortDefinitionOutput.nPortIndex = OUTPORT_INDEX;
paramPortDefinitionOutput.eDir = OMX_DirOutput;
paramPortDefinitionOutput.nBufferCountActual = OUTPORT_ACTUAL_BUFFER_COUNT;
paramPortDefinitionOutput.nBufferCountMin = OUTPORT_MIN_BUFFER_COUNT;
#if 0//fei
paramPortDefinitionOutput.nBufferSize = sizeof(VideoRenderBuffer);
#endif
paramPortDefinitionOutput.bEnabled = OMX_TRUE;
paramPortDefinitionOutput.bPopulated = OMX_FALSE;
paramPortDefinitionOutput.eDomain = OMX_PortDomainVideo;
paramPortDefinitionOutput.format.video.cMIMEType = (OMX_STRING)VA_RAW_MIME_TYPE;
paramPortDefinitionOutput.format.video.pNativeRender = NULL;
paramPortDefinitionOutput.format.video.nFrameWidth = 176;
paramPortDefinitionOutput.format.video.nFrameHeight = 144;
paramPortDefinitionOutput.format.video.nStride = 176;
paramPortDefinitionOutput.format.video.nSliceHeight = 144;
paramPortDefinitionOutput.format.video.nBitrate = 64000;
paramPortDefinitionOutput.format.video.xFramerate = 15 << 16;
paramPortDefinitionOutput.format.video.bFlagErrorConcealment = OMX_FALSE;
paramPortDefinitionOutput.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
paramPortDefinitionOutput.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
paramPortDefinitionOutput.format.video.pNativeWindow = NULL;
paramPortDefinitionOutput.bBuffersContiguous = OMX_FALSE;
paramPortDefinitionOutput.nBufferAlignment = 0;
// no format specific to initialize output port
InitOutputPortFormatSpecific(¶mPortDefinitionOutput);
port->SetPortDefinition(¶mPortDefinitionOutput, true);
// OMX_VIDEO_PARAM_PORTFORMATTYPE
OMX_VIDEO_PARAM_PORTFORMATTYPE paramPortFormat;
SetTypeHeader(¶mPortFormat, sizeof(paramPortFormat));
paramPortFormat.nPortIndex = OUTPORT_INDEX;
paramPortFormat.nIndex = 0;
paramPortFormat.eCompressionFormat = paramPortDefinitionOutput.format.video.eCompressionFormat;
paramPortFormat.eColorFormat = paramPortDefinitionOutput.format.video.eColorFormat;
paramPortFormat.xFramerate = paramPortDefinitionOutput.format.video.xFramerate;
port->SetPortVideoParam(¶mPortFormat, true);
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderBase::InitInputPort(void) {
this->ports[INPORT_INDEX] = new PortVideo;
if (this->ports[INPORT_INDEX] == NULL) {
return OMX_ErrorInsufficientResources;
}
PortVideo *port = static_cast<PortVideo *>(this->ports[INPORT_INDEX]);
// OMX_PARAM_PORTDEFINITIONTYPE
OMX_PARAM_PORTDEFINITIONTYPE paramPortDefinitionInput;
memset(¶mPortDefinitionInput, 0, sizeof(paramPortDefinitionInput));
SetTypeHeader(¶mPortDefinitionInput, sizeof(paramPortDefinitionInput));
paramPortDefinitionInput.nPortIndex = INPORT_INDEX;
paramPortDefinitionInput.eDir = OMX_DirInput;
paramPortDefinitionInput.nBufferCountActual = INPORT_ACTUAL_BUFFER_COUNT;
paramPortDefinitionInput.nBufferCountMin = INPORT_MIN_BUFFER_COUNT;
paramPortDefinitionInput.nBufferSize = INPORT_BUFFER_SIZE;
paramPortDefinitionInput.bEnabled = OMX_TRUE;
paramPortDefinitionInput.bPopulated = OMX_FALSE;
paramPortDefinitionInput.eDomain = OMX_PortDomainVideo;
paramPortDefinitionInput.format.video.cMIMEType = NULL; // to be overridden
paramPortDefinitionInput.format.video.pNativeRender = NULL;
paramPortDefinitionInput.format.video.nFrameWidth = 176;
paramPortDefinitionInput.format.video.nFrameHeight = 144;
paramPortDefinitionInput.format.video.nStride = 0;
paramPortDefinitionInput.format.video.nSliceHeight = 0;
paramPortDefinitionInput.format.video.nBitrate = 64000;
paramPortDefinitionInput.format.video.xFramerate = 15 << 16;
// TODO: check if we need to set bFlagErrorConcealment to OMX_TRUE
paramPortDefinitionInput.format.video.bFlagErrorConcealment = OMX_FALSE;
paramPortDefinitionInput.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused; // to be overridden
paramPortDefinitionInput.format.video.eColorFormat = OMX_COLOR_FormatUnused;
paramPortDefinitionInput.format.video.pNativeWindow = NULL;
paramPortDefinitionInput.bBuffersContiguous = OMX_FALSE;
paramPortDefinitionInput.nBufferAlignment = 0;
// Derived class must implement this interface and override any field if needed.
// eCompressionFormat and and cMIMEType must be overridden
InitInputPortFormatSpecific(¶mPortDefinitionInput);
port->SetPortDefinition(¶mPortDefinitionInput, true);
// OMX_VIDEO_PARAM_PORTFORMATTYPE
OMX_VIDEO_PARAM_PORTFORMATTYPE paramPortFormat;
memset(¶mPortFormat, 0, sizeof(paramPortFormat));
SetTypeHeader(¶mPortFormat, sizeof(paramPortFormat));
paramPortFormat.nPortIndex = INPORT_INDEX;
paramPortFormat.nIndex = 0;
paramPortFormat.eCompressionFormat = paramPortDefinitionInput.format.video.eCompressionFormat;
paramPortFormat.eColorFormat = paramPortDefinitionInput.format.video.eColorFormat;
paramPortFormat.xFramerate = paramPortDefinitionInput.format.video.xFramerate;
port->SetPortVideoParam(¶mPortFormat, true);
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderBase::PrepareConfigBuffer(VideoConfigBuffer *p) {
// default config buffer preparation
memset(p, 0, sizeof(VideoConfigBuffer));
const OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionInput = this->ports[INPORT_INDEX]->GetPortDefinition();
if (paramPortDefinitionInput == NULL) {
return OMX_ErrorBadParameter;
}
if (mWorkingMode == GRAPHICBUFFER_MODE) {
p->surfaceNumber = mOMXBufferHeaderTypePtrNum;
for (int i = 0; i < mOMXBufferHeaderTypePtrNum; i++){
OMX_BUFFERHEADERTYPE *buffer_hdr = mOMXBufferHeaderTypePtrArray[i];
p->graphicBufferHandler[i] = buffer_hdr->pBuffer;
ALOGV("PrepareConfigBuffer bufferid = %p, handle = %p", buffer_hdr, buffer_hdr->pBuffer);
}
p->flag |= USE_NATIVE_GRAPHIC_BUFFER;
p->graphicBufferStride = mGraphicBufferParam.graphicBufferStride;
p->graphicBufferColorFormat = mGraphicBufferParam.graphicBufferColorFormat;
p->graphicBufferWidth = mGraphicBufferParam.graphicBufferWidth;
p->graphicBufferHeight = mGraphicBufferParam.graphicBufferHeight;
if (p->graphicBufferColorFormat == OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled
#ifdef USE_GEN_HW
|| p->graphicBufferColorFormat == HAL_PIXEL_FORMAT_NV12_X_TILED_INTEL
#endif
)
p->flag |= USE_TILING_MEMORY;
if (mEnableAdaptivePlayback)
p->flag |= WANT_ADAPTIVE_PLAYBACK;
PortVideo *port = NULL;
port = static_cast<PortVideo *>(this->ports[INPORT_INDEX]);
OMX_PARAM_PORTDEFINITIONTYPE port_def;
memcpy(&port_def, port->GetPortDefinition(), sizeof(port_def));
if (port_def.format.video.pNativeWindow != NULL) {
p->nativeWindow = port_def.format.video.pNativeWindow;
ALOGD("NativeWindow = %p", p->nativeWindow);
}
}
p->rotationDegrees = mRotationDegrees;
#ifdef TARGET_HAS_VPP
p->vppBufferNum = mVppBufferNum;
#endif
p->width = paramPortDefinitionInput->format.video.nFrameWidth;
p->height = paramPortDefinitionInput->format.video.nFrameHeight;
return OMX_ErrorNone;
}
OMX_ERRORTYPE OMXVideoDecoderBase::GetParamVideoPortFormat(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_ENUMERATION_RANGE(p->nIndex, 1);
PortVideo *port = NULL;
port = static_cast<PortVideo *>(this->ports[p->nPortIndex]);
memcpy(p, port->GetPortVideoParam(), sizeof(*p));
return OMX_ErrorNone;
}
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;
}
bool OMXVideoDecoderVP9Hybrid::IsAllBufferAvailable(void) {
bool b = ComponentBase::IsAllBufferAvailable();
if (b == false) {
return false;
}
PortVideo *port = NULL;
port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
const OMX_PARAM_PORTDEFINITIONTYPE* port_def = port->GetPortDefinition();
// if output port is disabled, retain the input buffer
if (!port_def->bEnabled) {
return false;
}
return mCheckBufferAvailable(mHybridCtx);
}
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::GetParamVideoPortFormat(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
OMX_U32 index;
OMX_VIDEO_PARAM_PORTFORMATTYPE *p = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)pStructure;
CHECK_TYPE_HEADER(p);
CHECK_PORT_INDEX_RANGE(p);
CHECK_ENUMERATION_RANGE(p->nIndex, 2);
PortVideo *port = NULL;
port = static_cast<PortVideo *>(this->ports[p->nPortIndex]);
index = p->nIndex;
memcpy(p, port->GetPortVideoParam(), sizeof(*p));
// port supports OMX_COLOR_FormatYUV420SemiPlanar & OMX_COLOR_FormatAndroidOpaque
if (index == 1) {
p->nIndex = 1;
p->eColorFormat = OMX_COLOR_FormatAndroidOpaque;
}
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::SetNativeBufferModeSpecific(OMX_PTR pStructure) {
OMX_ERRORTYPE ret;
EnableAndroidNativeBuffersParams *param = (EnableAndroidNativeBuffersParams*)pStructure;
CHECK_TYPE_HEADER(param);
CHECK_PORT_INDEX_RANGE(param);
CHECK_SET_PARAM_STATE();
PortVideo *port = NULL;
port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
OMX_PARAM_PORTDEFINITIONTYPE port_def;
memcpy(&port_def,port->GetPortDefinition(),sizeof(port_def));
if (!param->enable) {
mWorkingMode = RAWDATA_MODE;
// If it is fallback from native mode the color format has been
// already set to INTEL format.
// We need to set back the default color format and Native stuff.
port_def.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
port_def.format.video.pNativeRender = NULL;
port_def.format.video.pNativeWindow = NULL;
port->SetPortDefinition(&port_def,true);
return OMX_ErrorNone;
}
mWorkingMode = GRAPHICBUFFER_MODE;
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::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;
};
/**
@brief Called when the processing is ready to be stopped
*/
WRAPPER_OPENMAX_API OMX_ERRORTYPE OpenMax_Proxy::stop()
//*************************************************************************************************************
{// Call Deinstantiation of component
IN0("\n");
m_pNmfProcWrp->stop();
#if 0
//ER355733 Try to fix ens bug that doesn't reset bufferSupplier type
PortVideo* pPort;
for (unsigned int Index=0; Index< mENSComponent.getPortCount(); ++Index)
{
pPort = (PortVideo*)mENSComponent.getPort(Index);
if (pPort->getBufferSupplier() !=OMX_BufferSupplyUnspecified)
{
MSG3("wwwwwwwwwwwwwwwwwwwwwwwwwwww %s.port[%d] reset state(%d) to OMX_BufferSupplyUnspecified\n", GetComponentName(), Index, pPort->getBufferSupplier());
pPort->setBufferSupplier(OMX_BufferSupplyUnspecified);
}
}
#endif
OUT0("\n");
return OMX_ErrorNone;
}
/**
brief Instantiate the nmf component and bind interfaces
Called during Loaded to Idle transition
*/
WRAPPER_OPENMAX_API OMX_ERRORTYPE OpenMax_Proxy::instantiate()
//*************************************************************************************************************
{ //binding all interfaces
OMX_ERRORTYPE omx_error=OMX_ErrorNone;
IN0("\n");
// Init Components
// Bind of arm nmf components
MSG1("OpenMax_Proxy(%s) Instantiating arm nmf component\n", GetComponentName());
openmax_processor *pProcessor=NULL;
if (m_pProcessor != NULL)
pProcessor = m_pProcessor;
else if (m_fnCreateNmfComponent !=NULL)
{
m_pProcessor= m_fnCreateNmfComponent();
pProcessor = m_pProcessor;
}
m_pNmfProcWrp = openmax_processor_wrpCreate(pProcessor);
m_pNmfProcWrp->priority = m_nmfPriority;
if (m_pNmfProcWrp->construct() != NMF_OK)
NMF_PANIC("PANIC - Construct Error\n") ;
t_nmf_error error ;
// bindFromUser --> Asynchronous
// getInterface --> Synchronous
error = m_pNmfProcWrp->bindFromUser("sendcommand", 2, &mIsendCommand) ;
if (error != NMF_OK)
NMF_PANIC("PANIC - bindFromUser sendCommand\n") ;
#if (SYNCHRONOUS ==0)
error = m_pNmfProcWrp->bindFromUser("Param", 2*mENSComponent.getPortCount()+1, &m_IParam) ; // One setparam per port + 1
if (error != NMF_OK)
NMF_PANIC("PANIC - bindFromUser Param\n") ;
error = m_pNmfProcWrp->bindFromUser("Config", 2*mENSComponent.getPortCount()+1, &m_IConfig) ; // One setparam per port + 1
if (error != NMF_OK)
NMF_PANIC("PANIC - bindFromUser Config\n") ;
#else //Bind synchronous interfaces
//interfaces are binded in a synchronous way
error = m_pNmfProcWrp->getInterface("Param", &m_IParam);
if (error != NMF_OK)
NMF_PANIC("PANIC - getInterface Param\n") ;
error = m_pNmfProcWrp->getInterface("Config", &m_IConfig);
if (error != NMF_OK)
NMF_PANIC("PANIC - getInterface Config\n") ;
#endif
error = m_pNmfProcWrp->bindFromUser("fsminit", 1 , &mIfsmInit);
if (error != NMF_OK)
NMF_PANIC("Error: unable to bind fsminit!...\n");
error = EnsWrapper_bindToUser(mENSComponent.getOMXHandle(), m_pNmfProcWrp, "proxy", getEventHandlerCB(), 8);
if (error != NMF_OK)
NMF_PANIC("Error: unable to bind proxy!...\n");
error = EnsWrapper_bindToUser(mENSComponent.getOMXHandle(), m_pNmfProcWrp, "ToOMXComponent", mConfigCB, 1);
if (error != NMF_OK)
NMF_PANIC("Error: unable to bind ToOMXComponent!...\n");
char name[20]; //reserve some char for formatting callback name
size_t iNbInput =0;
size_t iNbOutput=0;
PortVideo* pPort;
for (unsigned int Index=0; Index< mENSComponent.getPortCount(); ++Index)
{
pPort = (PortVideo*)mENSComponent.getPort(Index);
MSG3("\n %s Port %d : direction =%d\n", GetComponentName(), Index, pPort->getDirection());
//reset port info at this point
//NO it's too late!
#if 0
if (pPort->getBufferSupplier() !=OMX_BufferSupplyUnspecified)
{
printf("wwwwwwwwwwwwwwwwwwwwwwwwwwww %s.port[%d] reset state(%d) to OMX_BufferSupplyUnspecified\n", GetComponentName(), Index, pPort->getBufferSupplier());
pPort->setBufferSupplier(OMX_BufferSupplyUnspecified);
}
#endif
switch(pPort->getDirection())
{
case OMX_DirInput: //bind emptythisbuffer, emptybufferdone for each input port
if (iNbInput < MAX_PORTS_COUNT)
{
sprintf(name, "emptythisbuffer[%d]", Index);
error = m_pNmfProcWrp->bindFromUser(name, pPort->getBufferCountActual(), &mIemptyThisBuffer[Index]);
if (error != NMF_OK)
NMF_PANIC("PANIC %s->bindFromUser %s\n", GetComponentName(), name) ;
sprintf(name, "emptybufferdone[%d]", Index);
error = EnsWrapper_bindToUser(mENSComponent.getOMXHandle(),
m_pNmfProcWrp,
name ,
this->getEmptyBufferDoneCB(),
pPort->getBufferCountActual());
if (error != NMF_OK)
NMF_PANIC("PANIC %s->bindToUser %s\n", GetComponentName(), name) ;
++iNbInput;
}
else
{
// ReportError(
}
break;
case OMX_DirOutput://bind fillthisbuffer, fillbufferdone for each output port
if (iNbOutput < MAX_PORTS_COUNT)
{
sprintf(name, "fillthisbuffer[%d]", Index);
error = m_pNmfProcWrp->bindFromUser(name, pPort->getBufferCountActual(), &mIfillThisBuffer[Index]);
if (error != NMF_OK)
NMF_PANIC("PANIC %s->bindFromUser %s\n", GetComponentName(), name) ;
sprintf(name, "fillbufferdone[%d]", Index);
error = EnsWrapper_bindToUser(mENSComponent.getOMXHandle(),
m_pNmfProcWrp,
name,
this->getFillBufferDoneCB(),
pPort->getBufferCountActual());
if (error != NMF_OK)
NMF_PANIC("PANIC %s->bindToUser %s\n", GetComponentName(), name) ;
++iNbOutput;
}
else
{
// ReportError(
}
break;
default:
break;
}
}
// Configure the number of ports
m_IConfig.setTargetComponent(mENSComponent.getPortCount() , &mENSComponent);
OUTR(" ", (omx_error));
return omx_error;
}
/**
@brief Configure the processing component by sending all relevant info
*/
WRAPPER_OPENMAX_API OMX_ERRORTYPE OpenMax_Proxy::deInstantiate()
//*************************************************************************************************************
{
IN0("\n");
OMX_ERRORTYPE OmxError=OMX_ErrorNone;
t_nmf_error nmf_err = NMF_OK;
OMX_HANDLETYPE handle = mENSComponent.getOMXHandle();
nmf_err = m_pNmfProcWrp->unbindFromUser("sendcommand");
if (nmf_err != NMF_OK)
{
MSG1("Error: Imageproc unbindfromUser sendcommand 0x%x\n", nmf_err);
OmxError=OMX_ErrorHardware;
}
nmf_err = m_pNmfProcWrp->unbindFromUser("fsminit");
if (nmf_err != NMF_OK)
{
MSG1("Error: Imageproc unbindfromUser fsminit 0x%x\n", nmf_err);
OmxError=OMX_ErrorHardware;
}
#if (SYNCHRONOUS ==0)
nmf_err |= m_pNmfProcWrp->unbindFromUser("Config");
if (nmf_err != NMF_OK)
{
MSG1("Error: Imageproc unbindfromUser Config 0x%x\n", nmf_err);
OmxError=OMX_ErrorHardware;
}
nmf_err = m_pNmfProcWrp->unbindFromUser("Param");
if (nmf_err != NMF_OK)
{
MSG1("Error: Imageproc unbindfromUser Param 0x%x\n", nmf_err);
OmxError=OMX_ErrorHardware;
}
#endif
nmf_err |= EnsWrapper_unbindToUser(handle, m_pNmfProcWrp, "proxy");
if (nmf_err != NMF_OK)
{
MSG1("Error: m_pNmfProcWrp unbindToUser proxy 0x%x\n", nmf_err);
OmxError=OMX_ErrorHardware;
}
nmf_err |= EnsWrapper_unbindToUser(handle, m_pNmfProcWrp, /* "get_config" */ "ToOMXComponent");
if (nmf_err != NMF_OK)
{
MSG1("Error: m_pNmfProcWrp unbindToUser ToOMXComponent 0x%x\n", nmf_err);
OmxError=OMX_ErrorHardware;
}
char name[20]; //reserve some char for formatting callback name
PortVideo* pPort;
for (unsigned int Index=0; Index< mENSComponent.getPortCount(); ++Index)
{
pPort = (PortVideo*)mENSComponent.getPort(Index);
switch(pPort->getDirection())
{
case OMX_DirInput: //bind emptythisbuffer, emptybufferdone for each input port
sprintf(name, "emptythisbuffer[%u]", Index);
nmf_err |= m_pNmfProcWrp->unbindFromUser(name);
sprintf(name, "emptybufferdone[%u]", Index);
nmf_err |= EnsWrapper_unbindToUser(handle, m_pNmfProcWrp, name);
break;
case OMX_DirOutput: //bind emptythisbuffer, emptybufferdone for each input port
sprintf(name, "fillthisbuffer[%u]", Index);
nmf_err |= m_pNmfProcWrp->unbindFromUser(name);
sprintf(name, "fillbufferdone[%u]", Index);
nmf_err |= EnsWrapper_unbindToUser(handle, m_pNmfProcWrp, name);
break;
default:
WARNING(0);
break;
}
}
if (nmf_err != NMF_OK)
{
OmxError=OMX_ErrorHardware;
}
m_pNmfProcWrp->destroy();
openmax_processor_wrpDestroy(m_pNmfProcWrp);
m_pProcessor=NULL; // for releasing the 'processor'
OUTR(" ", (OmxError));
return OmxError;
}
OMX_ERRORTYPE OMXVideoEncoderBase::InitOutputPort(void) {
this->ports[OUTPORT_INDEX] = new PortVideo;
if (this->ports[OUTPORT_INDEX] == NULL) {
return OMX_ErrorInsufficientResources;
}
PortVideo *port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
// OMX_VIDEO_PARAM_BITRATETYPE
memset(&mParamBitrate, 0, sizeof(mParamBitrate));
SetTypeHeader(&mParamBitrate, sizeof(mParamBitrate));
mParamBitrate.nPortIndex = OUTPORT_INDEX;
mParamBitrate.eControlRate = OMX_Video_ControlRateVariable;
mParamBitrate.nTargetBitrate = 192000; // to be overridden
// OMX_VIDEO_CONFIG_PRI_INFOTYPE
memset(&mConfigPriInfo, 0, sizeof(mConfigPriInfo));
SetTypeHeader(&mConfigPriInfo, sizeof(mConfigPriInfo));
mConfigPriInfo.nPortIndex = OUTPORT_INDEX;
mConfigPriInfo.nCapacity = 0;
mConfigPriInfo.nHolder = NULL;
// OMX_VIDEO_CONFIG_INTEL_BITRATETYPE
memset(&mConfigIntelBitrate, 0, sizeof(mConfigIntelBitrate));
SetTypeHeader(&mConfigIntelBitrate, sizeof(mConfigIntelBitrate));
mConfigIntelBitrate.nPortIndex = OUTPORT_INDEX;
mConfigIntelBitrate.nMaxEncodeBitrate = 0; // Maximum bitrate
mConfigIntelBitrate.nTargetPercentage = 95; // Target bitrate as percentage of maximum bitrate; e.g. 95 is 95%
mConfigIntelBitrate.nWindowSize = 0; // Window size in milliseconds allowed for bitrate to reach target
mConfigIntelBitrate.nInitialQP = 0; // Initial QP for I frames
mConfigIntelBitrate.nMinQP = 0;
mConfigIntelBitrate.nMaxQP = 0;
mConfigIntelBitrate.nFrameRate = 0;
mConfigIntelBitrate.nTemporalID = 0;
// OMX_VIDEO_CONFIG_BITRATETYPE
memset(&mConfigBitrate, 0, sizeof(mConfigBitrate));
SetTypeHeader(&mConfigBitrate, sizeof(mConfigBitrate));
mConfigBitrate.nPortIndex = OUTPORT_INDEX;
mConfigBitrate.nEncodeBitrate = 0; // Maximum bitrate
// OMX_VIDEO_CONFIG_INTEL_AIR
memset(&mConfigIntelAir, 0, sizeof(mConfigIntelAir));
SetTypeHeader(&mConfigIntelAir, sizeof(mConfigIntelAir));
mConfigIntelAir.nPortIndex = OUTPORT_INDEX;
mConfigIntelAir.bAirEnable = OMX_FALSE;
mConfigIntelAir.bAirAuto = OMX_FALSE;
mConfigIntelAir.nAirMBs = 0;
mConfigIntelAir.nAirThreshold = 0;
// OMX_VIDEO_CONFIG_INTEL_AIR
memset(&mParamVideoRefresh, 0, sizeof(mParamVideoRefresh));
SetTypeHeader(&mParamVideoRefresh, sizeof(mParamVideoRefresh));
mParamVideoRefresh.nPortIndex = OUTPORT_INDEX;
mParamVideoRefresh.eRefreshMode = OMX_VIDEO_IntraRefreshAdaptive;
mParamVideoRefresh.nAirMBs = 0;
mParamVideoRefresh.nAirRef = 0;
mParamVideoRefresh.nCirMBs = 0;
// OMX_CONFIG_FRAMERATETYPE
memset(&mConfigFramerate, 0, sizeof(mConfigFramerate));
SetTypeHeader(&mConfigFramerate, sizeof(mConfigFramerate));
mConfigFramerate.nPortIndex = OUTPORT_INDEX;
mConfigFramerate.xEncodeFramerate = 0; // Q16 format
// OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL
memset(&mParamIntelAdaptiveSliceControl, 0, sizeof(mParamIntelAdaptiveSliceControl));
SetTypeHeader(&mParamIntelAdaptiveSliceControl, sizeof(mParamIntelAdaptiveSliceControl));
mParamIntelAdaptiveSliceControl.nPortIndex = OUTPORT_INDEX;
mParamIntelAdaptiveSliceControl.bEnable = OMX_FALSE;
mParamIntelAdaptiveSliceControl.nMinPSliceNumber = 5;
mParamIntelAdaptiveSliceControl.nNumPFramesToSkip = 8;
mParamIntelAdaptiveSliceControl.nSliceSizeThreshold = 1200;
// OMX_VIDEO_PARAM_PROFILELEVELTYPE
memset(&mParamProfileLevel, 0, sizeof(mParamProfileLevel));
SetTypeHeader(&mParamProfileLevel, sizeof(mParamProfileLevel));
mParamProfileLevel.nPortIndex = OUTPORT_INDEX;
mParamProfileLevel.eProfile = 0; // undefined profile, to be overridden
mParamProfileLevel.eLevel = 0; // undefined level, to be overridden
// OMX_PARAM_PORTDEFINITIONTYPE
OMX_PARAM_PORTDEFINITIONTYPE paramPortDefinitionOutput;
memset(¶mPortDefinitionOutput, 0, sizeof(paramPortDefinitionOutput));
SetTypeHeader(¶mPortDefinitionOutput, sizeof(paramPortDefinitionOutput));
paramPortDefinitionOutput.nPortIndex = OUTPORT_INDEX;
paramPortDefinitionOutput.eDir = OMX_DirOutput;
paramPortDefinitionOutput.nBufferCountActual = OUTPORT_ACTUAL_BUFFER_COUNT; // to be overridden
paramPortDefinitionOutput.nBufferCountMin = OUTPORT_MIN_BUFFER_COUNT;
paramPortDefinitionOutput.nBufferSize = OUTPORT_BUFFER_SIZE; // to be overridden
paramPortDefinitionOutput.bEnabled = OMX_TRUE;
paramPortDefinitionOutput.bPopulated = OMX_FALSE;
paramPortDefinitionOutput.eDomain = OMX_PortDomainVideo;
paramPortDefinitionOutput.format.video.cMIMEType = NULL; // to be overridden
paramPortDefinitionOutput.format.video.pNativeRender = NULL;
paramPortDefinitionOutput.format.video.nFrameWidth = 176;
paramPortDefinitionOutput.format.video.nFrameHeight = 144;
paramPortDefinitionOutput.format.video.nStride = 176;
paramPortDefinitionOutput.format.video.nSliceHeight = 144;
paramPortDefinitionOutput.format.video.nBitrate = 64000;
paramPortDefinitionOutput.format.video.xFramerate = 15 << 16;
paramPortDefinitionOutput.format.video.bFlagErrorConcealment = OMX_FALSE;
paramPortDefinitionOutput.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused; // to be overridden
paramPortDefinitionOutput.format.video.eColorFormat = OMX_COLOR_FormatUnused;
paramPortDefinitionOutput.format.video.pNativeWindow = NULL;
paramPortDefinitionOutput.bBuffersContiguous = OMX_FALSE;
paramPortDefinitionOutput.nBufferAlignment = 0;
InitOutputPortFormatSpecific(¶mPortDefinitionOutput);
port->SetPortDefinition(¶mPortDefinitionOutput, true);
port->SetPortBitrateParam(&mParamBitrate, true);
// OMX_VIDEO_PARAM_PORTFORMATTYPE
OMX_VIDEO_PARAM_PORTFORMATTYPE paramPortFormat;
memset(¶mPortFormat, 0, sizeof(paramPortFormat));
SetTypeHeader(¶mPortFormat, sizeof(paramPortFormat));
paramPortFormat.nPortIndex = OUTPORT_INDEX;
paramPortFormat.nIndex = 0;
paramPortFormat.eCompressionFormat = paramPortDefinitionOutput.format.video.eCompressionFormat;
paramPortFormat.eColorFormat = paramPortDefinitionOutput.format.video.eColorFormat;
paramPortFormat.xFramerate = paramPortDefinitionOutput.format.video.xFramerate;
port->SetPortVideoParam(¶mPortFormat, true);
return OMX_ErrorNone;
}