Ticket #13618: dpi2.diff

mythtv/libs/libmythtv/mythvideoout.cpp

@@ -1020 +1020 @@
         .arg(displayaspect).arg(source));
 
     // Get the window and screen resolutions
-    QSize window = m_window.GetWindowRect().size();
+    QSize window = m_window.GetWindowRect().size() / m_window.GetDevicePixelRatio();
     QSize screen = m_display->GetResolution();
 
     // If not running fullscreen, adjust for window size and ignore any video

mythtv/libs/libmythtv/videooutwindow.cpp

@@ -38 +38 @@
 
 #define LOC QString("VideoWin: ")
 
+
+#define SCALED_RECT(SRC, SCALE) (QRect(static_cast<int>(SRC.left()   * SCALE), \
+                                       static_cast<int>(SRC.top()    * SCALE), \
+                                       static_cast<int>(SRC.width()  * SCALE), \
+                                       static_cast<int>(SRC.height() * SCALE)))
 static float fix_aspect(float raw);
 static float snap(float value, float snapto, float diff);
 
@@ -63 +68 @@
     MoveResize();
 }
 
+void VideoOutWindow::PhysicalDPIChanged(qreal /*DPI*/)
+{
+    // FIXME - just feels wrong:)
+
+    // revert old device pixel ratio (noop for pixel ratio = 1.0)
+    m_windowRect = m_displayVisibleRect = SCALED_RECT(m_windowRect, 1.0 / m_devicePixelRatio);
+    PopulateGeometry();
+    // and apply new
+    m_windowRect = m_displayVisibleRect = SCALED_RECT(m_windowRect, m_devicePixelRatio);
+    MoveResize();
+}
+
 void VideoOutWindow::PopulateGeometry(void)
 {
     if (!m_display)
@@ -72 +89 @@
     if (!screen)
         return;
 
+    m_devicePixelRatio = screen->devicePixelRatio();
+
     if (MythDisplay::SpanAllScreens() && MythDisplay::GetScreenCount() > 1)
     {
         m_screenGeometry = screen->virtualGeometry();
@@ -416 +435 @@
     {
         m_display = Display;
         connect(m_display, &MythDisplay::CurrentScreenChanged, this, &VideoOutWindow::ScreenChanged);
+        connect(m_display, &MythDisplay::PhysicalDPIChanged,   this, &VideoOutWindow::PhysicalDPIChanged);
     }
 
     if (m_display)
@@ -429 +449 @@
 
     // N.B. we are always confined to the window size so use that for the initial
     // displayVisibleRect
-    m_windowRect = m_displayVisibleRect = WindowRect;
+    m_windowRect = m_displayVisibleRect = SCALED_RECT(WindowRect, m_devicePixelRatio);
 
     int pbp_width = m_displayVisibleRect.width() / 2;
     if (m_pipState == kPBPLeft || m_pipState == kPBPRight)
@@ -824 +844 @@
 }
 #endif
 
+qreal VideoOutWindow::GetDevicePixelRatio(void) const
+{
+    return m_devicePixelRatio;
+}
+
 /*
  * \brief Determines PIP Window size and Position.
  */

mythtv/libs/libmythtv/videooutwindow.h

@@ -45 +45 @@
 
   public slots:
     void ScreenChanged          (QScreen *screen);
+    void PhysicalDPIChanged     (qreal  /*DPI*/);
 
     // Sets
     void InputChanged           (const QSize &VideoDim, const QSize &VideoDispDim, float Aspect);
@@ -95 +96 @@
 #if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
     QRegion  GetBoundingRegion(void) const;
 #endif
+    qreal    GetDevicePixelRatio(void) const;
 
   private:
     void PopulateGeometry        (void);
@@ -115 +117 @@
     bool    m_dbScalingAllowed {true};  ///< disable this to prevent overscan/underscan
     bool    m_dbUseGUISize     {false}; ///< Use the gui size for video window
     QRect   m_screenGeometry   {0,0,1024,768}; ///< Full screen geometry
+    qreal   m_devicePixelRatio {1.0};
 
     // Manual Zoom
     float   m_manualVertScale  {1.0F}; ///< Manually applied vertical scaling.

mythtv/libs/libmythui/opengl/mythpainteropengl.cpp

@@ -109 +109 @@
             buf = m_render->CreateVBO(static_cast<int>(MythRenderOpenGL::kVertexSize));
     }
 
+    // check for high dpi
+    m_pixelRatio = m_parent->devicePixelRatioF();
+    QSize currentsize = m_parent->size() * m_pixelRatio;
+
     // check if we need to adjust cache sizes
