Changeset 713 for trunk/src/gui/painting/qwindowsurface_pm.cpp

Timestamp:

Apr 28, 2010, 6:02:42 PM (15 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).

File:

• trunk/src/gui/painting/qwindowsurface_pm.cpp (modified) (15 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(DiveAcquireFrameBuffer),
+    FUNC_ENTRY(DiveDeacquireFrameBuffer),
     FUNC_ENTRY(DiveAllocImageBuffer),
     FUNC_ENTRY(DiveFreeImageBuffer),
@@ -241 +250 @@
 
 static DIVE_CAPS diveCaps = { 0 };
+static bool diveUseFB = false;
+static ULONG diveColorMap[3][256] = { { 0 } };
+static HDIVE diveHandle = NULLHANDLE;
+static char *diveFrameBuf = NULL;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 QT_BEGIN_NAMESPACE
+
+#ifdef Q_CC_GNU
+extern inline unsigned bswap32_p(unsigned u)
+{
+    __asm__ __volatile__ ("bswap %0\n"
+                          : "=r" (u)
+                          : "0" (u));
+    return u;
+}
+#else
+#define bswap32_p(a) \
+    ((((ULONG)(a)) >> 24) | (((ULONG)(a)) << 24) | \
+     (((ULONG)(a) << 8) & 0x00ff0000) | (((ULONG)(a) >> 8) & 0x0000ff00))
+#endif
 
 // 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;
+    bool useFB;
     ULONG bufNum;
     bool posDirty;
@@ -302 +346 @@
     d->image = 0;
     d->hDive = NULLHANDLE;
+    d->useFB = false;
     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.topLeft() };
         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, 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::adjustSetup:" << "posDirty"
                  << ptl.x << ptl.y);
     }
@@ -426 +461 @@
 
 #if defined(QDIVE_DEBUG)
-        DEBUG(() << "QPMDiveWindowSurface::doFlush:" << "vrnDirty");
+        DEBUG(() << "QPMDiveWindowSurface::adjustSetup:" << "vrnDirty");
         for (size_t i = 0; i < d->setup.ulNumDstRects; ++i)
             DEBUG(() << " " << i << ":" << d->setup.pVisDstRects[i]);
@@ -432 +467 @@
     }
 
+    return setupDirty;
+}
+
+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.topLeft() - from.topLeft());
+
+    bool setupDirty = adjustSetup();
+
     // note that the source image is expected to be top-left oriented
     // by DiveSetupBlitter() so we don't perform y coordinate flip
+
+    // flip destination y coordinate
+    dst.setY(window()->height() - dst.y() - src.height());
 
     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;
             }
         }
 
+        if (diveDllOK) {
+            // resolve Dive functions
+            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;
+                }
+            }
+
+            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 (diveUseFB) {
+                    if (!diveCaps.fScreenDirect || diveCaps.fBankSwitched) {
+                        // direct framebuffer is not supported by the driver
+                        // (and switching banks is not supported by our code)
+                        diveUseFB = false;
+                    } else {
+                        if (bestBufFormat == diveCaps.fccColorEncoding) {
+                            // no color conversion is required
+                        } else if (bestBufFormat == FOURCC_BGR4) {
+                            // build the color conversion table
+                            switch (diveCaps.fccColorEncoding) {
+#if 0
+                            // FOURCC_R565/FOURCC_R555 should be handled directly
+                            case FOURCC_R565: {
+                                for (ULONG u = 0; u < 256; ++u) {
+                                    diveColorMap[0][u] = (u >> 3) << 0;
+                                    diveColorMap[1][u] = (u >> 2) << 5;
+                                    diveColorMap[2][u] = (u >> 3) << 11;
+                                }
+                                break;
+                            }
+                            case FOURCC_R555: {
+                                for (ULONG u = 0; u < 256; ++u) {
+                                    diveColorMap[0][u] = (u >> 3) << 0;
+                                    diveColorMap[1][u] = (u >> 3) << 5;
+                                    diveColorMap[2][u] = (u >> 3) << 10;
+                                }
+                                break;
+                            }
+#endif
+                            case FOURCC_R664: {
+                                for (ULONG u = 0; u < 256; ++u) {
+                                    diveColorMap[0][u] = (u >> 2) << 0;
+                                    diveColorMap[1][u] = (u >> 2) << 6;
+                                    diveColorMap[2][u] = (u >> 4) << 12;
+                                }
+                                break;
+                            }
+#if 0
+                            // FOURCC_BGR4 should be handled directly
+                            case FOURCC_BGR4:
+#endif
+                            case FOURCC_RGB4:
+                            case FOURCC_BGR3:
+                            case FOURCC_RGB3:
+                                break;
+                            default:
+                                // screen pixel format is not supported
+                                diveUseFB = false;
+                                break;
+                            }
+                        } else {
+                            Q_ASSERT(false);
+                            diveUseFB = false;
+                        }
+                    }
+                }
+
+                if (!diveUseFB) {
+                    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);
+        DEBUG_VAR(diveUseFB);
     }
 
