mythvideoout.cpp

Go to the documentation of this file.

// MythTV
#include "osd.h"
#include "mythplayer.h"
#include "videodisplayprofile.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"
#ifdef _WIN32
#include "videoout_d3d.h"
#endif
#ifdef USING_OPENGL
#include "mythvideooutopengl.h"
#endif
#include "mythvideooutnull.h"
#include "mythvideoout.h"

// std
#include <cmath>
#include <cstdlib>

#define LOC QString("VideoOutput: ")

void MythVideoOutput::GetRenderOptions(RenderOptions &Options)
{
    MythVideoOutputNull::GetRenderOptions(Options);

#ifdef _WIN32
    VideoOutputD3D::GetRenderOptions(Options);
#endif

#ifdef USING_OPENGL
    MythVideoOutputOpenGL::GetRenderOptions(Options);
#endif // USING_OPENGL
}

MythVideoOutput *MythVideoOutput::Create(const QString &Decoder,    MythCodecID CodecID,
                                 PIPState PiPState,         const QSize &VideoDim,
                                 const QSize &VideoDispDim, float VideoAspect,
                                 QWidget *ParentWidget,     const QRect &EmbedRect,
                                 float FrameRate,           uint  PlayerFlags,
                                 QString &Codec,            int ReferenceFrames)
{
    QStringList renderers;

    // select the best available output
    if (PlayerFlags & kVideoIsNull)
    {
        // plain null output
        renderers += "null";
    }
    else
    {
#ifdef _WIN32
        renderers += VideoOutputD3D::GetAllowedRenderers(CodecID, VideoDispDim);
#endif

#ifdef USING_OPENGL
        renderers += MythVideoOutputOpenGL::GetAllowedRenderers(CodecID, VideoDispDim);
#endif // USING_OPENGL
    }

    LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("Allowed renderers: %1").arg(renderers.join(",")));
    renderers = VideoDisplayProfile::GetFilteredRenderers(Decoder, renderers);
    LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("Allowed renderers (filt: %1): %2")
        .arg(Decoder).arg(renderers.join(",")));

    QString renderer;

    auto *vprof = new VideoDisplayProfile();

    if (!renderers.empty())
    {
        vprof->SetInput(VideoDispDim, FrameRate, Codec);
        QString tmp = vprof->GetVideoRenderer();
        if (vprof->IsDecoderCompatible(Decoder) && renderers.contains(tmp))
        {
            renderer = tmp;
            LOG(VB_PLAYBACK, LOG_INFO, LOC + "Preferred renderer: " + renderer);
        }
    }

    if (renderer.isEmpty())
        renderer = VideoDisplayProfile::GetBestVideoRenderer(renderers);

    while (!renderers.empty())
    {
        LOG(VB_PLAYBACK, LOG_INFO, LOC +
            QString("Trying video renderer: '%1'").arg(renderer));
        int index = renderers.indexOf(renderer);
        if (index >= 0)
            renderers.removeAt(index);
        else
            break;

        MythVideoOutput *vo = nullptr;

        /* these cases are mutually exlusive */
        if (renderer == "null")
        {
            vo = new MythVideoOutputNull();
        }

#ifdef _WIN32
        else if (renderer == "direct3d")
        {
            vo = new VideoOutputD3D();
        }
#endif // _WIN32

#ifdef USING_OPENGL
        else if (renderer.contains("opengl"))
        {
            vo = new MythVideoOutputOpenGL(renderer);
        }
#endif // USING_OPENGL

        if (vo)
            vo->m_dbDisplayProfile = vprof;

        if (vo && !(PlayerFlags & kVideoIsNull))
        {
            // ensure we have a window to display into
            QWidget *widget = ParentWidget;
            MythMainWindow *window = GetMythMainWindow();
            if (!widget && window)
                widget = window->findChild<QWidget*>("video playback window");

            if (!widget)
            {
                LOG(VB_GENERAL, LOG_ERR, LOC + "No window for video output.");
                delete vo;
                vo = nullptr;
                return nullptr;
            }

            if (!widget->winId())
            {
                LOG(VB_GENERAL, LOG_ERR, LOC + "No window for video output.");
                delete vo;
                vo = nullptr;
                return nullptr;
            }

            // determine the display rectangle
            QRect display_rect = QRect(0, 0, widget->width(), widget->height());
            if (PiPState == kPIPStandAlone)
                display_rect = EmbedRect;

            vo->SetPIPState(PiPState);
            vo->SetVideoFrameRate(FrameRate);
            vo->SetReferenceFrames(ReferenceFrames);
            if (vo->Init(VideoDim, VideoDispDim, VideoAspect,
                         MythDisplay::AcquireRelease(), display_rect, CodecID))
            {
                vo->SetVideoScalingAllowed(true);
                return vo;
            }

            vo->m_dbDisplayProfile = nullptr;
            delete vo;
            vo = nullptr;
        }
        else if (vo && (PlayerFlags & kVideoIsNull))
        {
            if (vo->Init(VideoDim, VideoDispDim, VideoAspect, nullptr, QRect(), CodecID))
                return vo;

            vo->m_dbDisplayProfile = nullptr;
            delete vo;
            vo = nullptr;
        }

        renderer = VideoDisplayProfile::GetBestVideoRenderer(renderers);
    }

    LOG(VB_GENERAL, LOG_ERR, LOC +
        "Not compiled with any useable video output method.");
    delete vprof;
    return nullptr;
}