-    if (m_lastSize != m_parent->size())
+    if (m_lastSize != currentsize)
     {
         // This will scale the cache depending on the resolution in use
         static const int s_onehd = 1920 * 1080;
         static const int s_basesize = 64;
-        m_lastSize = m_parent->size();
+        m_lastSize = currentsize;
         float hdscreens = (static_cast<float>(m_lastSize.width() + 1) * m_lastSize.height()) / s_onehd;
         int cpu = qMax(static_cast<int>(hdscreens * s_basesize), s_basesize);
         int gpu = cpu * 3 / 2;
@@ -131 +135 @@
     if (m_target || m_swapControl)
     {
         m_render->BindFramebuffer(m_target);
-        m_render->SetViewPort(QRect(0, 0, m_parent->width(), m_parent->height()));
+        m_render->SetViewPort(QRect(0, 0, m_lastSize.width(), m_lastSize.height()));
         m_render->SetBackground(0, 0, 0, 0);
         m_render->ClearFramebuffer();
     }
@@ -221 +225 @@
     return texture;
 }
 
+#define SCALED_RECT(DEST, SCALE) QRect dest = QRect(static_cast<int>(DEST.left()   * SCALE), \
+                                                    static_cast<int>(DEST.top()    * SCALE), \
+                                                    static_cast<int>(DEST.width()  * SCALE), \
+                                                    static_cast<int>(DEST.height() * SCALE));
+
 void MythOpenGLPainter::DrawImage(const QRect &Dest, MythImage *Image,
                                   const QRect &Source, int Alpha)
 {
     if (m_render)
     {
-        // Drawing an image  multiple times with the same VBO will stall most GPUs as
+        SCALED_RECT(Dest, m_pixelRatio)
+
+        // Drawing an image multiple times with the same VBO will stall most GPUs as
         // the VBO is re-mapped whilst still in use. Use a pooled VBO instead.
         MythGLTexture *texture = GetTextureFromCache(Image);
         if (texture && m_mappedTextures.contains(texture))
@@ -234 +245 @@
             QOpenGLBuffer *vbo = texture->m_vbo;
             texture->m_vbo = m_mappedBufferPool[m_mappedBufferPoolIdx];
             texture->m_destination = QRect();
-            m_render->DrawBitmap(texture, m_target, Source, Dest, nullptr, Alpha);
+            m_render->DrawBitmap(texture, m_target, Source, dest, nullptr, Alpha);
             texture->m_destination = QRect();
             texture->m_vbo = vbo;
             if (++m_mappedBufferPoolIdx >= MAX_BUFFER_POOL)
@@ -242 +253 @@
         }
         else
         {
-            m_render->DrawBitmap(texture, m_target, Source, Dest, nullptr, Alpha);
+            m_render->DrawBitmap(texture, m_target, Source, dest, nullptr, Alpha);
             m_mappedTextures.append(texture);
         }
     }
@@ -251 +262 @@
 void MythOpenGLPainter::DrawRect(const QRect &Area, const QBrush &FillBrush,
                                  const QPen &LinePen, int Alpha)
 {
+    /*
     if ((FillBrush.style() == Qt::SolidPattern ||
          FillBrush.style() == Qt::NoBrush) && m_render)
     {
         m_render->DrawRect(m_target, Area, FillBrush, LinePen, Alpha);
         return;
     }
+    */
     MythPainter::DrawRect(Area, FillBrush, LinePen, Alpha);
 }
 
@@ -264 +277 @@
                                       const QBrush &FillBrush,
                                       const QPen &LinePen, int Alpha)
 {
+    /*
     if ((FillBrush.style() == Qt::SolidPattern ||
          FillBrush.style() == Qt::NoBrush) && m_render)
     {
-        m_render->DrawRoundRect(m_target, Area, CornerRadius, FillBrush,
-                                  LinePen, Alpha);
+        m_render->DrawRoundRect(m_target, Area, CornerRadius, FillBrush, LinePen, Alpha);
         return;
     }
+    */
     MythPainter::DrawRoundRect(Area, CornerRadius, FillBrush, LinePen, Alpha);
 }
 

mythtv/libs/libmythui/opengl/mythpainteropengl.h

@@ -60 +60 @@
     QOpenGLFramebufferObject* m_target { nullptr };
     bool              m_swapControl { true };
     QSize             m_lastSize { };