@@ -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 @@
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
+QPMDiveWindowSurfaceFB::QPMDiveWindowSurfaceFB(QWidget* widget)
+    : QPMDiveWindowSurface(widget)
+{
+    d->useFB = true;
+}
+
+QPMDiveWindowSurfaceFB::~QPMDiveWindowSurfaceFB()
+{
+    // prevent the shared DIVE handle from closing
+    d->hDive = NULLHANDLE;
+}
+
+void QPMDiveWindowSurfaceFB::doFlush(const QRect &from, const QPoint &to)
+{
+    DEBUG(() << "QPMDiveWindowSurfaceFB::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()));
+
+    // convert the "to" coordinate to the delta
+    QPoint dstDelta = from.topLeft() - to;
+
+    bool wasPosDirty = d->posDirty;
+    bool wasVrnDirty = d->vrnDirty;
+
+    adjustSetup();
+
+    const int windowHeight = window()->height();
+
+    if (wasVrnDirty) {
+        // flip the y coordinate of all rectangles (both the image and the frame
+        // buffer are top-left oriented) and also make all points inclusive
+        for (ULONG i = 0; i < d->setup.ulNumDstRects; ++i) {
+            RECTL &rcl = d->setup.pVisDstRects[i];
+            --rcl.xRight;
+            --rcl.yTop;
+            rcl.yBottom = windowHeight - rcl.yBottom - 1;
+            rcl.yTop = windowHeight - rcl.yTop - 1;
+        }
+    }
+    if (wasPosDirty || wasVrnDirty) {
+        // the same flip for the window position
+        d->setup.lScreenPosY = diveCaps.ulVerticalResolution -
+                               d->setup.lScreenPosY - windowHeight;
+    }
+
+    // just assume that the rectangle in DiveAcquireFrameBuffer() is in PM
+    // coordinates (bottom-left based, top-right exclusive), MMREF doesn't
+    // mention anything particular...
+    RECTL rclDst = { src.left(),
+                     diveCaps.ulVerticalResolution -
+                     (d->setup.lScreenPosY + src.bottom() + dstDelta.y()) - 1,
+                     src.right() + 1,
+                     diveCaps.ulVerticalResolution -
+                     (d->setup.lScreenPosY + src.top() + dstDelta.y()) };
+
+    const int srcBpp = d->image->depth() >> 3;
+    const int dstBpp = diveCaps.ulDepth >> 3;
+    Q_ASSERT(srcBpp > 0); // we don't expect color depths < 1 byte here
+
+    const int srcBytesPerLine = d->image->bytesPerLine();
+
+    if (DiveAcquireFrameBuffer(d->hDive, &rclDst) == DIVE_SUCCESS) {
+        // take each visible rectangle and blit it
+        for (ULONG i = 0; i < d->setup.ulNumDstRects; ++i) {
+            RECTL rcl = d->setup.pVisDstRects[i];
+
+            if (rcl.xLeft < src.left())
+              rcl.xLeft = src.left();
+            if (rcl.xRight > src.right())
+              rcl.xRight = src.right();
+            if (rcl.yTop < src.top())
+              rcl.yTop = src.top();
+            if (rcl.yBottom > src.bottom())
+              rcl.yBottom = src.bottom();
+
+            int rows = rcl.yBottom - rcl.yTop + 1;
+            int cols = rcl.xRight - rcl.xLeft + 1;
+            int i;
+
+            if (cols > 0 && rows > 0) {
+                const uchar *srcBits =
+                    d->image->scanLine(rcl.yTop) + rcl.xLeft * srcBpp;
+                char *dstBits = diveFrameBuf +
+                    (d->setup.lScreenPosY + rcl.yTop + dstDelta.y()) * diveCaps.ulScanLineBytes +
+                    (d->setup.lScreenPosX + rcl.xLeft + dstDelta.x()) * dstBpp;
+
+                if (d->setup.fccSrcColorFormat == diveCaps.fccColorEncoding) {
+                    // no color conversion is required
+                    do {
+                        memcpy(dstBits, srcBits, srcBpp * cols);
+                        srcBits += srcBytesPerLine;
+                        dstBits += diveCaps.ulScanLineBytes;
+                    } while (--rows);
+                } else {
+                    Q_ASSERT(d->setup.fccSrcColorFormat == FOURCC_BGR4);
+                    Q_ASSERT(d->image->format() == QImage::Format_RGB32);
+                    Q_ASSERT(srcBpp == 4);
+                    switch (diveCaps.fccColorEncoding) {
+
+#if 0
+                    // FOURCC_BGR4 is covered by memcpy()
+                    case FOURCC_BGR4:
+                        do {
+                            for (i = 0; i < cols; i++ ) {
+                                *(PULONG)dstBits = *(PULONG)srcBits;
+                                srcBits += 4;
+                                dstBits += 4;
+                            }
+                            srcBits += srcBytesPerLine - (cols * 4);
+                            dstBits += diveCaps.ulScanLineBytes - (cols * 4);
+                        } while (--rows);
+                        break;
+#endif
+
+                    case FOURCC_RGB4:
+                        do {
+                            for (i = 0; i < cols; i++ ) {
+                                *(PULONG)dstBits = bswap32_p(*(PULONG)srcBits) >> 8;
+                                srcBits += 4;
+                                dstBits += 4;
+                            }
+                            srcBits += srcBytesPerLine - (cols * 4);
+                            dstBits += diveCaps.ulScanLineBytes - (cols * 4);
+                        } while (--rows);
+                        break;
+
+                    case FOURCC_BGR3:
+                        do {
+                            // copy in batches by 4 pixels
+                            for (i = cols; i >= 4; i -= 4) {
+                                *(PULONG)&dstBits[0] =
+                                    (*(PULONG)&srcBits[0] & 0x00ffffff) |
+                                    (*(PUCHAR)&srcBits[4] << 24);
+                                *(PULONG)&dstBits[4] =
+                                    (*(PUSHORT)&srcBits[5]) |
+                                    (*(PUSHORT)&srcBits[8] << 16);
+                                *(PULONG)&dstBits[8] =
+                                    (*(PUCHAR)&srcBits[10]) |
+                                    (*(PULONG)&srcBits[12] << 8);
+                                srcBits += 16;
+                                dstBits += 12;
+                            }
+                            // copy the rest
+                            while (i--) {
+                                dstBits[0] = srcBits[0];
+                                dstBits[1] = srcBits[1];
+                                dstBits[2] = srcBits[2];
+                                srcBits += 4;
+                                dstBits += 3;
+                            }
+                            srcBits += srcBytesPerLine - (cols * 4);
+                            dstBits += diveCaps.ulScanLineBytes - (cols * 3);
+                        } while (--rows);
+                        break;
+
+                    case FOURCC_RGB3:
+                        do {
+                            // copy in batches by 4 pixels
+                            for (i = cols; i >= 4; i -= 4) {
+                                *(PULONG)&dstBits[0] =
+                                    (*(PUCHAR)&srcBits[6] << 24) |
+                                    (bswap32_p(*(PULONG)srcBits) >> 8);
+                                *(PULONG)&dstBits[4] =
+                                    bswap32_p(*(PUSHORT)&srcBits[9]) |
+                                    (bswap32_p(*(PUSHORT)&srcBits[4]) >> 16);
+                                *(PULONG)&dstBits[8] =
+                                    (*(PUCHAR)&srcBits[8]) |
+                                    (bswap32_p(*(PULONG)&srcBits[12]) & 0xffffff00);
+                                srcBits += 16;
+                                dstBits += 12;
+                            }
+                            // copy the rest
+                            while (i--) {
+                                dstBits[2] = srcBits[0];
+                                dstBits[1] = srcBits[1];
+                                dstBits[0] = srcBits[2];
+                                srcBits += 4;
+                                dstBits += 3;
+                            }
+                            srcBits += srcBytesPerLine - (cols * 4);
+                            dstBits += diveCaps.ulScanLineBytes - (cols * 3);
+                        } while (--rows);
+                        break;
+
+                    default:
+                        // assumes that we initialized the diveColorMap table
+                        Q_ASSERT(dstBpp == 2);
+                        do {
+                            PUSHORT temp = (PUSHORT)dstBits;
+                            for (i = 0; i < cols; ++i) {
+                               *temp++ = (USHORT)
+                                    (diveColorMap[0][srcBits[0]] |
+                                     diveColorMap[1][srcBits[1]] |
+                                     diveColorMap[2][srcBits[2]]);
+                               srcBits += 4;
+                            }
+                            srcBits += srcBytesPerLine - (cols * 4);
+                            dstBits += diveCaps.ulScanLineBytes;
+                        } while(--rows);
+                        break;
+                    }
+                }
+            }
+        }
+
+        DiveDeacquireFrameBuffer(d->hDive);
+    }
+}
+
 QT_END_NAMESPACE