Ticket #13618: dpi6.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.GetRawWindowRect().size();
     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*/)
+{
+    PopulateGeometry();
+    m_windowRect = m_displayVisibleRect = SCALED_RECT(m_rawWindowRect, m_devicePixelRatio);
+    MoveResize();
+}
+
 void VideoOutWindow::PopulateGeometry(void)
 {
     if (!m_display)
@@ -72 +84 @@
     if (!screen)
         return;
 
+#ifdef Q_OS_MAC
+    m_devicePixelRatio = screen->devicePixelRatio();
+#endif
+
     if (MythDisplay::SpanAllScreens() && MythDisplay::GetScreenCount() > 1)
     {
         m_screenGeometry = screen->virtualGeometry();
@@ -416 +432 @@
     {
         m_display = Display;
         connect(m_display, &MythDisplay::CurrentScreenChanged, this, &VideoOutWindow::ScreenChanged);
+#ifdef Q_OS_MAC
+        connect(m_display, &MythDisplay::PhysicalDPIChanged,   this, &VideoOutWindow::PhysicalDPIChanged);
+#endif
     }
 
     if (m_display)
@@ -429 +448 @@
 
     // N.B. we are always confined to the window size so use that for the initial
     // displayVisibleRect
-    m_windowRect = m_displayVisibleRect = WindowRect;
+    m_rawWindowRect = WindowRect;
+    m_windowRect = m_displayVisibleRect = SCALED_RECT(WindowRect, m_devicePixelRatio);
 
     int pbp_width = m_displayVisibleRect.width() / 2;
     if (m_pipState == kPBPLeft || m_pipState == kPBPRight)
@@ -613 +633 @@
 
 void VideoOutWindow::SetWindowSize(QSize Size)
 {
-    if (Size != m_windowRect.size())
+    if (Size != m_rawWindowRect.size())
     {
-        QRect rect(m_windowRect.topLeft(), Size);
+        QRect rect(m_rawWindowRect.topLeft(), Size);
         LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("New window rect: %1x%2+%3+%4")
             .arg(rect.width()).arg(rect.height()).arg(rect.left()).arg(rect.top()));
-        m_windowRect = m_displayVisibleRect = rect;
+        m_rawWindowRect = rect;
+        m_windowRect = m_displayVisibleRect = SCALED_RECT(rect, m_devicePixelRatio);
         MoveResize();
     }
 }

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);
@@ -74 +75 @@
     float    GetOverridenVideoAspect(void) const { return m_videoAspectOverride;}
     QRect    GetDisplayVisibleRect(void)   const { return m_displayVisibleRect; }
     QRect    GetWindowRect(void)           const { return m_windowRect; }
+    QRect    GetRawWindowRect(void)        const { return m_rawWindowRect; }
     QRect    GetScreenGeometry(void)       const { return m_screenGeometry; }
     QRect    GetVideoRect(void)            const { return m_videoRect; }
     QRect    GetDisplayVideoRect(void)     const { return m_displayVideoRect; }
@@ -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.
@@ -147 +150 @@
     QRect   m_displayVisibleRect {0,0,0,0};
     /// Rectangle describing QWidget bounds.
     QRect   m_windowRect {0,0,0,0};
+    /// Rectangle describing QWidget bounds - not adjusted for high DPI scaling (macos)
+    QRect   m_rawWindowRect {0,0,0,0};
     /// Used to save the display_visible_rect for
     /// restoration after video embedding ends.
     QRect   m_tmpDisplayVisibleRect {0,0,0,0};

mythtv/libs/libmythui/opengl/mythpainteropengl.cpp

@@ -109 +109 @@
             buf = m_render->CreateVBO(static_cast<int>(MythRenderOpenGL::kVertexSize));
     }
 
+    // check for high dpi on macos
+    // If we do not have swap control (i.e. OSD), then the master should be pixel
+    // ratio 'aware' (i.e. the video output classes)
+#ifdef Q_OS_MAC
+    m_pixelRatio = m_swapControl ? m_parent->devicePixelRatioF() : 1.0;
+#endif
+    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 +139 @@
     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();
     }
@@ -226 +234 @@
 {
     if (m_render)
     {
-        // Drawing an image  multiple times with the same VBO will stall most GPUs as
+#ifdef Q_OS_MAC
+        QRect dest { static_cast<int>(Dest.left()   * m_pixelRatio),
+                     static_cast<int>(Dest.top()    * m_pixelRatio),
+                     static_cast<int>(Dest.width()  * m_pixelRatio),
+                     static_cast<int>(Dest.height() * m_pixelRatio) };
+#endif
+        // 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 +248 @@
             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);
+#ifdef Q_OS_MAC
+            m_render->DrawBitmap(texture, m_target, Source, dest, nullptr, Alpha, m_pixelRatio);
+#else
+            m_render->DrawBitmap(texture, m_target, Source, Dest, nullptr, Alpha, m_pixelRatio);
+#endif
             texture->m_destination = QRect();
             texture->m_vbo = vbo;
             if (++m_mappedBufferPoolIdx >= MAX_BUFFER_POOL)
@@ -242 +260 @@
         }
         else
         {
-            m_render->DrawBitmap(texture, m_target, Source, Dest, nullptr, Alpha);
+#ifdef Q_OS_MAC
+            m_render->DrawBitmap(texture, m_target, Source, dest, nullptr, Alpha, m_pixelRatio);
+#else
+            m_render->DrawBitmap(texture, m_target, Source, Dest, nullptr, Alpha, m_pixelRatio);
+#endif
             m_mappedTextures.append(texture);
         }
     }
 }
 