+    qreal             m_pixelRatio { 1.0 };
 
     QMap<MythImage *, MythGLTexture*> m_imageToTextureMap;
     std::list<MythImage *>     m_ImageExpireList;

mythtv/libs/libmythui/opengl/mythrenderopengl.cpp

@@ -579 +579 @@
 {
     if (Rect == m_viewport)
         return;
+    LOG(VB_GENERAL, LOG_INFO, LOC + QString("New viewport: %1x%2+%3+%4")
+        .arg(Rect.width()).arg(Rect.height()).arg(Rect.left()).arg(Rect.top()));
     makeCurrent();
     m_viewport = Rect;
     glViewport(m_viewport.left(), m_viewport.top(),

mythtv/libs/libmythui/platforms/mythdisplayosx.cpp

@@ -27 +27 @@
     {
         if (!HasMythMainWindow())
         {
+            LOG(VB_GENERAL, LOG_WARNING, LOC + "Cannot update current mode");
             MythDisplay::UpdateCurrentMode();
             return;
         }
@@ -36 +37 @@
     CGDirectDisplayID disp = GetOSXDisplay(widget->winId());
     if (!disp)
     {
+        LOG(VB_GENERAL, LOG_WARNING, LOC + "No display");
         MythDisplay::UpdateCurrentMode();
         return;
     }
     CGDisplayModeRef mode = CGDisplayCopyDisplayMode(disp);
     if (!mode)
     {
+        LOG(VB_GENERAL, LOG_WARNING, LOC + "Could not copy mode");
         MythDisplay::UpdateCurrentMode();
         return;
     }
@@ -67 +70 @@
 
 const std::vector<MythDisplayMode>& MythDisplayOSX::GetVideoModes(void)
 {
-    if (!m_videoModes.empty() || !HasMythMainWindow())
+    if (!m_videoModes.empty())
         return m_videoModes;
 
+    if (!HasMythMainWindow())
+    {
+        LOG(VB_GENERAL, LOG_WARNING, LOC + "Cannot retrieve modes");
+        return m_videoModes;
+    }
+
     ClearModes();
 
     WId win = (qobject_cast<QWidget*>(MythMainWindow::getMainWindow()))->winId();
@@ -83 +92 @@
     DisplayModeMap screen_map;
     CGSize sizemm = CGDisplayScreenSize(disp);
 
+    LOG(VB_GENERAL, LOG_INFO, LOC + "Raw video mode sizes:");
     for (int i = 0; i < CFArrayGetCount(modes); ++i)
     {
         CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(modes, i);
@@ -90 +100 @@
         bool interlaced = CGDisplayModeGetIOFlags(mode) & kDisplayModeInterlacedFlag;
         int width       = static_cast<int>(CGDisplayModeGetWidth(mode));
         int height      = static_cast<int>(CGDisplayModeGetHeight(mode));
+        int widthp      = static_cast<int>(CGDisplayModeGetPixelWidth(mode));
+        int heightp     = static_cast<int>(CGDisplayModeGetPixelHeight(mode));
+
+        LOG(VB_GENERAL, LOG_INFO, LOC + QString("Resolution: %1x%2 PixelSize: %3x%4")
+            .arg(width).arg(height).arg(widthp).arg(heightp));
 
         // See note in MythDisplayX11
         if (interlaced)
@@ -120 +135 @@
 bool MythDisplayOSX::SwitchToVideoMode(QSize Size, double DesiredRate)
 {
     if (!HasMythMainWindow())
+    {
+        LOG(VB_GENERAL, LOG_WARNING, LOC + "Cannot switch mode");
         return false;
+    }
+
     WId win = (qobject_cast<QWidget*>(MythMainWindow::getMainWindow()))->winId();
     CGDirectDisplayID disp = GetOSXDisplay(win);
     if (!disp)
+    {
+        LOG(VB_GENERAL, LOG_WARNING, LOC + "No display");
         return false;
+    }
 
     auto rate = static_cast<double>(NAN);
     MythDisplayMode desired(Size, QSize(0, 0), -1.0, DesiredRate);
@@ -147 +169 @@
     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);
+    CGError err = CGDisplaySetDisplayMode(disp, m_modeMap.value(mode), nullptr);
+    if (err != kCGErrorSuccess)
+        LOG(VB_GENERAL, LOG_ERR, LOC + QString("Failed to set display mode (%1)").arg(err));
+    err = CGCompleteDisplayConfiguration(cfg, kCGConfigureForAppOnly);
     CGDisplayRelease(disp);
     return err == kCGErrorSuccess;
 }