MythVideoOutput::MythVideoOutput()
  : m_display(nullptr)
{
    m_dbAspectOverride  = static_cast<AspectOverrideMode>(gCoreContext->GetNumSetting("AspectOverride", 0));
    m_dbAdjustFill      = static_cast<AdjustFillMode>(gCoreContext->GetNumSetting("AdjustFill", 0));
    m_dbLetterboxColour = static_cast<LetterBoxColour>(gCoreContext->GetNumSetting("LetterboxColour", 0));
}

MythVideoOutput::~MythVideoOutput()
{
    delete m_dbDisplayProfile;
    if (m_display)
        MythDisplay::AcquireRelease(false);
}

bool MythVideoOutput::Init(const QSize &VideoDim, const QSize &VideoDispDim,
                           float VideoAspect, MythDisplay *Display,
                           const QRect &WindowRect, MythCodecID CodecID)
{
    m_display = Display;
    m_videoCodecID = CodecID;
    bool wasembedding = m_window.IsEmbedding();
    QRect oldrect;
    if (wasembedding)
    {
        oldrect = m_window.GetEmbeddingRect();
        StopEmbedding();
    }

    bool mainSuccess = m_window.Init(VideoDim, VideoDispDim,
                                     VideoAspect, WindowRect,
                                     m_dbAspectOverride, m_dbAdjustFill,
                                     m_display);

    if (m_dbDisplayProfile)
        m_dbDisplayProfile->SetInput(m_window.GetVideoDispDim());

    if (wasembedding)
        EmbedInWidget(oldrect);

    VideoAspectRatioChanged(VideoAspect); // apply aspect ratio and letterbox mode

    return mainSuccess;
}

void MythVideoOutput::SetVideoFrameRate(float playback_fps)
{
    if (m_dbDisplayProfile)
        m_dbDisplayProfile->SetOutput(playback_fps);
}

void MythVideoOutput::SetReferenceFrames(int ReferenceFrames)
{
    m_maxReferenceFrames = ReferenceFrames;
}

