bool CMMALRenderer::Configure(unsigned int width, unsigned int height, unsigned int d_width, unsigned int d_height, float fps, unsigned flags, ERenderFormat format, unsigned extended_format, unsigned int orientation)
{
CSingleLock lock(m_sharedSection);
ReleaseBuffers();
m_sourceWidth = width;
m_sourceHeight = height;
m_renderOrientation = orientation;
m_fps = fps;
m_iFlags = flags;
// cause SetVideoRect to trigger - needed after a hdmi mode change
m_src_rect.SetRect(0, 0, 0, 0);
m_dst_rect.SetRect(0, 0, 0, 0);
CLog::Log(LOGDEBUG, "%s::%s - %dx%d->%dx%d@%.2f flags:%x format:%d ext:%x orient:%d", CLASSNAME, __func__, width, height, d_width, d_height, fps, flags, format, extended_format, orientation);
if (format != RENDER_FMT_BYPASS && format != RENDER_FMT_MMAL)
{
CLog::Log(LOGERROR, "%s::%s - format:%d not supported", CLASSNAME, __func__, format);
return false;
}
// calculate the input frame aspect ratio
CalculateFrameAspectRatio(d_width, d_height);
SetViewMode(CMediaSettings::GetInstance().GetCurrentVideoSettings().m_ViewMode);
ManageRenderArea();
m_bMMALConfigured = init_vout(format, m_opaque);
m_bConfigured = m_bMMALConfigured;
assert(m_bConfigured);
return m_bConfigured;
}
void CWinRenderer::Update()
{
if (!m_bConfigured)
return;
ManageRenderArea();
ManageTextures();
}
void CRendererDRMPRIME::Update()
{
if (!m_bConfigured)
return;
ManageRenderArea();
}
void CMMALRenderer::Update()
{
if (g_advancedSettings.CanLogComponent(LOGVIDEO))
CLog::Log(LOGDEBUG, "%s::%s", CLASSNAME, __func__);
if (!m_bConfigured) return;
ManageRenderArea();
}
bool CWinRenderer::Configure(const VideoPicture &picture, float fps, unsigned flags, unsigned int orientation)
{
m_sourceWidth = picture.iWidth;
m_sourceHeight = picture.iHeight;
m_renderOrientation = orientation;
// need to recreate textures
m_NumYV12Buffers = 0;
m_iYV12RenderBuffer = 0;
// reinitialize the filters/shaders
m_bFilterInitialized = false;
m_fps = fps;
m_iFlags = flags;
m_format = picture.videoBuffer->GetFormat();
if (m_format == AV_PIX_FMT_D3D11VA_VLD)
{
DXVA::CDXVAOutputBuffer *dxvaBuf = static_cast<DXVA::CDXVAOutputBuffer*>(picture.videoBuffer);
m_dxva_format = dxvaBuf->format;
}
// calculate the input frame aspect ratio
CalculateFrameAspectRatio(picture.iDisplayWidth, picture.iDisplayHeight);
SetViewMode(m_videoSettings.m_ViewMode);
ManageRenderArea();
SelectRenderMethod();
m_bConfigured = true;
// load 3DLUT
ColorManagmentUpdate();
return true;
}
bool CRendererAML::RenderUpdateVideoHook(bool clear, DWORD flags, DWORD alpha)
{
ManageRenderArea();
CDVDAmlogicInfo *amli = static_cast<CDVDAmlogicInfo *>(m_buffers[m_iYV12RenderBuffer].hwDec);
if (amli)
{
CAMLCodec *amlcodec = amli->getAmlCodec();
if (amlcodec)
amlcodec->SetVideoRect(m_sourceRect, m_destRect);
}
return true;
}
void CWinRenderer::RenderUpdate(int index, int index2, bool clear, unsigned int flags, unsigned int alpha)
{
m_iYV12RenderBuffer = index;
if (clear)
CServiceBroker::GetWinSystem()->GetGfxContext().Clear(DX::Windowing()->UseLimitedColor() ? 0x101010 : 0);
if (!m_bConfigured)
return;
DX::Windowing()->SetAlphaBlendEnable(alpha < 255);
ManageTextures();
ManageRenderArea();
Render(flags, DX::Windowing()->GetBackBuffer());
}
void CWinRenderer::RenderUpdate(int index, int index2, bool clear, unsigned int flags, unsigned int alpha)
{
m_iYV12RenderBuffer = index;
if (clear)
g_graphicsContext.Clear(DX::Windowing().UseLimitedColor() ? 0x101010 : 0);
if (!m_bConfigured)
return;
DX::Windowing().SetAlphaBlendEnable(alpha < 255);
ManageTextures();
ManageRenderArea();
Render(flags, DX::Windowing().GetBackBuffer());
}
bool CRendererAML::RenderUpdateVideoHook(bool clear, DWORD flags, DWORD alpha)
{
ManageRenderArea();
CDVDAmlogicInfo *amli = static_cast<CDVDAmlogicInfo *>(m_buffers[m_iYV12RenderBuffer].hwDec);
if (amli && amli->GetOmxPts() != m_prevPts)
{
m_prevPts = amli->GetOmxPts();
SysfsUtils::SetInt("/sys/module/amvideo/parameters/omx_pts", amli->GetOmxPts());
CAMLCodec *amlcodec = amli->getAmlCodec();
if (amlcodec)
amlcodec->SetVideoRect(m_sourceRect, m_destRect);
}
usleep(10000);
return true;
}
bool CRendererDRMPRIME::Configure(const VideoPicture& picture, float fps, unsigned int orientation)
{
m_format = picture.videoBuffer->GetFormat();
m_sourceWidth = picture.iWidth;
m_sourceHeight = picture.iHeight;
m_renderOrientation = orientation;
m_iFlags = GetFlagsChromaPosition(picture.chroma_position) |
GetFlagsColorMatrix(picture.color_space, picture.iWidth, picture.iHeight) |
GetFlagsColorPrimaries(picture.color_primaries) |
GetFlagsStereoMode(picture.stereoMode);
// Calculate the input frame aspect ratio.
CalculateFrameAspectRatio(picture.iDisplayWidth, picture.iDisplayHeight);
SetViewMode(m_videoSettings.m_ViewMode);
ManageRenderArea();
Reset();
m_bConfigured = true;
return true;
}
void CRendererMediaCodecSurface::RenderUpdate(int index, int index2, bool clear, unsigned int flags, unsigned int alpha)
{
m_bConfigured = true;
// this hack is needed to get the 2D mode of a 3D movie going
RENDER_STEREO_MODE stereo_mode = CServiceBroker::GetWinSystem()->GetGfxContext().GetStereoMode();
if (stereo_mode)
CServiceBroker::GetWinSystem()->GetGfxContext().SetStereoView(RENDER_STEREO_VIEW_LEFT);
ManageRenderArea();
if (stereo_mode)
CServiceBroker::GetWinSystem()->GetGfxContext().SetStereoView(RENDER_STEREO_VIEW_OFF);
m_surfDestRect = m_destRect;
switch (stereo_mode)
{
case RENDER_STEREO_MODE_SPLIT_HORIZONTAL:
m_surfDestRect.y2 *= 2.0;
break;
case RENDER_STEREO_MODE_SPLIT_VERTICAL:
m_surfDestRect.x2 *= 2.0;
break;
case RENDER_STEREO_MODE_MONO:
if (CONF_FLAGS_STEREO_MODE_MASK(m_iFlags) == CONF_FLAGS_STEREO_MODE_TAB)
m_surfDestRect.y2 = m_surfDestRect.y2 * 2.0;
else
m_surfDestRect.x2 = m_surfDestRect.x2 * 2.0;
break;
default:
break;
}
if (index != m_lastIndex)
{
ReleaseVideoBuffer(index, true);
m_lastIndex = index;
}
}
void CRendererMediaCodecSurface::RenderUpdate(int index, int index2, bool clear, unsigned int flags, unsigned int alpha)
{
CXBMCApp::get()->WaitVSync(100);
ManageRenderArea();
m_bConfigured = 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 CRendererMediaCodecSurface::RenderHook(int index)
{
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
CDVDMediaCodecInfo *mci = static_cast<CDVDMediaCodecInfo *>(m_buffers[index].hwDec);
if (mci && !mci->IsReleased())
{
// this hack is needed to get the 2D mode of a 3D movie going
RENDER_STEREO_MODE stereo_mode = g_graphicsContext.GetStereoMode();
if (stereo_mode)
g_graphicsContext.SetStereoView(RENDER_STEREO_VIEW_LEFT);
ManageRenderArea();
if (stereo_mode)
g_graphicsContext.SetStereoView(RENDER_STEREO_VIEW_OFF);
CRect dstRect(m_destRect);
CRect srcRect(m_sourceRect);
switch (stereo_mode)
{
case RENDER_STEREO_MODE_SPLIT_HORIZONTAL:
dstRect.y2 *= 2.0;
srcRect.y2 *= 2.0;
break;
case RENDER_STEREO_MODE_SPLIT_VERTICAL:
dstRect.x2 *= 2.0;
srcRect.x2 *= 2.0;
break;
default:
break;
}
// Handle orientation
switch (m_renderOrientation)
{
case 90:
case 270:
{
int diffX = 0;
int diffY = 0;
int centerX = 0;
int centerY = 0;
int newWidth = dstRect.Height(); // new width is old height
int newHeight = dstRect.Width(); // new height is old width
int diffWidth = newWidth - dstRect.Width(); // difference between old and new width
int diffHeight = newHeight - dstRect.Height(); // difference between old and new height
// if the new width is bigger then the old or
// the new height is bigger then the old - we need to scale down
if (diffWidth > 0 || diffHeight > 0 )
{
float aspectRatio = GetAspectRatio();
// scale to fit screen width because
// the difference in width is bigger then the
// difference in height
if (diffWidth > diffHeight)
{
newWidth = dstRect.Width(); // clamp to the width of the old dest rect
newHeight *= aspectRatio;
}
else // scale to fit screen height
{
newHeight = dstRect.Height(); // clamp to the height of the old dest rect
newWidth /= aspectRatio;
}
}
// calculate the center point of the view
centerX = m_viewRect.x1 + m_viewRect.Width() / 2;
centerY = m_viewRect.y1 + m_viewRect.Height() / 2;
// calculate the number of pixels we need to go in each
// x direction from the center point
diffX = newWidth / 2;
// calculate the number of pixels we need to go in each
// y direction from the center point
diffY = newHeight / 2;
dstRect = CRect(centerX - diffX, centerY - diffY, centerX + diffX, centerY + diffY);
break;
}
default:
break;
}
mci->RenderUpdate(srcRect, dstRect);
}
return true;
}
