mythvideoout.cpp

Go to the documentation of this file.

// MythTV
#include "osd.h"
#include "mythplayer.h"
#include "mythvideoprofile.h"
#include "decoderbase.h"
#include "mythcorecontext.h"
#include "mythlogging.h"
#include "mythmainwindow.h"
#include "mythuihelper.h"
#include "mythavutil.h"
#include "mthreadpool.h"
#include "mythcodeccontext.h"
#include "mythvideooutnull.h"
#include "mythvideooutgpu.h"
#include "mythvideoout.h"
 
// std
#include <cmath>
#include <cstdlib>
 
#define LOC QString("VideoOutput: ")
 
void MythVideoOutput::GetRenderOptions(RenderOptions& Options, MythRender* Render)
{
    MythVideoOutputNull::GetRenderOptions(Options);
    MythVideoOutputGPU::GetRenderOptions(Options, Render);
}
 
MythVideoOutput::MythVideoOutput()
{
    m_dbLetterboxColour = static_cast<LetterBoxColour>(gCoreContext->GetNumSetting("LetterboxColour", 0));
    m_clearColor = m_dbLetterboxColour == kLetterBoxColour_Gray25 ? 64 : 0;
}
 
bool MythVideoOutput::Init(const QSize VideoDim, const QSize VideoDispDim,
                           float VideoAspect, const QRect WindowRect, MythCodecID CodecID)
{
    m_videoCodecID = CodecID;
    bool wasembedding = IsEmbedding();
    QRect oldrect;
    if (wasembedding)
    {
        oldrect = GetEmbeddingRect();
        EmbedPlayback(false, {});
    }
 
    bool mainSuccess = InitBounds(VideoDim, VideoDispDim, VideoAspect, WindowRect);
 
    if (m_videoProfile)
        m_videoProfile->SetInput(GetVideoDispDim());
 
    if (wasembedding)
        EmbedPlayback(true, oldrect);
 
    VideoAspectRatioChanged(VideoAspect); // apply aspect ratio and letterbox mode
 
    return mainSuccess;
}
 
void MythVideoOutput::SetVideoFrameRate(float VideoFrameRate)
{
    if (m_videoProfile)
        m_videoProfile->SetOutput(VideoFrameRate);
}
 
void MythVideoOutput::SetDeinterlacing(bool Enable, bool DoubleRate, MythDeintType Force /*=DEINT_NONE*/)
{
 
 
    if (!Enable)
    {
        m_deinterlacing = false;
        m_deinterlacing2X = false;
        m_forcedDeinterlacer = DEINT_NONE;
        m_videoBuffers.SetDeinterlacing(DEINT_NONE, DEINT_NONE, m_videoCodecID);
        LOG(VB_PLAYBACK, LOG_INFO, LOC + "Disabled all deinterlacing");
        return;
    }
 
    m_deinterlacing   = Enable;
    m_deinterlacing2X = DoubleRate;
    m_forcedDeinterlacer = Force;
 
    MythDeintType singlerate = DEINT_NONE;
    MythDeintType doublerate = DEINT_NONE;
    if (DEINT_NONE != Force)
    {
        singlerate = Force;
        if (DoubleRate)
            doublerate = Force;
        LOG(VB_PLAYBACK, LOG_INFO, LOC + "Overriding deinterlacers");
    }
    else if (m_videoProfile)
    {
        singlerate = MythVideoFrame::ParseDeinterlacer(m_videoProfile->GetSingleRatePreferences());
        if (DoubleRate)
            doublerate = MythVideoFrame::ParseDeinterlacer(m_videoProfile->GetDoubleRatePreferences());
    }
 
    LOG(VB_GENERAL, LOG_INFO, LOC + QString("SetDeinterlacing (Doublerate %1): Single %2 Double %3")
        .arg(QString::number(DoubleRate),
             MythVideoFrame::DeinterlacerPref(singlerate),
             MythVideoFrame::DeinterlacerPref(doublerate)));
    m_videoBuffers.SetDeinterlacing(singlerate, doublerate, m_videoCodecID);
}
 