MythDeintType MythVideoOutput::ParseDeinterlacer(const QString &Deinterlacer)
{
    MythDeintType result = DEINT_NONE;

    if (Deinterlacer.contains(DEINT_QUALITY_HIGH))
        result = DEINT_HIGH;
    else if (Deinterlacer.contains(DEINT_QUALITY_MEDIUM))
        result = DEINT_MEDIUM;
    else if (Deinterlacer.contains(DEINT_QUALITY_LOW))
        result = DEINT_BASIC;

    if (result != DEINT_NONE)
    {
        result = result | DEINT_CPU; // NB always assumed
        if (Deinterlacer.contains(DEINT_QUALITY_SHADER))
            result = result | DEINT_SHADER;
        if (Deinterlacer.contains(DEINT_QUALITY_DRIVER))
            result = result | DEINT_DRIVER;
    }

    return result;
}

void MythVideoOutput::SetDeinterlacing(bool Enable, bool DoubleRate, MythDeintType Force /*=DEINT_NONE*/)
{
    if (!Enable)
    {
        m_videoBuffers.SetDeinterlacing(DEINT_NONE, DEINT_NONE, m_videoCodecID);
        LOG(VB_PLAYBACK, LOG_INFO, LOC + "Disabled all deinterlacing");
        return;
    }

    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_dbDisplayProfile)
    {
        singlerate = ParseDeinterlacer(m_dbDisplayProfile->GetSingleRatePreferences());
        if (DoubleRate)
            doublerate = ParseDeinterlacer(m_dbDisplayProfile->GetDoubleRatePreferences());
    }

    LOG(VB_GENERAL, LOG_INFO, LOC + QString("SetDeinterlacing (Doublerate %1): Single %2 Double %3")
        .arg(DoubleRate).arg(DeinterlacerPref(singlerate)).arg(DeinterlacerPref(doublerate)));
    m_videoBuffers.SetDeinterlacing(singlerate, doublerate, m_videoCodecID);
}

void MythVideoOutput::VideoAspectRatioChanged(float VideoAspect)
{
    m_window.VideoAspectRatioChanged(VideoAspect);
}

bool MythVideoOutput::InputChanged(const QSize &VideoDim, const QSize &VideoDispDim,
                                   float VideoAspect, MythCodecID  CodecID,
                                   bool  &/*AspectOnly*/, MythMultiLocker* /*Locks*/,
                                   int   ReferenceFrames, bool /*ForceChange*/)
{
    m_window.InputChanged(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_dbDisplayProfile)
        m_dbDisplayProfile->SetInput(m_window.GetVideoDispDim(), 0 ,codecName);
    m_videoCodecID = CodecID;
    DiscardFrames(true, true);
    return true;
}
void MythVideoOutput::ResizeDisplayWindow(const QRect &Rect, bool SaveVisible)
{
    m_window.ResizeDisplayWindow(Rect, SaveVisible);
}

void MythVideoOutput::EmbedInWidget(const QRect &EmbedRect)
{
    m_window.EmbedInWidget(EmbedRect);
}

void MythVideoOutput::StopEmbedding(void)
{
    m_window.StopEmbedding();
}

void MythVideoOutput::GetOSDBounds(QRect &Total, QRect &Visible,
                                   float &VisibleAspect,
                                   float &FontScaling,
                                   float ThemeAspect) const
{
    Total = GetTotalOSDBounds();
    Visible = GetVisibleOSDBounds(VisibleAspect, FontScaling, ThemeAspect);
}

QRect MythVideoOutput::GetVisibleOSDBounds(float &VisibleAspect,
                                           float &FontScaling,
                                           float ThemeAspect) const
{
    QRect dvr = m_window.GetDisplayVisibleRect();
    float dispPixelAdj = 1.0F;
    if (dvr.height() && dvr.width())
        dispPixelAdj = (m_window.GetDisplayAspect() * dvr.height()) / dvr.width();

    float ova = m_window.GetOverridenVideoAspect();
    QRect vr = m_window.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() };
}

QRect MythVideoOutput::GetTotalOSDBounds(void) const
{
    return m_window.GetDisplayVisibleRect();
}

QRect MythVideoOutput::GetMHEGBounds(void)
{
    return m_window.GetDisplayVideoRect();
}

void MythVideoOutput::MoveResize(void)
{
    m_window.MoveResize();
}

