Changeset 713 for trunk

Timestamp:

Apr 28, 2010, 6:02:42 PM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: Implemented the direct framebuffer access method in Dive mode (based on the patch by Rudi). It is controlled by the QT_PM_DIVE environment variable (see #101 for details).

Location:

trunk/src/gui/painting

Files:

• qwindowsurface_pm.cpp (modified) (15 diffs)
• qwindowsurface_pm_p.h (modified) (2 diffs)

trunk/src/gui/painting/qwindowsurface_pm.cpp

@@ -193 +193 @@
 
 static
-ULONG (APIENTRY *DiveClose) ( HDIVE hDiveInst );
+ULONG (APIENTRY *DiveClose) ( HDIVE hDiveInst ) = 0;
+
+static
+ULONG (APIENTRY *DiveAcquireFrameBuffer) ( HDIVE   hDiveInst,
+                                           PRECTL  prectlDst ) = 0;
+
+static
+ULONG (APIENTRY *DiveDeacquireFrameBuffer) ( HDIVE hDiveInst ) = 0;
 
 static
@@ -230 +237 @@
     FUNC_ENTRY(DiveBlitImage),
     FUNC_ENTRY(DiveClose),
+
+
     FUNC_ENTRY(DiveAllocImageBuffer),
     FUNC_ENTRY(DiveFreeImageBuffer),
@@ -241 +250 @@
 
 static DIVE_CAPS diveCaps = { 0 };
+
+
+
+
 
 ////////////////////////////////////////////////////////////////////////////////
 
 QT_BEGIN_NAMESPACE
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 // Returns a directly matching QImage format for the given FOURCC (including
@@ -262 +289 @@
 // 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)
-{
+// fourccToFormat(). If isFB is true, the selection is made for the direct
+// framebuffer access mode.
+static FOURCC fourccScreenToBuffer(FOURCC fourcc, bool isFB = false)
+{
+    Q_UNUSED(isFB);
+
     // 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;
-}
+    if (!isFB) {
+        // 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;
+    }
+
+    // in direct framebuffer access mode, we use BGR4 which should be faster
+    return FOURCC_BGR4;
+}
+
+class QPMDiveWindowSurfaceFB : public QPMDiveWindowSurface
+{
+public:
+    QPMDiveWindowSurfaceFB(QWidget *widget);
+    ~QPMDiveWindowSurfaceFB();
+    void doFlush(const QRect &from, const QPoint &to);
+};
 
 struct QPMDiveWindowSurfacePrivate
@@ -282 +325 @@
     QImage *image;
     HDIVE hDive;
+
     ULONG bufNum;
     bool posDirty;
@@ -302 +346 @@
     d->image = 0;
     d->hDive = NULLHANDLE;
+
     d->bufNum = 0;
     d->posDirty = true;
@@ -352 +397 @@
     br.translate(offset);
 
-    wbr.setBottom(widget->height() - wbr.bottom() - 1); // flip y coordinate
-
     if (d->vrnDisabled) {
         // defer the flush
-        QPMDiveWindowSurfacePrivate::FlushArgs args = { br, wbr.bottomLeft() };
+        QPMDiveWindowSurfacePrivate::FlushArgs args = { br, wbr.Left() };
         d->pending.append(args);
         return;
     }
 
-    doFlush(br, wbr.bottomLeft());
-}
-
-void QPMDiveWindowSurface::doFlush(const QRect &from, const QPoint &to)
-{
-    DEBUG(() << "QPMDiveWindowSurface::doFlush:" << window()
-             << "from" << from << "to" << to);
-
-    // make sure from doesn't exceed the backing storage size (it may happen
-    // during resize & move due to the different event order)
-    QRect src = from.intersected(QRect(0, 0, d->image->width(), d->image->height()));
-    QPoint dst = to + (src.bottomLeft() - from.bottomLeft());
-
+    doFlush(br, wbr.topLeft());
+}
+
+bool QPMDiveWindowSurface::adjustSetup()
+{
     HWND hwnd = window()->winId();
 
@@ -384 +419 @@
         d->posDirty = false;
         POINTL ptl = { 0, 0 };
-        WinMapWindowPoints(window()->winId(), HWND_DESKTOP, &ptl, 1);
+        WinMapWindowPoints(, HWND_DESKTOP, &ptl, 1);
         d->setup.lScreenPosX = ptl.x;
         d->setup.lScreenPosY = ptl.y;
         d->setup.ulStructLen = offsetof(SETUP_BLITTER, ulNumDstRects);
 
-        DEBUG(() << "QPMDiveWindowSurface::doFlush:" << "posDirty"
+        DEBUG(() << "QPMDiveWindowSurface:::" << "posDirty"
                  << ptl.x << ptl.y);
     }
@@ -426 +461 @@
 
 #if defined(QDIVE_DEBUG)
-        DEBUG(() << "QPMDiveWindowSurface::doFlush:" << "vrnDirty");
+        DEBUG(() << "QPMDiveWindowSurface:::" << "vrnDirty");
         for (size_t i = 0; i < d->setup.ulNumDstRects; ++i)
             DEBUG(() << " " << i << ":" << d->setup.pVisDstRects[i]);
@@ -432 +467 @@
     }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     // note that the source image is expected to be top-left oriented
     // by DiveSetupBlitter() so we don't perform y coordinate flip
