bool COMXVideo::Open(COMXStreamInfo &hints, OMXClock *clock, float display_aspect, bool deinterlace, bool hdmi_clock_sync, void* boblight_instance, int boblight_sizedown, int boblight_margin, int boblight_timeout)
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
std::string decoder_name;
m_video_codec_name = "";
m_codingType = OMX_VIDEO_CodingUnused;
m_decoded_width = hints.width;
m_decoded_height = hints.height;
m_hdmi_clock_sync = hdmi_clock_sync;
//copy boblight parameter
m_boblight_sizedown = boblight_sizedown;
m_boblight_margin = boblight_margin;
COMXVideo::m_boblight = boblight_instance;
COMXVideo::m_boblight_timeout = boblight_timeout;
if(!m_decoded_width || !m_decoded_height)
return false;
m_converter = new CBitstreamConverter();
m_video_convert = m_converter->Open(hints.codec, (uint8_t *)hints.extradata, hints.extrasize, false);
if(m_video_convert)
{
if(m_converter->GetExtraData() != NULL && m_converter->GetExtraSize() > 0)
{
m_extrasize = m_converter->GetExtraSize();
m_extradata = (uint8_t *)malloc(m_extrasize);
memcpy(m_extradata, m_converter->GetExtraData(), m_converter->GetExtraSize());
}
}
else
{
if(hints.extrasize > 0 && hints.extradata != NULL)
{
m_extrasize = hints.extrasize;
m_extradata = (uint8_t *)malloc(m_extrasize);
memcpy(m_extradata, hints.extradata, hints.extrasize);
}
}
switch (hints.codec)
{
case CODEC_ID_H264:
{
switch(hints.profile)
{
case FF_PROFILE_H264_BASELINE:
// (role name) video_decoder.avc
// H.264 Baseline profile
decoder_name = OMX_H264BASE_DECODER;
m_codingType = OMX_VIDEO_CodingAVC;
m_video_codec_name = "omx-h264";
break;
case FF_PROFILE_H264_MAIN:
// (role name) video_decoder.avc
// H.264 Main profile
decoder_name = OMX_H264MAIN_DECODER;
m_codingType = OMX_VIDEO_CodingAVC;
m_video_codec_name = "omx-h264";
break;
case FF_PROFILE_H264_HIGH:
// (role name) video_decoder.avc
// H.264 Main profile
decoder_name = OMX_H264HIGH_DECODER;
m_codingType = OMX_VIDEO_CodingAVC;
m_video_codec_name = "omx-h264";
break;
case FF_PROFILE_UNKNOWN:
decoder_name = OMX_H264HIGH_DECODER;
m_codingType = OMX_VIDEO_CodingAVC;
m_video_codec_name = "omx-h264";
break;
default:
decoder_name = OMX_H264HIGH_DECODER;
m_codingType = OMX_VIDEO_CodingAVC;
m_video_codec_name = "omx-h264";
break;
}
}
break;
case CODEC_ID_MPEG4:
// (role name) video_decoder.mpeg4
// MPEG-4, DivX 4/5 and Xvid compatible
decoder_name = OMX_MPEG4_DECODER;
m_codingType = OMX_VIDEO_CodingMPEG4;
m_video_codec_name = "omx-mpeg4";
break;
case CODEC_ID_MPEG1VIDEO:
case CODEC_ID_MPEG2VIDEO:
// (role name) video_decoder.mpeg2
// MPEG-2
decoder_name = OMX_MPEG2V_DECODER;
m_codingType = OMX_VIDEO_CodingMPEG2;
m_video_codec_name = "omx-mpeg2";
break;
case CODEC_ID_H263:
// (role name) video_decoder.mpeg4
// MPEG-4, DivX 4/5 and Xvid compatible
decoder_name = OMX_MPEG4_DECODER;
m_codingType = OMX_VIDEO_CodingMPEG4;
m_video_codec_name = "omx-h263";
break;
case CODEC_ID_VP8:
// (role name) video_decoder.vp8
// VP8
decoder_name = OMX_VP8_DECODER;
m_codingType = OMX_VIDEO_CodingVP8;
m_video_codec_name = "omx-vp8";
break;
case CODEC_ID_VC1:
case CODEC_ID_WMV3:
// (role name) video_decoder.vc1
// VC-1, WMV9
decoder_name = OMX_VC1_DECODER;
m_codingType = OMX_VIDEO_CodingWMV;
m_video_codec_name = "omx-vc1";
break;
default:
printf("Vcodec id unknown: %x\n", hints.codec);
return false;
break;
}
if(deinterlace)
{
printf("enable deinterlace\n");
m_deinterlace = true;
}
else
{
m_deinterlace = false;
}
std::string componentName = "";
componentName = decoder_name;
if(!m_omx_decoder.Initialize(componentName, OMX_IndexParamVideoInit))
return false;
componentName = "OMX.broadcom.video_render";
if(!m_omx_render.Initialize(componentName, OMX_IndexParamVideoInit))
return false;
componentName = "OMX.broadcom.video_scheduler";
if(!m_omx_sched.Initialize(componentName, OMX_IndexParamVideoInit))
return false;
if(COMXVideo::m_boblight){
componentName = "OMX.broadcom.video_splitter";
if(!m_omx_split.Initialize(componentName, OMX_IndexParamVideoInit))
return false;
componentName = "OMX.broadcom.resize";
if(!m_omx_resize.Initialize(componentName, OMX_IndexParamImageInit))
return false;
}
if(m_deinterlace)
{
componentName = "OMX.broadcom.image_fx";
if(!m_omx_image_fx.Initialize(componentName, OMX_IndexParamImageInit))
return false;
}
componentName = "OMX.broadcom.text_scheduler";
if(!m_omx_text.Initialize(componentName, OMX_IndexParamOtherInit))
return false;
if(clock == NULL)
return false;
m_av_clock = clock;
m_omx_clock = m_av_clock->GetOMXClock();
if(m_omx_clock->GetComponent() == NULL)
{
m_av_clock = NULL;
m_omx_clock = NULL;
return false;
}
if(m_deinterlace)
{
m_omx_tunnel_decoder.Initialize(&m_omx_decoder, m_omx_decoder.GetOutputPort(), &m_omx_image_fx, m_omx_image_fx.GetInputPort());
m_omx_tunnel_image_fx.Initialize(&m_omx_image_fx, m_omx_image_fx.GetOutputPort(), &m_omx_sched, m_omx_sched.GetInputPort());
}
else
{
m_omx_tunnel_decoder.Initialize(&m_omx_decoder, m_omx_decoder.GetOutputPort(), &m_omx_sched, m_omx_sched.GetInputPort());
}
if(COMXVideo::m_boblight){
m_omx_tunnel_sched.Initialize(&m_omx_sched, m_omx_sched.GetOutputPort(), &m_omx_split, m_omx_split.GetInputPort());
m_omx_tunnel_split.Initialize(&m_omx_split, m_omx_split.GetOutputPort()+1, &m_omx_render, m_omx_render.GetInputPort());
m_omx_tunnel_resize.Initialize(&m_omx_split, m_omx_split.GetOutputPort(), &m_omx_resize, m_omx_resize.GetInputPort());
}
else
{
m_omx_tunnel_sched.Initialize(&m_omx_sched, m_omx_sched.GetOutputPort(), &m_omx_render, m_omx_render.GetInputPort());
}
m_omx_tunnel_clock.Initialize(m_omx_clock, m_omx_clock->GetInputPort() + 1, &m_omx_sched, m_omx_sched.GetOutputPort() + 1);
m_omx_tunnel_text.Initialize(m_omx_clock, m_omx_clock->GetInputPort() + 2, &m_omx_text, m_omx_text.GetInputPort() + 2);
omx_err = m_omx_tunnel_clock.Establish(false);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open m_omx_tunnel_clock.Establish\n");
return false;
}
omx_err = m_omx_decoder.SetStateForComponent(OMX_StateIdle);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open m_omx_decoder.SetStateForComponent\n");
return false;
}
OMX_VIDEO_PARAM_PORTFORMATTYPE formatType;
OMX_INIT_STRUCTURE(formatType);
formatType.nPortIndex = m_omx_decoder.GetInputPort();
formatType.eCompressionFormat = m_codingType;
if (hints.fpsscale > 0 && hints.fpsrate > 0)
{
formatType.xFramerate = (long long)(1<<16)*hints.fpsrate / hints.fpsscale;
}
else
{
formatType.xFramerate = 25 * (1<<16);
}
omx_err = m_omx_decoder.SetParameter(OMX_IndexParamVideoPortFormat, &formatType);
if(omx_err != OMX_ErrorNone)
return false;
OMX_PARAM_PORTDEFINITIONTYPE portParam;
OMX_INIT_STRUCTURE(portParam);
portParam.nPortIndex = m_omx_decoder.GetInputPort();
omx_err = m_omx_decoder.GetParameter(OMX_IndexParamPortDefinition, &portParam);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error OMX_IndexParamPortDefinition omx_err(0x%08x)\n", omx_err);
return false;
}
portParam.nPortIndex = m_omx_decoder.GetInputPort();
portParam.nBufferCountActual = VIDEO_BUFFERS;
portParam.format.video.nFrameWidth = m_decoded_width;
portParam.format.video.nFrameHeight = m_decoded_height;
omx_err = m_omx_decoder.SetParameter(OMX_IndexParamPortDefinition, &portParam);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error OMX_IndexParamPortDefinition omx_err(0x%08x)\n", omx_err);
return false;
}
OMX_PARAM_BRCMVIDEODECODEERRORCONCEALMENTTYPE concanParam;
OMX_INIT_STRUCTURE(concanParam);
concanParam.bStartWithValidFrame = OMX_FALSE;
omx_err = m_omx_decoder.SetParameter(OMX_IndexParamBrcmVideoDecodeErrorConcealment, &concanParam);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error OMX_IndexParamBrcmVideoDecodeErrorConcealment omx_err(0x%08x)\n", omx_err);
return false;
}
if(m_hdmi_clock_sync)
{
OMX_CONFIG_LATENCYTARGETTYPE latencyTarget;
OMX_INIT_STRUCTURE(latencyTarget);
latencyTarget.nPortIndex = m_omx_render.GetInputPort();
latencyTarget.bEnabled = OMX_TRUE;
latencyTarget.nFilter = 2;
latencyTarget.nTarget = 4000;
latencyTarget.nShift = 3;
latencyTarget.nSpeedFactor = -135;
latencyTarget.nInterFactor = 500;
latencyTarget.nAdjCap = 20;
omx_err = m_omx_render.SetConfig(OMX_IndexConfigLatencyTarget, &latencyTarget);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open OMX_IndexConfigLatencyTarget error (0%08x)\n", omx_err);
return false;
}
}
// Alloc buffers for the omx intput port.
omx_err = m_omx_decoder.AllocInputBuffers();
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open AllocOMXInputBuffers error (0%08x)\n", omx_err);
return false;
}
OMX_INIT_STRUCTURE(portParam);
portParam.nPortIndex = m_omx_text.GetInputPort();
omx_err = m_omx_text.GetParameter(OMX_IndexParamPortDefinition, &portParam);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error OMX_IndexParamPortDefinition omx_err(0x%08x)\n", omx_err);
return false;
}
portParam.nBufferCountActual = 100;
portParam.nBufferSize = MAX_TEXT_LENGTH;
omx_err = m_omx_text.SetParameter(OMX_IndexParamPortDefinition, &portParam);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error OMX_IndexParamPortDefinition omx_err(0x%08x)\n", omx_err);
return false;
}
omx_err = m_omx_text.AllocInputBuffers();
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open AllocOMXInputBuffers\n");
return false;
}
OMX_INIT_STRUCTURE(portParam);
portParam.nPortIndex = m_omx_text.GetOutputPort();
omx_err = m_omx_text.GetParameter(OMX_IndexParamPortDefinition, &portParam);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error OMX_IndexParamPortDefinition omx_err(0x%08x)\n", omx_err);
return false;
}
portParam.eDir = OMX_DirOutput;
portParam.format.other.eFormat = OMX_OTHER_FormatText;
portParam.format.other.eFormat = OMX_OTHER_FormatText;
portParam.nBufferCountActual = 1;
portParam.nBufferSize = MAX_TEXT_LENGTH;
omx_err = m_omx_text.SetParameter(OMX_IndexParamPortDefinition, &portParam);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error OMX_IndexParamPortDefinition omx_err(0x%08x)\n", omx_err);
return false;
}
omx_err = m_omx_text.AllocOutputBuffers();
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open AllocOutputBuffers\n");
return false;
}
omx_err = m_omx_tunnel_decoder.Establish(false);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open m_omx_tunnel_decoder.Establish\n");
return false;
}
omx_err = m_omx_decoder.SetStateForComponent(OMX_StateExecuting);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error m_omx_decoder.SetStateForComponent\n");
return false;
}
if(m_deinterlace)
{
OMX_CONFIG_IMAGEFILTERPARAMSTYPE image_filter;
OMX_INIT_STRUCTURE(image_filter);
image_filter.nPortIndex = m_omx_image_fx.GetOutputPort();
image_filter.nNumParams = 1;
image_filter.nParams[0] = 3;
image_filter.eImageFilter = OMX_ImageFilterDeInterlaceAdvanced;
omx_err = m_omx_image_fx.SetConfig(OMX_IndexConfigCommonImageFilterParameters, &image_filter);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error OMX_IndexConfigCommonImageFilterParameters omx_err(0x%08x)\n", omx_err);
return false;
}
omx_err = m_omx_tunnel_image_fx.Establish(false);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open m_omx_tunnel_image_fx.Establish\n");
return false;
}
omx_err = m_omx_image_fx.SetStateForComponent(OMX_StateExecuting);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error m_omx_image_fx.SetStateForComponent\n");
return false;
}
m_omx_image_fx.DisablePort(m_omx_image_fx.GetInputPort(), false);
m_omx_image_fx.DisablePort(m_omx_image_fx.GetOutputPort(), false);
}
omx_err = m_omx_tunnel_sched.Establish(false);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open m_omx_tunnel_sched.Establish\n");
return false;
}
/**
omx_err = m_omx_tunnel_write.Establish(false);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open m_omx_tunnel_write.Establish\n");
return false;
}
**/
omx_err = m_omx_text.SetStateForComponent(OMX_StateExecuting);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error m_omx_text.SetStateForComponent\n");
return false;
}
omx_err = m_omx_tunnel_text.Establish(false);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open m_omx_tunnel_text.Establish\n");
return false;
}
OMX_BUFFERHEADERTYPE *omx_buffer = m_omx_text.GetOutputBuffer();
if(!omx_buffer)
return false;
omx_err = m_omx_text.FillThisBuffer(omx_buffer);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open FillThisBuffer\n");
return false;
}
omx_buffer = NULL;
omx_err = m_omx_sched.SetStateForComponent(OMX_StateExecuting);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error m_omx_sched.SetStateForComponent\n");
return false;
}
if(COMXVideo::m_boblight){
omx_err = m_omx_split.SetStateForComponent(OMX_StateExecuting);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error m_omx_split.SetStateForComponent\n");
return false;
}
//set up the resizer
//make sure output of the splitter and input of the resize match
OMX_PARAM_PORTDEFINITIONTYPE port_def;
OMX_INIT_STRUCTURE(port_def);
port_def.nPortIndex = m_omx_split.GetOutputPort();
m_omx_split.GetParameter(OMX_IndexParamPortDefinition, &port_def);
port_def.nPortIndex = m_omx_resize.GetInputPort();
m_omx_resize.SetParameter(OMX_IndexParamPortDefinition, &port_def);
omx_err = m_omx_tunnel_resize.Establish(false);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s m_omx_tunnel_resize.Establish\n", CLASSNAME, __func__);
return false;
}
omx_err = m_omx_resize.WaitForEvent(OMX_EventPortSettingsChanged);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s m_omx_resize.WaitForEvent=%x\n", CLASSNAME, __func__, omx_err);
return false;
}
port_def.nPortIndex = m_omx_resize.GetOutputPort();
m_omx_resize.GetParameter(OMX_IndexParamPortDefinition, &port_def);
port_def.nPortIndex = m_omx_resize.GetOutputPort();
port_def.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
port_def.format.image.eColorFormat = OMX_COLOR_Format32bitARGB8888;
//calculate the size of the sized-down image
if(m_boblight_sizedown%2==1)m_boblight_sizedown--; //make sure we have even dimensions, since resize component requires it
float factor;
if(m_decoded_width>m_decoded_height){
factor = (float)m_boblight_sizedown / m_decoded_width;
}else{
factor = (float)m_boblight_sizedown / m_decoded_height;
}
port_def.format.image.nFrameWidth = round(factor * m_decoded_width);
port_def.format.image.nFrameHeight = round(factor * m_decoded_height);
port_def.format.image.nStride = 0;
port_def.format.image.nSliceHeight = 0;
port_def.format.image.bFlagErrorConcealment = OMX_FALSE;
omx_err = m_omx_resize.SetParameter(OMX_IndexParamPortDefinition, &port_def);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s m_omx_resize.SetParameter result(0x%x)\n", CLASSNAME, __func__, omx_err);
return false;
}
COMXVideo::m_boblight_width = (int)round(factor * m_decoded_width);
COMXVideo::m_boblight_height = (int)round(factor * m_decoded_height);
//calculate margins of processed pixels on the outer border of the image
COMXVideo::m_boblight_margin_t = (int)round(m_boblight_margin*m_boblight_height/100);
COMXVideo::m_boblight_margin_b = m_boblight_height - m_boblight_margin_t;
COMXVideo::m_boblight_margin_l = (int)round(m_boblight_margin*m_boblight_width/100);
COMXVideo::m_boblight_margin_r = m_boblight_width - m_boblight_margin_l;
CLog::Log(LOGDEBUG, "Setting boblight scanrange to %ix%i, scan margin is %i percent\n", COMXVideo::m_boblight_width, COMXVideo::m_boblight_height, m_boblight_margin);
boblight_setscanrange(COMXVideo::m_boblight, COMXVideo::m_boblight_width, COMXVideo::m_boblight_height);
OMX_PARAM_PORTDEFINITIONTYPE m_decoded_format;
OMX_INIT_STRUCTURE(m_decoded_format);
m_decoded_format.nPortIndex = m_omx_resize.GetOutputPort();
omx_err = m_omx_resize.GetParameter(OMX_IndexParamPortDefinition, &m_decoded_format);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s m_omx_resize.GetParameter result(0x%x)\n", CLASSNAME, __func__, omx_err);
return false;
}
assert(m_decoded_format.nBufferCountActual == 1);
omx_err = m_omx_resize.AllocOutputBuffers();
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s m_omx_resize.AllocOutputBuffers result(0x%x)\n", CLASSNAME, __func__, omx_err);
return false;
}
omx_err = m_omx_resize.SetStateForComponent(OMX_StateExecuting);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s m_omx_resize.SetStateForComponent result(0x%x)\n", CLASSNAME, __func__, omx_err);
return false;
}
omx_err = m_omx_tunnel_split.Establish(false);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open m_omx_tunnel_split.Establish\n");
return false;
}
omx_err = m_omx_tunnel_resize.Establish(false);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open m_omx_tunnel_resize.Establish\n");
return false;
}
//setting the custom callback to broadcast a signal COMXVideo::Thread is waiting for
m_omx_resize.SetCustomDecoderFillBufferDoneHandler(&COMXVideo::BufferDoneHandler);
//prepare boblight client thread and start it
pthread_cond_init(&COMXVideo::m_boblight_bufferdone_cond, NULL);
pthread_mutex_init(&COMXVideo::m_boblight_bufferdone_mutex, NULL);
COMXCoreComponent* args[2];
args[0] = &m_omx_split;
args[1] = &m_omx_resize;
pthread_create(&COMXVideo::m_boblight_clientthread, NULL, &COMXVideo::BoblightClientThread, (void*)&args);
}
omx_err = m_omx_render.SetStateForComponent(OMX_StateExecuting);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error m_omx_render.SetStateForComponent\n");
return false;
}
if(!SendDecoderConfig())
return false;
m_is_open = true;
m_drop_state = false;
m_setStartTime = true;
m_setStartTimeText = true;
// only set aspect when we have a aspect and display doesn't match the aspect
if(display_aspect != 0.0f && (hints.aspect != display_aspect))
{
OMX_CONFIG_DISPLAYREGIONTYPE configDisplay;
OMX_INIT_STRUCTURE(configDisplay);
configDisplay.nPortIndex = m_omx_render.GetInputPort();
AVRational aspect;
float fAspect = (float)hints.aspect / (float)m_decoded_width * (float)m_decoded_height;
aspect = av_d2q(fAspect, 100);
printf("Aspect : num %d den %d aspect %f display aspect %f\n", aspect.num, aspect.den, hints.aspect, display_aspect);
configDisplay.set = OMX_DISPLAY_SET_PIXEL;
configDisplay.pixel_x = aspect.num;
configDisplay.pixel_y = aspect.den;
omx_err = m_omx_render.SetConfig(OMX_IndexConfigDisplayRegion, &configDisplay);
if(omx_err != OMX_ErrorNone)
return false;
}
/*
configDisplay.set = OMX_DISPLAY_SET_LAYER;
configDisplay.layer = 2;
omx_err = m_omx_render.SetConfig(OMX_IndexConfigDisplayRegion, &configDisplay);
if(omx_err != OMX_ErrorNone)
return false;
configDisplay.set = OMX_DISPLAY_SET_DEST_RECT;
configDisplay.dest_rect.x_offset = 100;
configDisplay.dest_rect.y_offset = 100;
configDisplay.dest_rect.width = 640;
configDisplay.dest_rect.height = 480;
omx_err = m_omx_render.SetConfig(OMX_IndexConfigDisplayRegion, &configDisplay);
if(omx_err != OMX_ErrorNone)
return false;
configDisplay.set = OMX_DISPLAY_SET_TRANSFORM;
configDisplay.transform = OMX_DISPLAY_ROT180;
omx_err = m_omx_render.SetConfig(OMX_IndexConfigDisplayRegion, &configDisplay);
if(omx_err != OMX_ErrorNone)
return false;
configDisplay.set = OMX_DISPLAY_SET_FULLSCREEN;
configDisplay.fullscreen = OMX_FALSE;
omx_err = m_omx_render.SetConfig(OMX_IndexConfigDisplayRegion, &configDisplay);
if(omx_err != OMX_ErrorNone)
return false;
configDisplay.set = OMX_DISPLAY_SET_MODE;
configDisplay.mode = OMX_DISPLAY_MODE_FILL; //OMX_DISPLAY_MODE_LETTERBOX;
omx_err = m_omx_render.SetConfig(OMX_IndexConfigDisplayRegion, &configDisplay);
if(omx_err != OMX_ErrorNone)
return false;
configDisplay.set = OMX_DISPLAY_SET_LAYER;
configDisplay.layer = 1;
omx_err = m_omx_render.SetConfig(OMX_IndexConfigDisplayRegion, &configDisplay);
if(omx_err != OMX_ErrorNone)
return false;
configDisplay.set = OMX_DISPLAY_SET_ALPHA;
configDisplay.alpha = OMX_FALSE;
omx_err = m_omx_render.SetConfig(OMX_IndexConfigDisplayRegion, &configDisplay);
if(omx_err != OMX_ErrorNone)
return false;
*/
CLog::Log(LOGDEBUG,
"%s::%s - decoder_component(0x%p), input_port(0x%x), output_port(0x%x) deinterlace %d hdmiclocksync %d\n",
CLASSNAME, __func__, m_omx_decoder.GetComponent(), m_omx_decoder.GetInputPort(), m_omx_decoder.GetOutputPort(),
m_deinterlace, m_hdmi_clock_sync);
m_first_frame = true;
m_first_text = true;
return true;
}
int cBoblight::setScanRange(int width, int height) {
boblight_setscanrange(m_boblight, width, height);
return success;
}