void MythVideoOutput::Zoom(ZoomDirection Direction)
{
    m_window.Zoom(Direction);
}

void MythVideoOutput::ToggleMoveBottomLine(void)
{
    m_window.ToggleMoveBottomLine();
}

void MythVideoOutput::SaveBottomLine(void)
{
    m_window.SaveBottomLine();
}

void MythVideoOutput::ToggleAspectOverride(AspectOverrideMode AspectMode)
{
    m_window.ToggleAspectOverride(AspectMode);
}

void MythVideoOutput::ToggleAdjustFill(AdjustFillMode FillMode)
{
    m_window.ToggleAdjustFill(FillMode);
}

QString MythVideoOutput::GetZoomString(void) const
{
    return m_window.GetZoomString();
}

PictureAttributeSupported MythVideoOutput::GetSupportedPictureAttributes(void)
{
    return m_videoColourSpace.SupportedAttributes();
}

int MythVideoOutput::ChangePictureAttribute(PictureAttribute AttributeType, bool Direction)
{
    int curVal = GetPictureAttribute(AttributeType);
    if (curVal < 0)
        return -1;

    int newVal = curVal + ((Direction) ? +1 : -1);

    if (kPictureAttribute_Hue == AttributeType)
        newVal = newVal % 100;

    if ((kPictureAttribute_Range == AttributeType) && newVal > 1)
        newVal = 1;

    newVal = min(max(newVal, 0), 100);

    return SetPictureAttribute(AttributeType, newVal);
}

int MythVideoOutput::SetPictureAttribute(PictureAttribute Attribute, int NewValue)
{
    return m_videoColourSpace.SetPictureAttribute(Attribute, NewValue);
}

int MythVideoOutput::GetPictureAttribute(PictureAttribute AttributeType)
{
    return m_videoColourSpace.GetPictureAttribute(AttributeType);
}

void MythVideoOutput::SetFramesPlayed(long long FramesPlayed)
{
    m_framesPlayed = FramesPlayed;
}

long long MythVideoOutput::GetFramesPlayed(void)
{
    return m_framesPlayed;
}

bool MythVideoOutput::IsErrored(void) const
{
    return m_errorState != kError_None;
}

VideoErrorState MythVideoOutput::GetError(void) const
{
    return m_errorState;
}

void MythVideoOutput::SetPrebuffering(bool Normal)
{
    m_videoBuffers.SetPrebuffering(Normal);
}

void MythVideoOutput::ClearAfterSeek(void)
{
    m_videoBuffers.ClearAfterSeek();
}

int MythVideoOutput::ValidVideoFrames(void) const
{
    return static_cast<int>(m_videoBuffers.ValidVideoFrames());
}

int MythVideoOutput::FreeVideoFrames(void)
{
    return static_cast<int>(m_videoBuffers.FreeVideoFrames());
}

bool MythVideoOutput::EnoughFreeFrames(void)
{
    return m_videoBuffers.EnoughFreeFrames();
}

bool MythVideoOutput::EnoughDecodedFrames(void)
{
    return m_videoBuffers.EnoughDecodedFrames();
}

QRect MythVideoOutput::GetPIPRect(PIPLocation Location, MythPlayer *PiPPlayer, bool DoPixelAdj) const
{
    return m_window.GetPIPRect(Location, PiPPlayer, DoPixelAdj);
}

void MythVideoOutput::ShowPIPs(VideoFrame *Frame, const PIPMap &PiPPlayers)
{
    for (auto it = PiPPlayers.cbegin(); it != PiPPlayers.cend(); ++it)
        ShowPIP(Frame, it.key(), *it);
}

AspectOverrideMode MythVideoOutput::GetAspectOverride(void) const
{
    return m_window.GetAspectOverride();
}

AdjustFillMode MythVideoOutput::GetAdjustFill(void) const
{
    return m_window.GetAdjustFill();
}

VideoFrame* MythVideoOutput::GetLastDecodedFrame(void)
{
    return m_videoBuffers.GetLastDecodedFrame();
}