bool MythVideoOutput::InputChanged(const QSize VideoDim, const QSize VideoDispDim,
                                   float VideoAspect, MythCodecID  CodecID,
                                   bool& /*AspectOnly*/, int ReferenceFrames, bool /*ForceChange*/)
{
    SourceChanged(VideoDim, VideoDispDim, VideoAspect);
    m_maxReferenceFrames = ReferenceFrames;
    AVCodecID avCodecId = myth2av_codecid(CodecID);
    AVCodec* codec = avcodec_find_decoder(avCodecId);
    QString codecName;
    if (codec)
        codecName = codec->name;
    if (m_videoProfile)
        m_videoProfile->SetInput(GetVideoDispDim(), 0 ,codecName);
    m_videoCodecID = CodecID;
    DiscardFrames(true, true);
    // Update deinterlacers for any input change
    SetDeinterlacing(m_deinterlacing, m_deinterlacing2X, m_forcedDeinterlacer);
    return true;
}
 
void MythVideoOutput::GetOSDBounds(QRect& Total, QRect& Visible,
                                   float& VisibleAspect,
                                   float& FontScaling,
                                   float ThemeAspect) const
{
    Total   = GetDisplayVisibleRect();
    Visible = GetVisibleOSDBounds(VisibleAspect, FontScaling, ThemeAspect);
}
 
QRect MythVideoOutput::GetVisibleOSDBounds(float& VisibleAspect,
                                           float& FontScaling,
                                           float ThemeAspect) const
{
    QRect dvr = GetDisplayVisibleRect();
    float dispPixelAdj = 1.0F;
    if (dvr.height() && dvr.width())
        dispPixelAdj = (GetDisplayAspect() * dvr.height()) / dvr.width();
 
    float ova = GetOverridenVideoAspect();
    QRect vr = GetVideoRect();
    float vs = vr.height() ? static_cast<float>(vr.width()) / vr.height() : 1.0F;
    VisibleAspect = ThemeAspect * (ova > 0.0F ? vs / ova : 1.F) * dispPixelAdj;
 
    FontScaling = 1.0F;
    return { QPoint(0,0), dvr.size() };
}
 
PictureAttributeSupported MythVideoOutput::GetSupportedPictureAttributes()
{
    return m_videoColourSpace.SupportedAttributes();
}
 
void MythVideoOutput::SetFramesPlayed(long long FramesPlayed)
{
    m_framesPlayed = FramesPlayed;
}
 
long long MythVideoOutput::GetFramesPlayed()
{
    return m_framesPlayed;
}
 
bool MythVideoOutput::IsErrored() const
{
    return m_errorState != kError_None;
}
 
VideoErrorState MythVideoOutput::GetError() const
{
    return m_errorState;
}
 
void MythVideoOutput::SetPrebuffering(bool Normal)
{
    m_videoBuffers.SetPrebuffering(Normal);
}
 
void MythVideoOutput::ClearAfterSeek()
{
    m_videoBuffers.ClearAfterSeek();
}
 
int MythVideoOutput::ValidVideoFrames() const
{
    return static_cast<int>(m_videoBuffers.ValidVideoFrames());
}
 
int MythVideoOutput::FreeVideoFrames()
{
    return static_cast<int>(m_videoBuffers.FreeVideoFrames());
}
 
bool MythVideoOutput::EnoughFreeFrames()
{
    return m_videoBuffers.EnoughFreeFrames();
}
 
bool MythVideoOutput::EnoughDecodedFrames()
{
    return m_videoBuffers.EnoughDecodedFrames();
}
 
MythVideoFrame* MythVideoOutput::GetLastDecodedFrame()
{
    return m_videoBuffers.GetLastDecodedFrame();
}
 
QString MythVideoOutput::GetFrameStatus() const
{
    return m_videoBuffers.GetStatus();
}
 