+
+
+
 
     SETUP_BLITTER setupTmp = d->setup;
@@ -522 +575 @@
         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,
-                                        d->setup.fccSrcColorFormat,
-                                        width, height,
-                                        d->image->bytesPerLine(),
-                                        (PBYTE)const_cast<const QImage *>(d->image)->bits());
-        if (rc != DIVE_SUCCESS) {
-            qWarning("QPMDiveWindowSurface::setGeometry: DiveAllocImageBuffer "
-                     "returned 0x%08lX", rc);
-            delete d->image;
-            delete oldImage;
-            return;
+        if (!d->useFB) {
+            // associate the image data pointer with the buffer number
+            DiveFreeImageBuffer(d->hDive, d->bufNum);
+            d->bufNum = 0;
+            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 "
+                         "returned 0x%08lX", rc);
+                delete d->image;
+                delete oldImage;
+                return;
+            }
         }
 
@@ -599 +654 @@
     if (!diveDllResolved) {
         diveDllResolved = true;
-        diveDllOK = true;
-        for (size_t i = 0; i < sizeof(diveDllFuncs) / sizeof(diveDllFuncs[0]); ++i) {
-            *diveDllFuncs[i].entry = diveDll.resolve(diveDllFuncs[i].name);
-            if (!*diveDllFuncs[i].entry) {
-                diveDllOK = false;
-                break;
-            }
-        }
-
+        diveDllOK = qgetenv("QT_PM_NO_DIVE").isEmpty();
         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
+            QByteArray diveEnv = qgetenv("QT_PM_DIVE").trimmed().toUpper();
+            if (diveEnv == "BLIT") {
+                // use DiveBlitImage()
+                diveUseFB = false;
+            } else if (diveEnv == "FB") {
+                // use direct framebuffer access
+                diveUseFB = true;
+            } else {
+                // disable DIVE by default due to bugs in the Panorama driver
                 diveDllOK = false;
             }
         }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
         DEBUG_VAR(diveDllOK);
+
     }
 
@@ -648 +789 @@
         return 0;
 
-    // Attempt to create a new DIVE instance for this widget
     HDIVE hDive = NULLHANDLE;
-    ULONG rc = DiveOpen(&hDive, FALSE, 0);
+    ULONG rc = DIVE_SUCCESS;
+
+    if (diveUseFB) {
+        // we use a shared DIVE instance for all widgets
+        if (diveHandle == NULLHANDLE)
+            rc = DiveOpen(&diveHandle, FALSE, &diveFrameBuf);
+        hDive = diveHandle;
+    } else {
+        // we need a new DIVE instance to reduce the number of calls to
+        // DiveSetupBlitter() (as recommended by MMAPG)
+        rc = DiveOpen(&hDive, FALSE, 0);
+    }
+
     if (rc != DIVE_SUCCESS) {
         qWarning("QPMDiveWindowSurface::create: DiveOpen returned 0x%08lX", rc);
@@ -656 +808 @@
     }
 
-    QPMDiveWindowSurface *surface = new QPMDiveWindowSurface(widget);
+    QPMDiveWindowSurface *surface = diveUseFB ?
+        new QPMDiveWindowSurfaceFB(widget) : new QPMDiveWindowSurface(widget);
+
     if (surface)
         surface->d->hDive = hDive;
@@ -665 +819 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 QT_END_NAMESPACE
 

trunk/src/gui/painting/qwindowsurface_pm_p.h

@@ -71 +71 @@
     QPaintDevice *paintDevice();
     void flush(QWidget *widget, const QRegion &rgn, const QPoint &offset);
-    void doFlush(const QRect &from, const QPoint &to);
     void setGeometry(const QRect &rect);
     bool scroll(const QRegion &area, int dx, int dy);
@@ -77 +76 @@
     static QPMDiveWindowSurface *create(QWidget *widget);
 
-private:
+protected:
+    bool adjustSetup();
+    virtual void doFlush(const QRect &from, const QPoint &to);
     bool pmEventFilter(QMSG *msg, MRESULT *result);