Changeset 712

Timestamp:

Apr 27, 2010, 4:15:04 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: Fixed widget painting in Dive mode when the screen color format is not 32-bit.

File:

• trunk/src/gui/painting/qwindowsurface_pm.cpp (modified) (11 diffs)

trunk/src/gui/painting/qwindowsurface_pm.cpp ¶

@@ -42 +42 @@
 ****************************************************************************/
 
-#include "qt_os2.h"
-#include "qlibrary.h"
+#include <qdebug.h>
+
+//#define QDIVE_DEBUG
+
+#if defined QDIVE_DEBUG
+#define DEBUG(a) qDebug a
+#define DEBUG_VAR(v) DEBUG(() << #v << v)
+#define DEBUG_VAR_HEX(v) DEBUG(() << #v << qDebugFmtHex(v))
+#else
+#define DEBUG(a) do {} while(0)
+#define DEBUG_VAR(v) do {} while(0)
+#define DEBUG_VAR_HEX(v) do {} while(0)
+#endif
+
+#include <qt_os2.h>
+#include <qlibrary.h>
 
 #include "qwindowsurface_pm_p.h"
 #include "private/qnativeimage_p.h"
-
-#include "qdebug.h"
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -77 +89 @@
 #define DIVE_BUFFER_GRAPHICS_PLANE                       0x00000001
 #define DIVE_BUFFER_ALTERNATE_PLANE                      0x00000002