QString MythVideoOutput::GetFrameStatus(void) const
{
    return m_videoBuffers.GetStatus();
}

VideoFrame* MythVideoOutput::GetLastShownFrame(void)
{
    return m_videoBuffers.GetLastShownFrame();
}

void MythVideoOutput::SetVideoResize(const QRect &VideoRect)
{
    m_window.SetITVResize(VideoRect);
}

void MythVideoOutput::SetVideoScalingAllowed(bool Allow)
{
    m_window.SetVideoScalingAllowed(Allow);
}

bool MythVideoOutput::EnableVisualisation(AudioPlayer *Audio, bool Enable,
                                      const QString &Name)
{
    if (!Enable)
    {
        DestroyVisualisation();
        return false;
    }
    return SetupVisualisation(Audio, nullptr, Name);
}

bool MythVideoOutput::CanVisualise(AudioPlayer *Audio, MythRender *Render)
{
    return VideoVisual::CanVisualise(Audio, Render);
}

bool MythVideoOutput::SetupVisualisation(AudioPlayer *Audio, MythRender *Render,
                                     const QString &Name)
{
    DestroyVisualisation();
    m_visual = VideoVisual::Create(Name, Audio, Render);
    return m_visual;
}

QString MythVideoOutput::GetVisualiserName(void)
{
    if (m_visual)
        return m_visual->Name();
    return QString("");
}

QStringList MythVideoOutput::GetVisualiserList(void)
{
    return QStringList();
}

void MythVideoOutput::DestroyVisualisation(void)
{
    delete m_visual;
    m_visual = nullptr;
}

void MythVideoOutput::CopyFrame(VideoFrame *To, const VideoFrame *From)
{
    if (To == nullptr || From == nullptr)
        return;

    To->frameNumber = From->frameNumber;
    To->disp_timecode = From->disp_timecode;
    To->frameCounter = From->frameCounter;

    copy(To, From);
}

QRect MythVideoOutput::GetImageRect(const QRect &Rect, QRect *DisplayRect)
{
    qreal hscale = 0.0;
    QSize video_size   = m_window.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())
    {
        QMatrix 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 = m_window.GetDisplayVideoRect();
    QRect vid_rec = m_window.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;
    QMatrix 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();
    QMatrix 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(void)
{
    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) };
}

void MythVideoOutput::SetPIPState(PIPState Setting)
{
    m_window.SetPIPState(Setting);
}

VideoFrameType* MythVideoOutput::DirectRenderFormats(void)
{
    static VideoFrameType s_defaultFormats[] = { FMT_YV12, FMT_NONE };
    return &s_defaultFormats[0];
}

VideoFrame* MythVideoOutput::GetNextFreeFrame(void)
{
    return m_videoBuffers.GetNextFreeFrame();
}

void MythVideoOutput::ReleaseFrame(VideoFrame *Frame)
{
    m_videoBuffers.ReleaseFrame(Frame);
}

void MythVideoOutput::DeLimboFrame(VideoFrame *Frame)
{
    m_videoBuffers.DeLimboFrame(Frame);
}

bool MythVideoOutput::IsEmbedding(void)
{
    return m_window.IsEmbedding();
}

void MythVideoOutput::StartDisplayingFrame(void)
{
    m_videoBuffers.StartDisplayingFrame();
}

void MythVideoOutput::DoneDisplayingFrame(VideoFrame *Frame)
{
    m_videoBuffers.DoneDisplayingFrame(Frame);
}

void MythVideoOutput::DiscardFrame(VideoFrame *Frame)
{
    m_videoBuffers.DiscardFrame(Frame);
}

void MythVideoOutput::DiscardFrames(bool KeyFrame, bool /*Flushed*/)
{
    m_videoBuffers.DiscardFrames(KeyFrame);
}