MythVideoFrame* MythVideoOutput::GetLastShownFrame()
{
    return m_videoBuffers.GetLastShownFrame();
}
 
QRect MythVideoOutput::GetImageRect(const QRect Rect, QRect* DisplayRect)
{
    qreal hscale = 0.0;
    QSize video_size   = GetVideoDispDim();
    int image_height   = video_size.height();
    int image_width    = (image_height > 720) ? 1920 :
                         (image_height > 576) ? 1280 : 720;
    qreal image_aspect = static_cast<qreal>(image_width) / image_height;
    qreal pixel_aspect = static_cast<qreal>(video_size.width()) / video_size.height();
 
    QRect rect1 = Rect;
    if (DisplayRect && DisplayRect->isValid())
    {
        QTransform m0;
        m0.scale(static_cast<qreal>(image_width)  / DisplayRect->width(),
                 static_cast<qreal>(image_height) / DisplayRect->height());
        rect1 = m0.mapRect(rect1);
        rect1.translate(DisplayRect->left(), DisplayRect->top());
    }
    QRect result = rect1;
 
    QRect dvr_rec = GetDisplayVideoRect();
    QRect vid_rec = GetVideoRect();
 
    hscale = image_aspect / pixel_aspect;
    if (hscale < 0.99 || hscale > 1.01)
    {
        vid_rec.setLeft(static_cast<int>(lround(static_cast<qreal>(vid_rec.left()) * hscale)));
        vid_rec.setWidth(static_cast<int>(lround(static_cast<qreal>(vid_rec.width()) * hscale)));
    }
 
    qreal vscale = static_cast<qreal>(dvr_rec.width()) / image_width;
    hscale = static_cast<qreal>(dvr_rec.height()) / image_height;
    QTransform m1;
    m1.translate(dvr_rec.left(), dvr_rec.top());
    m1.scale(vscale, hscale);
 
    vscale = static_cast<qreal>(image_width) / vid_rec.width();
    hscale = static_cast<qreal>(image_height) / vid_rec.height();
    QTransform m2;
    m2.scale(vscale, hscale);
    m2.translate(-vid_rec.left(), -vid_rec.top());
 
    result = m2.mapRect(result);
    result = m1.mapRect(result);
    return result;
}
 
QRect MythVideoOutput::GetSafeRect()
{
    static constexpr float kSafeMargin = 0.05F;
    float dummy = NAN;
    QRect result = GetVisibleOSDBounds(dummy, dummy, 1.0F);
    int safex = static_cast<int>(static_cast<float>(result.width())  * kSafeMargin);
    int safey = static_cast<int>(static_cast<float>(result.height()) * kSafeMargin);
    return { result.left() + safex, result.top() + safey,
             result.width() - (2 * safex), result.height() - (2 * safey) };
}
 
MythVideoFrame* MythVideoOutput::GetNextFreeFrame()
{
    return m_videoBuffers.GetNextFreeFrame();
}
 
void MythVideoOutput::ReleaseFrame(MythVideoFrame* Frame)
{
    m_videoBuffers.ReleaseFrame(Frame);
}
 
void MythVideoOutput::DeLimboFrame(MythVideoFrame* Frame)
{
    m_videoBuffers.DeLimboFrame(Frame);
}
 
void MythVideoOutput::StartDisplayingFrame()
{
    m_videoBuffers.StartDisplayingFrame();
}
 
void MythVideoOutput::DoneDisplayingFrame(MythVideoFrame* Frame)
{
    m_videoBuffers.DoneDisplayingFrame(Frame);
}
 
void MythVideoOutput::DiscardFrame(MythVideoFrame* Frame)
{
    m_videoBuffers.DiscardFrame(Frame);
}
 
void MythVideoOutput::DiscardFrames(bool KeyFrame, bool /*Flushed*/)
{
    m_videoBuffers.DiscardFrames(KeyFrame);
}