BOOL CChildView::OnPlayPlayPauseStop(UINT nID)
{
if(nID == ID_PLAY_STOP) SetVideoRect();
CString osd = ResStr(nID);
int i = osd.Find(_T("\n"));
if(i > 0) osd.Delete(i, osd.GetLength()-i);
CRect r1;
((CMainFrame*)AfxGetMainWnd())->GetClientRect(&r1);
if((!r1.Width()) || (!r1.Height())) return FALSE;
((CMainFrame*)AfxGetMainWnd())->m_OSD.DisplayMessage(OSD_TOPLEFT, osd, 1500);
return FALSE;
}
EC_U32 SDL_VideoRender::Init(MediaCtxInfo* pMediaInfo,
EC_U32 nScreenWidth,
EC_U32 nScreenHight,
EC_VOIDP pDrawable)
{
if (EC_NULL == pMediaInfo)
return EC_Err_BadParam;
AVCodecContext *pCodecCtx = (AVCodecContext*)(pMediaInfo->m_pVideoCodecInfo);
if ((0 == nScreenWidth) || (0 == nScreenHight))
{
nScreenWidth = pCodecCtx->width;
nScreenHight = pCodecCtx->height;
}
m_pDrawable = pDrawable;
char pEnvStr[256] = { 0 };
sprintf_s(pEnvStr, 255, "SDL_WINDOWID=0x%lx", pDrawable);
SDL_putenv(pEnvStr);
if (SDL_Init(SDL_INIT_VIDEO) < 0)
return Video_Render_Err_InitFail;
m_nWindowWidth = nScreenWidth;
m_nWindowHeight = nScreenHight;
m_nVideoWidth = pCodecCtx->width;
m_nVideoHeight = pCodecCtx->height;
m_nScreenWidth = GetSystemMetrics(SM_CXSCREEN);
m_nScreenHeight = GetSystemMetrics(SM_CYSCREEN);
EC_U32 nFlag = 0;
if (m_pDrawable == EC_NULL)
nFlag = SDL_FULLSCREEN;
m_pScreen = SDL_SetVideoMode(m_nScreenWidth, m_nScreenHeight, 0, nFlag);
if (EC_NULL == m_pScreen)
return Video_Render_Err_CreatWindowFail;
m_pOverlay = SDL_CreateYUVOverlay(m_nWindowWidth, m_nWindowHeight, SDL_YV12_OVERLAY, m_pScreen);
if (EC_NULL == m_pOverlay)
return Video_Render_Err_CreatRenderFail;
SetVideoRect(&m_sSDLRect);
return Video_Render_Err_None;
}
EC_VOID SDL_VideoRender::UpdateVideoScreen(MediaEngVideoScreen *pVideoScreen)
{
m_nWindowWidth = pVideoScreen->nWidth;
m_nWindowHeight = pVideoScreen->nHeight;
EC_VOIDP pDrawable = pVideoScreen->pScreen;
if (pDrawable != m_pDrawable)
{
EC_U32 nFlag = 0;
SDL_FreeSurface(m_pScreen);
if (m_pDrawable == EC_NULL) nFlag = SDL_FULLSCREEN;
m_pScreen = SDL_SetVideoMode(m_nScreenWidth, m_nScreenHeight, 0, nFlag);
}
SDL_FreeYUVOverlay(m_pOverlay);
m_pOverlay = SDL_CreateYUVOverlay(m_nWindowWidth, m_nWindowHeight, SDL_YV12_OVERLAY, m_pScreen);
SetVideoRect(&m_sSDLRect);
EraseVideoRim();
}
bool COMXVideo::PortSettingsChanged()
{
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
std::string componentName = "";
if (m_settings_changed)
{
m_omx_decoder.DisablePort(m_omx_decoder.GetOutputPort(), true);
}
OMX_PARAM_PORTDEFINITIONTYPE port_image;
OMX_INIT_STRUCTURE(port_image);
port_image.nPortIndex = m_omx_decoder.GetOutputPort();
omx_err = m_omx_decoder.GetParameter(OMX_IndexParamPortDefinition, &port_image);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - error m_omx_decoder.GetParameter(OMX_IndexParamPortDefinition) omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
}
OMX_CONFIG_POINTTYPE pixel_aspect;
OMX_INIT_STRUCTURE(pixel_aspect);
pixel_aspect.nPortIndex = m_omx_decoder.GetOutputPort();
omx_err = m_omx_decoder.GetParameter(OMX_IndexParamBrcmPixelAspectRatio, &pixel_aspect);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - error m_omx_decoder.GetParameter(OMX_IndexParamBrcmPixelAspectRatio) omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
}
if (pixel_aspect.nX && pixel_aspect.nY)
m_pixel_aspect = (float)pixel_aspect.nX / (float)pixel_aspect.nY;
if (m_settings_changed)
{
SetVideoRect(m_src_rect, m_dst_rect);
m_omx_decoder.EnablePort(m_omx_decoder.GetOutputPort(), true);
return true;
}
OMX_CONFIG_INTERLACETYPE interlace;
OMX_INIT_STRUCTURE(interlace);
interlace.nPortIndex = m_omx_decoder.GetOutputPort();
omx_err = m_omx_decoder.GetConfig(OMX_IndexConfigCommonInterlace, &interlace);
if(m_deinterlace_request == 1)
m_deinterlace = true;
else if(m_deinterlace_request == -1)
m_deinterlace = false;
else
m_deinterlace = interlace.eMode != OMX_InterlaceProgressive;
printf("V:PortSettingsChanged: %dx%d@%.2f %s\n", port_image.format.video.nFrameWidth, port_image.format.video.nFrameHeight,
port_image.format.video.xFramerate / (float)(1<<16), m_deinterlace ? "interlaced":"progressive");
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(m_deinterlace)
{
componentName = "OMX.broadcom.image_fx";
if(!m_omx_image_fx.Initialize(componentName, OMX_IndexParamImageInit))
return false;
}
m_settings_changed = true;
SetVideoRect(m_src_rect, m_dst_rect);
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;
}
}
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;
}
}
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());
}
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);
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;
}
if(m_deinterlace)
{
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;
}
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_sched.SetStateForComponent(OMX_StateExecuting);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error m_omx_sched.SetStateForComponent\n");
return 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_render.SetStateForComponent(OMX_StateExecuting);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error m_omx_render.SetStateForComponent\n");
return false;
}
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;
}
return true;
}
HRESULT FMPlayerDShow::LoadMedia(const tchar* pFileName, IMediaOptions* pOptions)
{
USES_CONVERSION;
HRESULT hr = E_FAIL;
if (m_FourCC == "divx" && m_StreamFormat == "divx")
{
Init(m_hWndParent, m_pNotify);
}
if (m_FilterGraph == NULL)
return E_FAIL;
m_MediaControl->Stop();
if (m_FileSource)
{
m_FilterGraph->RemoveFilter(m_FileSource);
m_FileSource.Release();
}
else
{
/* CComQIPtr<IGraphBuilder> pGraphBuilder = m_FilterGraph;
if (SUCCEEDED(pGraphBuilder->RenderFile(T2OLE(pFileName), NULL)))
{
hr = Start();
return hr;
}
*/
if (SUCCEEDED(DetermineVideoType(pFileName)))
{
InitFilters(pFileName);
}
else
{
_DBGAlertM("FMPlayerDShow: PlayVideo: **Unable to determine file format.\n");
return E_FAIL;
}
}
_DBGAlertM("FMPlayerDShow: Starting playback: %s; offset = %I64d\n", pFileName, pOptions->rtOffset);
CComQIPtr<IGraphBuilder> pGraphBuilder = m_FilterGraph;
hr = pGraphBuilder->AddSourceFilter(T2OLE(pFileName), T2OLE(pFileName), &m_FileSource);
if (SUCCEEDED(hr))
{
CComPtr<IPin> PinSourceOut = GetOutPin(m_FileSource, 0);
CComPtr<IPin> PinSplitterIn = GetInPin(m_AviSplitter, 0);
if (PinSourceOut && PinSplitterIn)
{
PinSplitterIn->Disconnect();
hr = m_FilterGraph->ConnectDirect(PinSourceOut, PinSplitterIn, NULL);
if (FAILED(hr))
_DBGAlertM("FMediaMgr: **Connect SourceOut to SplitterIn: %s\n", GetErrorDescription(hr));
}
else
_DBGAlertM("FMediaMgr: **PinSourceOut or PinSourceIn is NULL\n");
hr = BuildTheGraph();
if (SUCCEEDED(hr))
{
m_FileName = pFileName;
m_Offset = pOptions->rtOffset;
hr = Start();
if (FAILED(hr))
_DBGAlertM("FMPlayerDShow: **Start() failed: %s\n", GetErrorDescription(hr));
else
{
SetVideoRect(m_VideoRect);
}
}
else
_DBGAlertM("FMPlayerDShow: **Cannot Start(): %s\n", GetErrorDescription(hr));
}
else
_DBGAlertM("FMPlayerDShow: **AddSourceFilter() failed: %s\n", GetErrorDescription(hr));
_DBGAlertM("FMPlayerDShow: StartPlayback() exiting: %s\n", GetErrorDescription(hr));
return hr;
}
bool COMXVideo::PortSettingsChanged()
{
CSingleLock lock (m_critSection);
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
if (m_settings_changed)
{
m_omx_decoder.DisablePort(m_omx_decoder.GetOutputPort(), true);
}
OMX_PARAM_PORTDEFINITIONTYPE port_image;
OMX_INIT_STRUCTURE(port_image);
port_image.nPortIndex = m_omx_decoder.GetOutputPort();
omx_err = m_omx_decoder.GetParameter(OMX_IndexParamPortDefinition, &port_image);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - error m_omx_decoder.GetParameter(OMX_IndexParamPortDefinition) omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
}
OMX_CONFIG_POINTTYPE pixel_aspect;
OMX_INIT_STRUCTURE(pixel_aspect);
pixel_aspect.nPortIndex = m_omx_decoder.GetOutputPort();
omx_err = m_omx_decoder.GetParameter(OMX_IndexParamBrcmPixelAspectRatio, &pixel_aspect);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - error m_omx_decoder.GetParameter(OMX_IndexParamBrcmPixelAspectRatio) omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
}
if (pixel_aspect.nX && pixel_aspect.nY)
{
float fAspect = (float)pixel_aspect.nX / (float)pixel_aspect.nY;
m_pixel_aspect = fAspect / m_config.display_aspect;
}
if (m_settings_changed)
{
CLog::Log(LOGDEBUG, "%s::%s - %dx%d@%.2f interlace:%d deinterlace:%d anaglyph:%d par:%.2f display:%d layer:%d", CLASSNAME, __func__,
port_image.format.video.nFrameWidth, port_image.format.video.nFrameHeight,
port_image.format.video.xFramerate / (float)(1<<16), 0, m_deinterlace, m_config.anaglyph, m_pixel_aspect, m_config.display, m_config.layer);
printf("V:PortSettingsChanged: %dx%d@%.2f interlace:%d deinterlace:%d anaglyph:%d par:%.2f display:%d layer:%d\n",
port_image.format.video.nFrameWidth, port_image.format.video.nFrameHeight,
port_image.format.video.xFramerate / (float)(1<<16), 0, m_deinterlace, m_config.anaglyph, m_pixel_aspect, m_config.display, m_config.layer);
SetVideoRect(m_src_rect, m_config.dst_rect);
m_omx_decoder.EnablePort(m_omx_decoder.GetOutputPort(), true);
return true;
}
OMX_CONFIG_INTERLACETYPE interlace;
OMX_INIT_STRUCTURE(interlace);
interlace.nPortIndex = m_omx_decoder.GetOutputPort();
omx_err = m_omx_decoder.GetConfig(OMX_IndexConfigCommonInterlace, &interlace);
if(m_config.deinterlace == VS_DEINTERLACEMODE_FORCE)
m_deinterlace = true;
else if(m_config.deinterlace == VS_DEINTERLACEMODE_OFF)
m_deinterlace = false;
else
m_deinterlace = interlace.eMode != OMX_InterlaceProgressive;
if(!m_omx_render.Initialize("OMX.broadcom.video_render", OMX_IndexParamVideoInit))
return false;
m_omx_render.ResetEos();
CLog::Log(LOGDEBUG, "%s::%s - %dx%d@%.2f interlace:%d deinterlace:%d anaglyph:%d par:%.2f layer:%d", CLASSNAME, __func__,
port_image.format.video.nFrameWidth, port_image.format.video.nFrameHeight,
port_image.format.video.xFramerate / (float)(1<<16), interlace.eMode, m_deinterlace, m_config.anaglyph, m_pixel_aspect, m_config.layer);
printf("V:PortSettingsChanged: %dx%d@%.2f interlace:%d deinterlace:%d anaglyph:%d par:%.2f layer:%d alpha:%d\n",
port_image.format.video.nFrameWidth, port_image.format.video.nFrameHeight,
port_image.format.video.xFramerate / (float)(1<<16), interlace.eMode, m_deinterlace, m_config.anaglyph, m_pixel_aspect, m_config.layer, m_config.alpha);
if(!m_omx_sched.Initialize("OMX.broadcom.video_scheduler", OMX_IndexParamVideoInit))
return false;
if(m_deinterlace || m_config.anaglyph)
{
if(!m_omx_image_fx.Initialize("OMX.broadcom.image_fx", OMX_IndexParamImageInit))
return false;
}
OMX_CONFIG_DISPLAYREGIONTYPE configDisplay;
OMX_INIT_STRUCTURE(configDisplay);
configDisplay.nPortIndex = m_omx_render.GetInputPort();
configDisplay.set = (OMX_DISPLAYSETTYPE)(OMX_DISPLAY_SET_ALPHA | OMX_DISPLAY_SET_TRANSFORM | OMX_DISPLAY_SET_LAYER | OMX_DISPLAY_SET_NUM);
configDisplay.alpha = m_config.alpha;
configDisplay.num = m_config.display;
configDisplay.layer = m_config.layer;
configDisplay.transform = m_transform;
omx_err = m_omx_render.SetConfig(OMX_IndexConfigDisplayRegion, &configDisplay);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGWARNING, "%s::%s - could not set transform : %d", CLASSNAME, __func__, m_transform);
return false;
}
SetVideoRect(m_src_rect, m_config.dst_rect);
if(m_config.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, "%s::%s - OMX_IndexConfigLatencyTarget omx_err(0%08x)", CLASSNAME, __func__, omx_err);
return false;
}
}
if(m_deinterlace || m_config.anaglyph)
{
bool advanced_deinterlace = m_config.advanced_hd_deinterlace || port_image.format.video.nFrameWidth * port_image.format.video.nFrameHeight <= 576 * 720;
if (m_config.anaglyph != OMX_ImageFilterAnaglyphNone || !advanced_deinterlace)
{
// Image_fx assumed 3 frames of context. anaglyph and simple deinterlace don't require this
OMX_PARAM_U32TYPE extra_buffers;
OMX_INIT_STRUCTURE(extra_buffers);
extra_buffers.nU32 = -2;
omx_err = m_omx_image_fx.SetParameter(OMX_IndexParamBrcmExtraBuffers, &extra_buffers);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s error OMX_IndexParamBrcmExtraBuffers omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
return false;
}
}
OMX_CONFIG_IMAGEFILTERPARAMSTYPE image_filter;
OMX_INIT_STRUCTURE(image_filter);
image_filter.nPortIndex = m_omx_image_fx.GetOutputPort();
if (m_config.anaglyph != OMX_ImageFilterAnaglyphNone)
{
image_filter.nNumParams = 1;
image_filter.nParams[0] = m_config.anaglyph;
image_filter.eImageFilter = OMX_ImageFilterAnaglyph;
}
else
{
image_filter.nNumParams = 4;
image_filter.nParams[0] = 3;
image_filter.nParams[1] = 0; // default frame interval
image_filter.nParams[2] = 0; // half framerate
image_filter.nParams[3] = 1; // use qpus
if (!advanced_deinterlace)
image_filter.eImageFilter = OMX_ImageFilterDeInterlaceFast;
else
image_filter.eImageFilter = OMX_ImageFilterDeInterlaceAdvanced;
}
omx_err = m_omx_image_fx.SetConfig(OMX_IndexConfigCommonImageFilterParameters, &image_filter);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - OMX_IndexConfigCommonImageFilterParameters omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
return false;
}
}
if(m_deinterlace || m_config.anaglyph)
{
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());
}
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);
omx_err = m_omx_tunnel_clock.Establish();
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - m_omx_tunnel_clock.Establish omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
return false;
}
omx_err = m_omx_tunnel_decoder.Establish();
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - m_omx_tunnel_decoder.Establish omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
return false;
}
if(m_deinterlace || m_config.anaglyph)
{
omx_err = m_omx_tunnel_image_fx.Establish();
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - m_omx_tunnel_image_fx.Establish omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
return false;
}
omx_err = m_omx_image_fx.SetStateForComponent(OMX_StateExecuting);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - m_omx_image_fx.SetStateForComponent omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
return false;
}
}
omx_err = m_omx_tunnel_sched.Establish();
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - m_omx_tunnel_sched.Establish omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
return false;
}
omx_err = m_omx_sched.SetStateForComponent(OMX_StateExecuting);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - m_omx_sched.SetStateForComponent omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
return false;
}
omx_err = m_omx_render.SetStateForComponent(OMX_StateExecuting);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "%s::%s - m_omx_render.SetStateForComponent omx_err(0x%08x)", CLASSNAME, __func__, omx_err);
return false;
}
m_settings_changed = true;
return true;
}
void CMMALRenderer::RenderUpdate(bool clear, DWORD flags, DWORD alpha)
{
CSingleLock lock(m_sharedSection);
int source = m_iYV12RenderBuffer;
CMMALBuffer *omvb = nullptr;
if (!m_bConfigured)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s - not configured: clear:%d flags:%x alpha:%d source:%d", CLASSNAME, __func__, clear, flags, alpha, source);
goto exit;
}
if (m_format == RENDER_FMT_MMAL)
omvb = m_buffers[source];
// we only want to upload frames once
if (omvb && omvb->mmal_buffer && omvb->mmal_buffer->flags & MMAL_BUFFER_HEADER_FLAG_USER1)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s - MMAL: clear:%d flags:%x alpha:%d source:%d omvb:%p mmal:%p mflags:%x skipping", CLASSNAME, __func__, clear, flags, alpha, source, omvb, omvb->mmal_buffer, omvb->mmal_buffer->flags);
goto exit;
}
ManageRenderArea();
if (m_format != RENDER_FMT_MMAL)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s - bypass: clear:%d flags:%x alpha:%d source:%d format:%d", CLASSNAME, __func__, clear, flags, alpha, source, m_format);
goto exit;
}
SetVideoRect(m_sourceRect, m_destRect);
if (omvb && omvb->mmal_buffer)
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s - MMAL: clear:%d flags:%x alpha:%d source:%d omvb:%p mmal:%p mflags:%x", CLASSNAME, __func__, clear, flags, alpha, source, omvb, omvb->mmal_buffer, omvb->mmal_buffer->flags);
// check for changes in aligned sizes
if (omvb->m_width != (uint32_t)m_vout_input->format->es->video.crop.width || omvb->m_height != (uint32_t)m_vout_input->format->es->video.crop.height ||
omvb->m_aligned_width != m_vout_input->format->es->video.width || omvb->m_aligned_height != m_vout_input->format->es->video.height)
{
CLog::Log(LOGDEBUG, "%s::%s Changing dimensions from %dx%d (%dx%d) to %dx%d (%dx%d)", CLASSNAME, __func__,
m_vout_input->format->es->video.crop.width, m_vout_input->format->es->video.crop.height, omvb->m_width, omvb->m_height,
m_vout_input->format->es->video.width, m_vout_input->format->es->video.height, omvb->m_aligned_width, omvb->m_aligned_height);
m_vout_input->format->es->video.width = omvb->m_aligned_width;
m_vout_input->format->es->video.height = omvb->m_aligned_height;
m_vout_input->format->es->video.crop.width = omvb->m_width;
m_vout_input->format->es->video.crop.height = omvb->m_height;
MMAL_STATUS_T status = mmal_port_format_commit(m_vout_input);
if (status != MMAL_SUCCESS)
{
CLog::Log(LOGERROR, "%s::%s Failed to commit vout input format (status=%x %s)", CLASSNAME, __func__, status, mmal_status_to_string(status));
goto exit;
}
}
m_inflight++;
assert(omvb->mmal_buffer && omvb->mmal_buffer->data && omvb->mmal_buffer->length);
omvb->Acquire();
omvb->mmal_buffer->flags |= MMAL_BUFFER_HEADER_FLAG_USER1 | MMAL_BUFFER_HEADER_FLAG_USER2;
omvb->mmal_buffer->user_data = omvb;
if (m_queue && m_fps > 0.0f)
mmal_queue_put(m_queue, omvb->mmal_buffer);
else
mmal_port_send_buffer(m_vout_input, omvb->mmal_buffer);
}
else
CLog::Log(LOGDEBUG, "%s::%s - MMAL: No buffer to update clear:%d flags:%x alpha:%d source:%d omvb:%p mmal:%p", CLASSNAME, __func__, clear, flags, alpha, source, omvb, omvb ? omvb->mmal_buffer : nullptr);
exit:
lock.Leave();
g_RBP.WaitVsync();
}
BOOL CChildView::OnPlayPlayPauseStop(UINT nID)
{
if(nID == ID_PLAY_STOP) SetVideoRect();
return FALSE;
}
bool COMXVideo::Open(COMXStreamInfo &hints, OMXClock *clock, const CRect &DestRect, float display_aspect, bool deinterlace, bool hdmi_clock_sync)
{
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;
if(!m_decoded_width || !m_decoded_height)
return false;
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_VP6:
case CODEC_ID_VP6F:
case CODEC_ID_VP6A:
// (role name) video_decoder.vp6
// VP6
decoder_name = OMX_VP6_DECODER;
m_codingType = OMX_VIDEO_CodingVP6;
m_video_codec_name = "omx-vp6";
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_THEORA:
// (role name) video_decoder.theora
// theora
decoder_name = OMX_THEORA_DECODER;
m_codingType = OMX_VIDEO_CodingTheora;
m_video_codec_name = "omx-theora";
break;
case CODEC_ID_MJPEG:
case CODEC_ID_MJPEGB:
// (role name) video_decoder.mjpg
// mjpg
decoder_name = OMX_MJPEG_DECODER;
m_codingType = OMX_VIDEO_CodingMJPEG;
m_video_codec_name = "omx-mjpeg";
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(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());
}
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_deinterlace)
{
// the deinterlace component requires 3 additional video buffers in addition to the DPB (this is normally 2).
OMX_PARAM_U32TYPE extra_buffers;
OMX_INIT_STRUCTURE(extra_buffers);
extra_buffers.nU32 = 3;
omx_err = m_omx_decoder.SetParameter(OMX_IndexParamBrcmExtraBuffers, &extra_buffers);
if(omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open error OMX_IndexParamBrcmExtraBuffers omx_err(0x%08x)\n", omx_err);
return false;
}
}
// broadcom omx entension:
// When enabled, the timestamp fifo mode will change the way incoming timestamps are associated with output images.
// In this mode the incoming timestamps get used without re-ordering on output images.
if(hints.ptsinvalid)
{
OMX_CONFIG_BOOLEANTYPE timeStampMode;
OMX_INIT_STRUCTURE(timeStampMode);
timeStampMode.bEnabled = OMX_TRUE;
omx_err = m_omx_decoder.SetParameter((OMX_INDEXTYPE)OMX_IndexParamBrcmVideoTimestampFifo, &timeStampMode);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open OMX_IndexParamBrcmVideoTimestampFifo error (0%08x)\n", omx_err);
return false;
}
}
if(NaluFormatStartCodes(hints.codec, m_extradata, m_extrasize))
{
OMX_NALSTREAMFORMATTYPE nalStreamFormat;
OMX_INIT_STRUCTURE(nalStreamFormat);
nalStreamFormat.nPortIndex = m_omx_decoder.GetInputPort();
nalStreamFormat.eNaluFormat = OMX_NaluFormatStartCodes;
omx_err = m_omx_decoder.SetParameter((OMX_INDEXTYPE)OMX_IndexParamNalStreamFormatSelect, &nalStreamFormat);
if (omx_err != OMX_ErrorNone)
{
CLog::Log(LOGERROR, "COMXVideo::Open OMX_IndexParamNalStreamFormatSelect error (0%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;
}
}
CRect SrcRect = {0,0,0,0};
SetVideoRect(SrcRect, DestRect);
// 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_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;
}
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;
float fAspect = (float)hints.aspect / (float)m_decoded_width * (float)m_decoded_height;
float par = hints.aspect ? fAspect/display_aspect : 0.0f;
// only set aspect when we have a aspect and display doesn't match the aspect
if(par != 0.0f && fabs(par - 1.0f) > 0.01f)
{
OMX_CONFIG_DISPLAYREGIONTYPE configDisplay;
OMX_INIT_STRUCTURE(configDisplay);
configDisplay.nPortIndex = m_omx_render.GetInputPort();
AVRational aspect;
aspect = av_d2q(par, 100);
configDisplay.set = OMX_DISPLAY_SET_PIXEL;
configDisplay.pixel_x = aspect.num;
configDisplay.pixel_y = aspect.den;
printf("Aspect : num %d den %d aspect %f pixel aspect %f\n", aspect.num, aspect.den, hints.aspect, par);
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;
}