void MythVideoOutput::ResizeForVideo(QSize Size)
{
    if (!m_display)
        return;
    if (!m_display->UsingVideoModes())
        return;

    if (Size.isEmpty())
    {
        Size = m_window.GetVideoDispDim();
        if (Size.isEmpty())
            return;
    }

    float rate = m_dbDisplayProfile ? m_dbDisplayProfile->GetOutput() : 0.0F;

    bool hide = m_display->NextModeIsLarger(Size);
    MythMainWindow* window = GetMythMainWindow();
    if (hide)
        window->hide();

    if (m_display->SwitchToVideo(Size, static_cast<double>(rate)))
    {
        // Switching to custom display resolution succeeded
        // Make a note of the new size
        QString source;
        double aspect = m_display->GetAspectRatio(source);
        LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("Aspect ratio: %1 (%2)")
            .arg(aspect).arg(source));
        m_window.SetDisplayAspect(static_cast<float>(aspect));
        m_window.SetWindowSize(m_display->GetResolution());

        bool fullscreen = !m_window.UsingGuiSize();

        // if width && height are zero users expect fullscreen playback
        if (!fullscreen)
        {
            int gui_width = 0;
            int gui_height = 0;
            gCoreContext->GetResolutionSetting("Gui", gui_width, gui_height);
            fullscreen |= (0 == gui_width && 0 == gui_height);
        }

        if (fullscreen)
        {
            QSize sz = m_display->GetResolution();
            QRect display_visible_rect = QRect(GetMythMainWindow()->geometry().topLeft(), sz);
            if (HasMythMainWindow())
            {
                if (hide)
                {
                    window->Show();
                    hide = false;
                }
                GetMythMainWindow()->MoveResize(display_visible_rect);
            }
        }
    }
    if (hide)
        window->Show();
}

void MythVideoOutput::InitDisplayMeasurements(void)
{
    if (!m_display)
        return;

    // Retrieve the display aspect ratio.
    // This will be, in priority order:-
    // - aspect ratio override when using resolution/mode switching (if not 'Default')
    // - aspect ratio override for setups where detection does not work/is broken (multiscreen, broken EDID etc)
    // - aspect ratio based on detected physical size (this should be the common/default value)
    // - aspect ratio fallback using screen resolution
    // - 16:9
    QString source;
    double displayaspect = m_display->GetAspectRatio(source);
    LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("Display aspect ratio: %1 (%2)")
        .arg(displayaspect).arg(source));

    // Get the window and screen resolutions
    QSize window = m_window.GetWindowRect().size();
    QSize screen = m_display->GetResolution();

    // If not running fullscreen, adjust for window size and ignore any video
    // mode overrides as they do not apply when in a window
    if (!window.isEmpty() && !screen.isEmpty() && window != screen)
    {
        displayaspect = m_display->GetAspectRatio(source, true);
        double screenaspect = screen.width() / static_cast<double>(screen.height());
        double windowaspect = window.width() / static_cast<double>(window.height());
        displayaspect = displayaspect * (1.0 / screenaspect) * windowaspect;
        LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("Window aspect ratio: %1").arg(displayaspect));
    }

    m_window.SetDisplayAspect(static_cast<float>(displayaspect));
}

int MythVideoOutput::CalcHueBase(const QString &AdaptorName)
{
    int defaulthue = 50;

    QString lower = AdaptorName.toLower();
    // Hue base for different adaptors
    // This can probably now be removed as it is only relevant to VAAPI
    // which always uses 50
    if (lower.contains("radeon") ||
        lower.contains("g3d") ||
        lower.contains("xvba") /* VAAPI */ ||
        lower.startsWith("intel") ||
        lower.contains("splitted"))
    {
        defaulthue = 50;
    }
    else if (lower.startsWith("nv17")) /* nVidia */
    {
        defaulthue = 0;
    }
    else
    {
        LOG(VB_GENERAL, LOG_INFO, LOC +
            QString("CalcHueBase(%1): Unknown adaptor, hue may be wrong.")
            .arg(AdaptorName));
    }

    return defaulthue;
}