+
+typedef struct _DIVE_CAPS {
+
+   ULONG  ulStructLen;            /* Set equal to sizeof(DIVE_CAPS)          */
+   ULONG  ulPlaneCount;           /* Number of defined planes.               */
+
+   /* Info returned in the following fields pertains to ulPlaneID.           */
+   BOOL   fScreenDirect;          /* TRUE if can get addressability to vram. */
+   BOOL   fBankSwitched;          /* TRUE if vram is bank-switched.          */
+   ULONG  ulDepth;                /* Number of bits per pixel.               */
+   ULONG  ulHorizontalResolution; /* Screen width in pixels.                 */
+   ULONG  ulVerticalResolution;   /* Screen height in pixels.                */
+   ULONG  ulScanLineBytes;        /* Screen scan line size in bytes.         */
+   FOURCC fccColorEncoding;       /* Colorspace encoding of the screen.      */
+   ULONG  ulApertureSize;         /* Size of vram aperture in bytes.         */
+
+   ULONG  ulInputFormats;         /* Number of input color formats.          */
+   ULONG  ulOutputFormats;        /* Number of output color formats.         */
+   ULONG  ulFormatLength;         /* Length of format buffer.                */
+   PVOID  pFormatData;            /* Pointer to color format buffer FOURCC's.*/
+
+   } DIVE_CAPS;
+typedef DIVE_CAPS *PDIVE_CAPS;
 
 typedef struct _SETUP_BLITTER {
@@ -140 +175 @@
 
 static
+ULONG (APIENTRY *DiveQueryCaps) ( PDIVE_CAPS pDiveCaps,
+                                  ULONG      ulPlaneBufNum ) = 0;
+
+static
 ULONG (APIENTRY *DiveOpen) ( HDIVE *phDiveInst,
                              BOOL   fNonScreenInstance,
@@ -186 +225 @@
 static struct { const char *name; void **entry; } diveDllFuncs[] =
 {
+    FUNC_ENTRY(DiveQueryCaps),
     FUNC_ENTRY(DiveOpen),
     FUNC_ENTRY(DiveSetupBlitter),
@@ -200 +240 @@
 static bool diveDllOK = false;
 
+static DIVE_CAPS diveCaps = { 0 };
+
 ////////////////////////////////////////////////////////////////////////////////
 
 QT_BEGIN_NAMESPACE
+
+// Returns a directly matching QImage format for the given FOURCC (including
+// bit order and depth, scan line size etc.) or Format_Invalid.
+static QImage::Format fourccToFormat(FOURCC fourcc)
+{
+    switch (fourcc) {
+        case FOURCC_R555: return QImage::Format_RGB555;
+        case FOURCC_R565: return QImage::Format_RGB16;
+        case FOURCC_RGB3: return QImage::Format_RGB888;
+        case FOURCC_BGR4: return QImage::Format_RGB32;
+        default: return QImage::Format_Invalid;
+    }
+}
+
+// Returns a FOURCC that is best for the buffer used to blit to the given
+// screen FOURCC. Returns 0 (FOURC_SCRN) if there is no suitable conversion,
+// otherwise it is guaranteed that the returned value is accepted by
+// fourccToFormat().
+static FOURCC fourccScreenToBuffer(FOURCC fourcc)
+{
+    // return it as is if supported by fourccToFormat()
+    if (fourccToFormat(fourcc) != QImage::Format_Invalid)
+        return fourcc;
+
+    // otherwise, use FOURCC_RGB3 (which in theory should always work; if not,
+    // we will add exceptions here and return 0 in such cases). Note that
+    // although working with 32-bit pixels would be faster, we cannot return
+    // FOURCC_BGR4 here because DiveBlitImage() is known to crahsh when the
+    // source buffer is BGR4 and the screen is not (at least, it's the case
+    // with recent SNAP versions)
+    return FOURCC_RGB3;
+}
 
 struct QPMDiveWindowSurfacePrivate
@@ -235 +309 @@
     memset(&d->setup, 0, sizeof(SETUP_BLITTER));
 
-    // Note that DiveBlitImage() seems to ignore fccSrcColorFormat and
-    // fccSrcColorFormat which is not a big surprise because both values are
-    // known (the source color format is specified at buffer creation time
-    // and the screen color format is always known). Also note that specifying
-    // values other than FOURCC_LUT8/R565/BGR3 causes a crash in DiveBlitImage()
-    // no matter what the actual source format is. FOURCC_SCRN seems to work.
-    d->setup.fccSrcColorFormat = FOURCC_SCRN;
+    // note that fccSrcColorFormat overrides the value specified during the
+    // source buffer creation, so they must match
+    d->setup.fccSrcColorFormat = fourccScreenToBuffer(diveCaps.fccColorEncoding);
     d->setup.fccDstColorFormat = FOURCC_SCRN;
 
@@ -296 +366 @@
 void QPMDiveWindowSurface::doFlush(const QRect &from, const QPoint &to)
 {
-#if 0
-    qDebug() << "QPMDiveWindowSurface::doFlush:" << window()
-             << "from" << from << "to" << to;
-#endif
+    DEBUG(() << "QPMDiveWindowSurface::doFlush:" << window()
+             << "from" << from << "to" << to);
 
     // make sure from doesn't exceed the backing storage size (it may happen
@@ -320 +388 @@
         d->setup.lScreenPosY = ptl.y;
         d->setup.ulStructLen = offsetof(SETUP_BLITTER, ulNumDstRects);
+
+        DEBUG(() << "QPMDiveWindowSurface::doFlush:" << "posDirty"
+                 << ptl.x << ptl.y);
     }
 
@@ -353 +424 @@
         GpiDestroyRegion(hps, hrgn);
         window()->releasePS(hps);
+
+#if defined(QDIVE_DEBUG)
+        DEBUG(() << "QPMDiveWindowSurface::doFlush:" << "vrnDirty");
+        for (size_t i = 0; i < d->setup.ulNumDstRects; ++i)
+            DEBUG(() << " " << i << ":" << d->setup.pVisDstRects[i]);
+#endif
     }
 
@@ -441 +518 @@
         QImage *oldImage = d->image;
 
-        d->image = new QImage(width, height, QImage::Format_RGB32);
+        QImage::Format format = fourccToFormat(d->setup.fccSrcColorFormat);
+        Q_ASSERT(format != QImage::Format_Invalid);
+        d->image = new QImage(width, height, format);
 
         // associate the image data pointer with the buffer number
         DiveFreeImageBuffer(d->hDive, d->bufNum);
         d->bufNum = 0;
-        ULONG rc = DiveAllocImageBuffer(d->hDive, &d->bufNum, FOURCC_BGR4,
+        ULONG rc = DiveAllocImageBuffer(d->hDive, &d->bufNum,
+                                        d->setup.fccSrcColorFormat,
                                         width, height,
                                         d->image->bytesPerLine(),
                                         (PBYTE)const_cast<const QImage *>(d->image)->bits());
-
         if (rc != DIVE_SUCCESS) {
             qWarning("QPMDiveWindowSurface::setGeometry: DiveAllocImageBuffer "
@@ -528 +607 @@
             }
         }
+
+        if (diveDllOK) {
+            diveCaps.ulStructLen = sizeof(diveCaps);
+            DiveQueryCaps(&diveCaps, DIVE_BUFFER_SCREEN);
+
+            DEBUG_VAR(diveCaps.fScreenDirect);
+            DEBUG_VAR(diveCaps.fBankSwitched);
+            DEBUG_VAR(diveCaps.ulDepth);
+            DEBUG_VAR(diveCaps.ulHorizontalResolution);
+            DEBUG_VAR(diveCaps.ulVerticalResolution);
+            DEBUG_VAR(diveCaps.ulScanLineBytes);
+            DEBUG(() << "diveCaps.fccColorEncoding"
+                     << ((char*)&diveCaps.fccColorEncoding)[0]
+                     << ((char*)&diveCaps.fccColorEncoding)[1]
+                     << ((char*)&diveCaps.fccColorEncoding)[2]
+                     << ((char*)&diveCaps.fccColorEncoding)[3]);
+
+            FOURCC bestBufFormat = fourccScreenToBuffer(diveCaps.fccColorEncoding);
+            DEBUG(() << "bestBufFormat"
+                     << ((char*)&bestBufFormat)[0]
+                     << ((char*)&bestBufFormat)[1]
+                     << ((char*)&bestBufFormat)[2]
+                     << ((char*)&bestBufFormat)[3]);
+
+            if (bestBufFormat == 0) {
+                // there is no working pixel format for the buffer for
+                // DiveBlitImage() to work correctly with the current screen
+                // format, give up
+                diveDllOK = false;
+            }
+        }
+
+        DEBUG_VAR(diveDllOK);
     }