+/*! \brief Render a rectangle to the UI
+ *
+ * \note MythRenderOpenGL can only handle simple (i.e. solid) brush patterns -
+ * otherwise we fallback to QPainter rendering, which will create a QImage that
+ * will be rendered as a texture.
+ * \note Fallback to QPainter rendering for high DPI (pixel ratio > 1.0) rather
+ * than handle the various adjustments that are needed.
+*/
 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)
+    if ((FillBrush.style() == Qt::SolidPattern || FillBrush.style() == Qt::NoBrush) &&
+        (m_pixelRatio == 1.0) && m_render)
     {
         m_render->DrawRect(m_target, Area, FillBrush, LinePen, Alpha);
         return;
     }
+
     MythPainter::DrawRect(Area, FillBrush, LinePen, Alpha);
 }
 
@@ -264 +295 @@
                                       const QBrush &FillBrush,
                                       const QPen &LinePen, int Alpha)
 {
-    if ((FillBrush.style() == Qt::SolidPattern ||
-         FillBrush.style() == Qt::NoBrush) && m_render)
+    if ((FillBrush.style() == Qt::SolidPattern || FillBrush.style() == Qt::NoBrush) &&
+        (m_pixelRatio = 1.0) && 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

@@ -804 +804 @@
 
 void MythRenderOpenGL::DrawBitmap(MythGLTexture *Texture, QOpenGLFramebufferObject *Target,
                                   const QRect &Source, const QRect &Destination,
-                                  QOpenGLShaderProgram *Program, int Alpha)
+                                  QOpenGLShaderProgram *Program, int Alpha, qreal Scale)
 {
     makeCurrent();
 
@@ -827 +827 @@
 
     QOpenGLBuffer* buffer = Texture->m_vbo;
     buffer->bind();
-    if (UpdateTextureVertices(Texture, Source, Destination, 0))
+    if (UpdateTextureVertices(Texture, Source, Destination, 0, Scale))
     {
         if (m_extraFeaturesUsed & kGLBufferMap)
         {
@@ -1262 +1262 @@
 }
 
 bool MythRenderOpenGL::UpdateTextureVertices(MythGLTexture *Texture, const QRect &Source,
-                                             const QRect &Destination, int Rotation)
+                                             const QRect &Destination, int Rotation, qreal Scale)
 {
     if (!Texture || (Texture && Texture->m_size.isEmpty()))
         return false;
@@ -1301 +1301 @@
     data[4 + TEX_OFFSET] = data[6 + TEX_OFFSET];
     data[5 + TEX_OFFSET] = data[1 + TEX_OFFSET];
 
-    width  = Texture->m_crop ? min(width, Destination.width())   : Destination.width();
-    height = Texture->m_crop ? min(height, Destination.height()) : Destination.height();
+    width  = Texture->m_crop ? min(static_cast<int>(width * Scale),  Destination.width())  : Destination.width();
+    height = Texture->m_crop ? min(static_cast<int>(height * Scale), Destination.height()) : Destination.height();
 
     data[2] = data[0] = Destination.left();
     data[5] = data[1] = Destination.top();

mythtv/libs/libmythui/opengl/mythrenderopengl.h

@@ -143 +143 @@
 
     void  DrawBitmap(MythGLTexture *Texture, QOpenGLFramebufferObject *Target,
                      const QRect &Source, const QRect &Destination,
-                     QOpenGLShaderProgram *Program, int Alpha = 255);
+                     QOpenGLShaderProgram *Program, int Alpha = 255, qreal Scale = 1.0);
     void  DrawBitmap(MythGLTexture **Textures, uint TextureCount,
                      QOpenGLFramebufferObject *Target,
                      const QRect &Source, const QRect &Destination,
@@ -171 +171 @@
     void  SetMatrixView(void);
     void  DeleteFramebuffers(void);
     static bool UpdateTextureVertices(MythGLTexture *Texture, const QRect &Source,
-                                      const QRect &Destination, int Rotation);
+                                      const QRect &Destination, int Rotation, qreal Scale = 1.0);
     GLfloat* GetCachedVertices(GLuint Type, const QRect &Area);
     void  ExpireVertices(int Max = 0);
     void  GetCachedVBO(GLuint Type, const QRect &Area);

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;
 }