mythdisplayosx.cpp

Go to the documentation of this file.

// MythTV
#include "config.h"
#include "mythcorecontext.h"
#include "mythmainwindow.h"
#include "mythdisplayosx.h"
#import  "mythosxutils.h"
#import  "mythutilscocoa.h"

#define LOC QString("DisplayOSX: ")

MythDisplayOSX::MythDisplayOSX()
  : MythDisplay()
{
    Initialise();
}

MythDisplayOSX::~MythDisplayOSX()
{
    ClearModes();
}

void MythDisplayOSX::UpdateCurrentMode(void)
{
    QWidget* widget = m_widget;

    if (!widget)
    {
        if (!HasMythMainWindow())
        {
            MythDisplay::UpdateCurrentMode();
            return;
        }
        widget = qobject_cast<QWidget*>(MythMainWindow::getMainWindow());
    }

    CGDirectDisplayID disp = GetOSXDisplay(widget->winId());
    if (!disp)
    {
        MythDisplay::UpdateCurrentMode();
        return;
    }
    CGDisplayModeRef mode = CGDisplayCopyDisplayMode(disp);
    if (!mode)
    {
        MythDisplay::UpdateCurrentMode();
        return;
    }

    m_modeComplete = true;
    m_refreshRate = CGDisplayModeGetRefreshRate(mode);
    m_resolution  = QSize(static_cast<int>(CGDisplayModeGetWidth(mode)),
                          static_cast<int>(CGDisplayModeGetHeight(mode)));
    QByteArray edid = GetOSXEDID(disp);
    m_edid = MythEDID(edid);
    //bool interlaced = CGDisplayModeGetIOFlags(mode) & kDisplayModeInterlacedFlag;
    CGDisplayModeRelease(mode);
    CGSize sizemm = CGDisplayScreenSize(disp);
    m_physicalSize = QSize(static_cast<int>(sizemm.width), static_cast<int>(sizemm.height));
}

bool MythDisplayOSX::UsingVideoModes(void)
{
    if (gCoreContext)
        return gCoreContext->GetBoolSetting("UseVideoModes", false);
    return false;
}

const std::vector<MythDisplayMode>& MythDisplayOSX::GetVideoModes(void)
{
    if (!m_videoModes.empty() || !HasMythMainWindow())
        return m_videoModes;

    ClearModes();

    WId win = (qobject_cast<QWidget*>(MythMainWindow::getMainWindow()))->winId();
    CGDirectDisplayID disp = GetOSXDisplay(win);
    if (!disp)
        return m_videoModes;
    CFArrayRef modes = CGDisplayCopyAllDisplayModes(disp, nullptr);
    if (!modes)
        return m_videoModes;

    DisplayModeMap screen_map;
    CGSize sizemm = CGDisplayScreenSize(disp);

    for (int i = 0; i < CFArrayGetCount(modes); ++i)
    {
        CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(modes, i);
        double rate     = CGDisplayModeGetRefreshRate(mode);
        bool interlaced = CGDisplayModeGetIOFlags(mode) & kDisplayModeInterlacedFlag;
        int width       = static_cast<int>(CGDisplayModeGetWidth(mode));
        int height      = static_cast<int>(CGDisplayModeGetHeight(mode));

        // See note in MythDisplayX11
        if (interlaced)
        {
            LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("Ignoring interlaced mode %1x%2 %3i")
                .arg(width).arg(height).arg(rate, 2, 'f', 2, '0'));
            continue;
        }

        QSize resolution(width, height);
        uint64_t key = MythDisplayMode::CalcKey(resolution, 0.0);
        if (screen_map.find(key) == screen_map.end())
            screen_map[key] = MythDisplayMode(resolution, QSize(sizemm.width, sizemm.height),
                                              -1.0, rate);
        else
            screen_map[key].AddRefreshRate(rate);
        m_modeMap.insert(MythDisplayMode::CalcKey(resolution, rate), CGDisplayModeRetain(mode));
    }

    CFRelease(modes);

    for (auto it = screen_map.begin(); screen_map.end() != it; ++it)
        m_videoModes.push_back(it->second);
    DebugModes();
    return m_videoModes;
}

bool MythDisplayOSX::SwitchToVideoMode(QSize Size, double DesiredRate)
{
    if (!HasMythMainWindow())
        return false;
    WId win = (qobject_cast<QWidget*>(MythMainWindow::getMainWindow()))->winId();
    CGDirectDisplayID disp = GetOSXDisplay(win);
    if (!disp)
        return false;

    auto rate = static_cast<double>(NAN);
    MythDisplayMode desired(Size, QSize(0, 0), -1.0, DesiredRate);
    int idx = MythDisplayMode::FindBestMatch(m_videoModes, desired, rate);
    if (idx < 0)
    {
        LOG(VB_GENERAL, LOG_ERR, LOC + "Desired resolution and frame rate not found.");
        return false;
    }

    auto mode = MythDisplayMode::CalcKey(Size, rate);
    if (!m_modeMap.contains(mode))
    {
        LOG(VB_GENERAL, LOG_ERR, LOC + "Failed to find mode");
        return false;
    }

    // switch mode and return success
    CGDisplayCapture(disp);
    CGDisplayConfigRef cfg;
    CGBeginDisplayConfiguration(&cfg);
    CGConfigureDisplayFadeEffect(cfg, 0.3f, 0.5f, 0, 0, 0);
    CGDisplaySetDisplayMode(disp, m_modeMap.value(mode), nullptr);
    CGError err = CGCompleteDisplayConfiguration(cfg, kCGConfigureForAppOnly);
    CGDisplayRelease(disp);
    return err == kCGErrorSuccess;
}

void MythDisplayOSX::ClearModes(void)
{
    for (auto it = m_modeMap.cbegin(); it != m_modeMap.cend(); ++it)
        CGDisplayModeRelease(it.value());
    m_modeMap.clear();
    m_videoModes.clear();
}