Long live Qt 4.5!

1 files changed, 8248 insertions, 0 deletions

diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
new file mode 100644
index 0000000..efdc778
--- /dev/null
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -0,0 +1,8248 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <private/qdrawhelper_p.h>
+#include <private/qpaintengine_raster_p.h>
+#include <private/qpainter_p.h>
+#include <private/qdrawhelper_x86_p.h>
+#include <private/qmath_p.h>
+#include <qmath.h>
+
+QT_BEGIN_NAMESPACE
+
+#define MASK(src, a) src = BYTE_MUL(src, a)
+
+#if defined(Q_OS_IRIX) && defined(Q_CC_GNU) && __GNUC__ == 3 && __GNUC__ < 4 && QT_POINTER_SIZE == 8
+#define Q_IRIX_GCC3_3_WORKAROUND
+//
+// work around http://gcc.gnu.org/bugzilla/show_bug.cgi?id=14484
+//
+static uint gccBug(uint value) __attribute__((noinline));
+static uint gccBug(uint value)
+{
+    return value;
+}
+#endif
+
+/*
+  constants and structures
+*/
+
+static const int fixed_scale = 1 << 16;
+static const int half_point = 1 << 15;
+static const int buffer_size = 2048;
+
+struct LinearGradientValues
+{
+    qreal dx;
+    qreal dy;
+    qreal l;
+    qreal off;
+};
+
+struct RadialGradientValues
+{
+    qreal dx;
+    qreal dy;
+    qreal a;
+};
+
+struct Operator;
+typedef uint* (QT_FASTCALL *DestFetchProc)(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length);
+typedef void (QT_FASTCALL *DestStoreProc)(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length);
+typedef const uint* (QT_FASTCALL *SourceFetchProc)(uint *buffer, const Operator *o, const QSpanData *data, int y, int x, int length);
+
+
+struct Operator
+{
+    QPainter::CompositionMode mode;
+    DestFetchProc dest_fetch;
+    DestStoreProc dest_store;
+    SourceFetchProc src_fetch;
+    CompositionFunctionSolid funcSolid;
+    CompositionFunction func;
+    union {
+        LinearGradientValues linear;
+        RadialGradientValues radial;
+//        TextureValues texture;
+    };
+};
+
+/*
+  Destination fetch. This is simple as we don't have to do bounds checks or
+  transformations
+*/
+
+static uint * QT_FASTCALL destFetchMono(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
+{
+    uchar *data = (uchar *)rasterBuffer->scanLine(y);
+    uint *start = buffer;
+    const uint *end = buffer + length;
+    while (buffer < end) {
+        *buffer = data[x>>3] & (0x80 >> (x & 7)) ? rasterBuffer->destColor1 : rasterBuffer->destColor0;
+        ++buffer;
+        ++x;
+    }
+    return start;
+}
+
+static uint * QT_FASTCALL destFetchMonoLsb(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
+{
+    uchar *data = (uchar *)rasterBuffer->scanLine(y);
+    uint *start = buffer;
+    const uint *end = buffer + length;
+    while (buffer < end) {
+        *buffer = data[x>>3] & (0x1 << (x & 7)) ? rasterBuffer->destColor1 : rasterBuffer->destColor0;
+        ++buffer;
+        ++x;
+    }
+    return start;
+}
+
+static uint * QT_FASTCALL destFetchARGB32(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
+{
+    const uint *data = (const uint *)rasterBuffer->scanLine(y) + x;
+    for (int i = 0; i < length; ++i)
+        buffer[i] = PREMUL(data[i]);
+    return buffer;
+}
+
+static uint * QT_FASTCALL destFetchARGB32P(uint *, QRasterBuffer *rasterBuffer, int x, int y, int)
+{
+    return (uint *)rasterBuffer->scanLine(y) + x;
+}
+
+static uint * QT_FASTCALL destFetchRGB16(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
+{
+    const ushort *data = (const ushort *)rasterBuffer->scanLine(y) + x;
+    for (int i = 0; i < length; ++i)
+        buffer[i] = qConvertRgb16To32(data[i]);
+    return buffer;
+}
+
+#if defined(Q_CC_MSVC) && _MSC_VER <= 1300 && !defined(Q_CC_INTEL)
+template <typename EnumType, int value>
+class QEnumToType
+{
+public:
+    inline EnumType operator()() const
+    {
+        return EnumType(value);
+    }
+};
+template <QImage::Format format>
+class QImageFormatToType
+{
+public:
+    inline QImage::Format operator()() const
+    {
+        return format;
+    }
+};
+// Would have used QEnumToType instead of creating a specialized version for QImageFormatToType,
+// but that causes internal compiler error on VC6
+#define Q_TEMPLATE_IMAGEFORMAT_FIX(format) , const QImageFormatToType<format> &imageFormatType
+#define Q_TEMPLATE_IMAGEFORMAT_CALL(format) , QImageFormatToType<format>()
+#define Q_TEMPLATE_ENUM_FIX(Type, Value) , const QEnumToType<Type, Value> &enumTemplateType
+#define Q_TEMPLATE_ENUM_CALL(Type, Value) , QEnumToType<Type, Value>()
+#define Q_TEMPLATE_FIX(Type) , const QTypeInfo<Type> &templateType
+#define Q_TEMPLATE_CALL(Type) , QTypeInfo<Type>()
+#else
+#define Q_TEMPLATE_IMAGEFORMAT_FIX(format)
+#define Q_TEMPLATE_IMAGEFORMAT_CALL(format)
+#define Q_TEMPLATE_ENUM_FIX(Type, Value)
+#define Q_TEMPLATE_ENUM_CALL(Type, Value)
+#define Q_TEMPLATE_FIX(Type)
+#define Q_TEMPLATE_CALL(Type)
+#endif
+
+template <class DST>
+Q_STATIC_TEMPLATE_FUNCTION uint * QT_FASTCALL destFetch(uint *buffer, QRasterBuffer *rasterBuffer,
+                                    int x, int y, int length
+                                    Q_TEMPLATE_FIX(DST))
+{
+    const DST *src = reinterpret_cast<DST*>(rasterBuffer->scanLine(y)) + x;
+    quint32 *dest = reinterpret_cast<quint32*>(buffer);
+    while (length--)
+        *dest++ = *src++;
+    return buffer;
+}
+
+#if defined(Q_CC_MSVC) && _MSC_VER <= 1300 && !defined(Q_CC_INTEL)
+#define DEST_FETCH_DECL(DST)                                            \
+    static uint * QT_FASTCALL destFetch_##DST(uint *buffer,             \
+                                              QRasterBuffer *rasterBuffer, \
+                                              int x, int y, int length) \
+    {                                                                   \
+        return destFetch<DST>(buffer, rasterBuffer, x, y, length Q_TEMPLATE_CALL(DST));      \
+    }
+
+DEST_FETCH_DECL(qargb8565)
+DEST_FETCH_DECL(qrgb666)
+DEST_FETCH_DECL(qargb6666)
+DEST_FETCH_DECL(qrgb555)
+DEST_FETCH_DECL(qrgb888)
+DEST_FETCH_DECL(qargb8555)
+DEST_FETCH_DECL(qrgb444)
+DEST_FETCH_DECL(qargb4444)
+#undef DEST_FETCH_DECL
+# define SPANFUNC_POINTER_DESTFETCH(Arg) destFetch_##Arg
+#else // !VC6 && !VC2002
+# define SPANFUNC_POINTER_DESTFETCH(Arg) destFetch<Arg>
+#endif
+
+static const DestFetchProc destFetchProc[QImage::NImageFormats] =
+{
+    0, // Format_Invalid
+    destFetchMono, // Format_Mono,
+    destFetchMonoLsb, // Format_MonoLSB
+    0, // Format_Indexed8
+    destFetchARGB32P, // Format_RGB32
+    destFetchARGB32, // Format_ARGB32,
+    destFetchARGB32P, // Format_ARGB32_Premultiplied
+    destFetchRGB16,   // Format_RGB16
+    SPANFUNC_POINTER_DESTFETCH(qargb8565), // Format_ARGB8565_Premultiplied
+    SPANFUNC_POINTER_DESTFETCH(qrgb666),   // Format_RGB666
+    SPANFUNC_POINTER_DESTFETCH(qargb6666), // Format_ARGB6666_Premultiplied
+    SPANFUNC_POINTER_DESTFETCH(qrgb555),   // Format_RGB555
+    SPANFUNC_POINTER_DESTFETCH(qargb8555), // Format_ARGB8555_Premultiplied
+    SPANFUNC_POINTER_DESTFETCH(qrgb888),   // Format_RGB888
+    SPANFUNC_POINTER_DESTFETCH(qrgb444),   // Format_RGB444
+    SPANFUNC_POINTER_DESTFETCH(qargb4444)  // Format_ARGB4444_Premultiplied
+};
+
+/*
+   Returns the color in the mono destination color table
+   that is the "nearest" to /color/.
+*/
+static inline QRgb findNearestColor(QRgb color, QRasterBuffer *rbuf)
+{
+    QRgb color_0 = PREMUL(rbuf->destColor0);
+    QRgb color_1 = PREMUL(rbuf->destColor1);
+    color = PREMUL(color);
+
+    int r = qRed(color);
+    int g = qGreen(color);
+    int b = qBlue(color);
+    int rx, gx, bx;
+    int dist_0, dist_1;
+
+    rx = r - qRed(color_0);
+    gx = g - qGreen(color_0);
+    bx = b - qBlue(color_0);
+    dist_0 = rx*rx + gx*gx + bx*bx;
+
+    rx = r - qRed(color_1);
+    gx = g - qGreen(color_1);
+    bx = b - qBlue(color_1);
+    dist_1 = rx*rx + gx*gx + bx*bx;
+
+    if (dist_0 < dist_1)
+        return color_0;
+    return color_1;
+}
+
+/*
+  Destination store.
+*/
+
+static void QT_FASTCALL destStoreMono(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
+{
+    uchar *data = (uchar *)rasterBuffer->scanLine(y);
+    if (rasterBuffer->monoDestinationWithClut) {
+        for (int i = 0; i < length; ++i) {
+            if (buffer[i] == rasterBuffer->destColor0) {
+                data[x >> 3] &= ~(0x80 >> (x & 7));
+            } else if (buffer[i] == rasterBuffer->destColor1) {
+                data[x >> 3] |= 0x80 >> (x & 7);
+            } else if (findNearestColor(buffer[i], rasterBuffer) == rasterBuffer->destColor0) {
+                data[x >> 3] &= ~(0x80 >> (x & 7));
+            } else {
+                data[x >> 3] |= 0x80 >> (x & 7);
+            }
+            ++x;
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            if (qGray(buffer[i]) < int(qt_bayer_matrix[y & 15][x & 15]))
+                data[x >> 3] |= 0x80 >> (x & 7);
+            else
+                data[x >> 3] &= ~(0x80 >> (x & 7));
+            ++x;
+        }
+    }
+}
+
+static void QT_FASTCALL destStoreMonoLsb(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
+{
+    uchar *data = (uchar *)rasterBuffer->scanLine(y);
+    if (rasterBuffer->monoDestinationWithClut) {
+        for (int i = 0; i < length; ++i) {
+            if (buffer[i] == rasterBuffer->destColor0) {
+                data[x >> 3] &= ~(1 << (x & 7));
+            } else if (buffer[i] == rasterBuffer->destColor1) {
+                data[x >> 3] |= 1 << (x & 7);
+            } else if (findNearestColor(buffer[i], rasterBuffer) == rasterBuffer->destColor0) {
+                data[x >> 3] &= ~(1 << (x & 7));
+            } else {
+                data[x >> 3] |= 1 << (x & 7);
+            }
+            ++x;
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            if (qGray(buffer[i]) < int(qt_bayer_matrix[y & 15][x & 15]))
+                data[x >> 3] |= 1 << (x & 7);
+            else
+                data[x >> 3] &= ~(1 << (x & 7));
+            ++x;
+        }
+    }
+}
+
+static void QT_FASTCALL destStoreARGB32(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
+{
+    uint *data = (uint *)rasterBuffer->scanLine(y) + x;
+    for (int i = 0; i < length; ++i) {
+        int p = buffer[i];
+        int alpha = qAlpha(p);
+        if (alpha == 255)
+            data[i] = p;
+        else if (alpha == 0)
+            data[i] = 0;
+        else {
+            int inv_alpha = 0xff0000/qAlpha(buffer[i]);
+            data[i] = (p & 0xff000000)
+                      | ((qRed(p)*inv_alpha) & 0xff0000)
+                      | (((qGreen(p)*inv_alpha) >> 8) & 0xff00)
+                      | ((qBlue(p)*inv_alpha) >> 16);
+        }
+    }
+}
+
+static void QT_FASTCALL destStoreRGB16(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
+{
+    quint16 *data = (quint16*)rasterBuffer->scanLine(y) + x;
+    qt_memconvert<quint16, quint32>(data, buffer, length);
+}
+
+template <class DST>
+Q_STATIC_TEMPLATE_FUNCTION void QT_FASTCALL destStore(QRasterBuffer *rasterBuffer,
+                                  int x, int y,
+                                  const uint *buffer, int length
+                                  Q_TEMPLATE_FIX(DST))
+{
+    DST *dest = reinterpret_cast<DST*>(rasterBuffer->scanLine(y)) + x;
+    const quint32 *src = reinterpret_cast<const quint32*>(buffer);
+    while (length--)
+        *dest++ = DST(*src++);
+}
+
+#if defined(Q_CC_MSVC) && _MSC_VER <= 1300 && !defined(Q_CC_INTEL)
+# define DEST_STORE_DECL(DST)                                           \
+    static void QT_FASTCALL destStore_##DST(QRasterBuffer *rasterBuffer, \
+                                            int x, int y,               \
+                                            const uint *buffer, int length) \
+    {                                                                   \
+        destStore<DST>(rasterBuffer, x, y, buffer, length Q_TEMPLATE_CALL(DST));             \
+    }
+
+DEST_STORE_DECL(qargb8565)
+DEST_STORE_DECL(qrgb555)
+DEST_STORE_DECL(qrgb666)
+DEST_STORE_DECL(qargb6666)
+DEST_STORE_DECL(qargb8555)
+DEST_STORE_DECL(qrgb888)
+DEST_STORE_DECL(qrgb444)
+DEST_STORE_DECL(qargb4444)
+# undef DEST_FETCH_DECL
+# define SPANFUNC_POINTER_DESTSTORE(DEST) destStore_##DEST
+#else // !VC6 && !VC2002
+# define SPANFUNC_POINTER_DESTSTORE(DEST) destStore<DEST>
+#endif
+
+static const DestStoreProc destStoreProc[QImage::NImageFormats] =
+{
+    0, // Format_Invalid
+    destStoreMono, // Format_Mono,
+    destStoreMonoLsb, // Format_MonoLSB
+    0, // Format_Indexed8
+    0, // Format_RGB32
+    destStoreARGB32, // Format_ARGB32,
+    0, // Format_ARGB32_Premultiplied
+    destStoreRGB16, // Format_RGB16
+    SPANFUNC_POINTER_DESTSTORE(qargb8565), // Format_ARGB8565_Premultiplied
+    SPANFUNC_POINTER_DESTSTORE(qrgb666),   // Format_RGB666
+    SPANFUNC_POINTER_DESTSTORE(qargb6666), // Format_ARGB6666_Premultiplied
+    SPANFUNC_POINTER_DESTSTORE(qrgb555),   // Format_RGB555
+    SPANFUNC_POINTER_DESTSTORE(qargb8555), // Format_ARGB8555_Premultiplied
+    SPANFUNC_POINTER_DESTSTORE(qrgb888),   // Format_RGB888
+    SPANFUNC_POINTER_DESTSTORE(qrgb444),   // Format_RGB444
+    SPANFUNC_POINTER_DESTSTORE(qargb4444)  // Format_ARGB4444_Premultiplied
+};
+
+/*
+  Source fetches
+
+  This is a bit more complicated, as we need several fetch routines for every surface type
+
+  We need 5 fetch methods per surface type:
+  untransformed
+  transformed
+  transformed tiled
+  transformed bilinear
+  transformed bilinear tiled
+
+  We don't need bounds checks for untransformed, but we need them for the other ones.
+
+  The generic implementation does pixel by pixel fetches
+*/
+
+template <QImage::Format format>
+Q_STATIC_TEMPLATE_FUNCTION uint QT_FASTCALL qt_fetchPixel(const uchar *scanLine, int x, const QVector<QRgb> *rgb
+                                   Q_TEMPLATE_IMAGEFORMAT_FIX(format));
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_Mono>(const uchar *scanLine,
+                                                 int x, const QVector<QRgb> *rgb
+                                                 Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_Mono))
+{
+    bool pixel = scanLine[x>>3] & (0x80 >> (x & 7));
+    if (rgb) return PREMUL(rgb->at(pixel ? 1 : 0));
+    return pixel ? 0xff000000 : 0xffffffff;
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_MonoLSB>(const uchar *scanLine,
+                                                    int x, const QVector<QRgb> *rgb
+                                                    Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_MonoLSB))
+{
+    bool pixel = scanLine[x>>3] & (0x1 << (x & 7));
+    if (rgb) return PREMUL(rgb->at(pixel ? 1 : 0));
+    return pixel ? 0xff000000 : 0xffffffff;
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_Indexed8>(const uchar *scanLine,
+                                                     int x, const QVector<QRgb> *rgb
+                                                     Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_Indexed8))
+{
+    return PREMUL(rgb->at(scanLine[x]));
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB32>(const uchar *scanLine,
+                                                   int x, const QVector<QRgb> *
+                                                   Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_ARGB32))
+{
+    return PREMUL(((const uint *)scanLine)[x]);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB32_Premultiplied>(const uchar *scanLine,
+                                                                 int x, const QVector<QRgb> *
+                                                                 Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_ARGB32_Premultiplied))
+{
+    return ((const uint *)scanLine)[x];
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB16>(const uchar *scanLine,
+                                                  int x, const QVector<QRgb> *
+                                                  Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_RGB16))
+{
+    return qConvertRgb16To32(((const ushort *)scanLine)[x]);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB8565_Premultiplied>(const uchar *scanLine,
+                                                     int x,
+                                                     const QVector<QRgb> *
+                                                     Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_ARGB8565_Premultiplied))
+{
+    const qargb8565 color = reinterpret_cast<const qargb8565*>(scanLine)[x];
+    return qt_colorConvert<quint32, qargb8565>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB666>(const uchar *scanLine,
+                                                   int x,
+                                                   const QVector<QRgb> *
+                                                   Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_RGB666))
+{
+    const qrgb666 color = reinterpret_cast<const qrgb666*>(scanLine)[x];
+    return qt_colorConvert<quint32, qrgb666>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB6666_Premultiplied>(const uchar *scanLine,
+                                                   int x,
+                                                   const QVector<QRgb> *
+                                                   Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_ARGB6666_Premultiplied))
+{
+    const qargb6666 color = reinterpret_cast<const qargb6666*>(scanLine)[x];
+    return qt_colorConvert<quint32, qargb6666>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB555>(const uchar *scanLine,
+                                                   int x,
+                                                   const QVector<QRgb> *
+                                                   Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_RGB555))
+{
+    const qrgb555 color = reinterpret_cast<const qrgb555*>(scanLine)[x];
+    return qt_colorConvert<quint32, qrgb555>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB8555_Premultiplied>(const uchar *scanLine,
+                                                     int x,
+                                                     const QVector<QRgb> *
+                                                     Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_ARGB8555_Premultiplied))
+{
+    const qargb8555 color = reinterpret_cast<const qargb8555*>(scanLine)[x];
+    return qt_colorConvert<quint32, qargb8555>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB888>(const uchar *scanLine,
+                                                   int x,
+                                                   const QVector<QRgb> *
+                                                   Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_RGB888))
+{
+    const qrgb888 color = reinterpret_cast<const qrgb888*>(scanLine)[x];
+    return qt_colorConvert<quint32, qrgb888>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_RGB444>(const uchar *scanLine,
+                                                   int x,
+                                                   const QVector<QRgb> *
+                                                   Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_RGB444))
+{
+    const qrgb444 color = reinterpret_cast<const qrgb444*>(scanLine)[x];
+    return qt_colorConvert<quint32, qrgb444>(color, 0);
+}
+
+template<>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+uint QT_FASTCALL qt_fetchPixel<QImage::Format_ARGB4444_Premultiplied>(const uchar *scanLine,
+                                                     int x,
+                                                     const QVector<QRgb> *
+                                                     Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_ARGB4444_Premultiplied))
+{
+    const qargb4444 color = reinterpret_cast<const qargb4444*>(scanLine)[x];
+    return qt_colorConvert<quint32, qargb4444>(color, 0);
+}
+
+typedef uint (QT_FASTCALL *FetchPixelProc)(const uchar *scanLine, int x, const QVector<QRgb> *);
+
+#if defined(Q_CC_MSVC) && _MSC_VER <= 1300 && !defined(Q_CC_INTEL)
+
+// explicit template instantiations needed to compile with VC6 and VC2002
+
+#define SPANFUNC_INSTANTIATION_FETCHPIXEL(Arg)  \
+        static inline uint fetchPixel_##Arg(const uchar * scanLine, int x, const QVector<QRgb> * rgb) \
+{ \
+        return qt_fetchPixel<QImage::Arg>(scanLine, x, rgb Q_TEMPLATE_IMAGEFORMAT_CALL(QImage::Arg)); \
+}
+
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_Mono);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_MonoLSB);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_Indexed8);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_ARGB32_Premultiplied);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_ARGB32);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_RGB16);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_ARGB8565_Premultiplied);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_RGB666);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_ARGB6666_Premultiplied);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_RGB555);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_ARGB8555_Premultiplied);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_RGB888);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_RGB444);
+SPANFUNC_INSTANTIATION_FETCHPIXEL(Format_ARGB4444_Premultiplied);
+
+#undef SPANFUNC_INSTANTIATION_FETCHPIXEL
+
+#define SPANFUNC_POINTER_FETCHPIXEL(Arg) fetchPixel_##Arg
+
+#else // !VC6 && !VC2002
+# define SPANFUNC_POINTER_FETCHPIXEL(Arg) qt_fetchPixel<QImage::Arg>
+#endif
+
+
+static const FetchPixelProc fetchPixelProc[QImage::NImageFormats] =
+{
+    0,
+    SPANFUNC_POINTER_FETCHPIXEL(Format_Mono),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_MonoLSB),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_Indexed8),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB32_Premultiplied),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB32),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB32_Premultiplied),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB16),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB8565_Premultiplied),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB666),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB6666_Premultiplied),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB555),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB8555_Premultiplied),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB888),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_RGB444),
+    SPANFUNC_POINTER_FETCHPIXEL(Format_ARGB4444_Premultiplied)
+};
+
+enum TextureBlendType {
+    BlendUntransformed,
+    BlendTiled,
+    BlendTransformed,
+    BlendTransformedTiled,
+    BlendTransformedBilinear,
+    BlendTransformedBilinearTiled,
+    NBlendTypes
+};
+
+template <QImage::Format format>
+Q_STATIC_TEMPLATE_FUNCTION const uint * QT_FASTCALL qt_fetchUntransformed(uint *buffer, const Operator *, const QSpanData *data,
+                                             int y, int x, int length Q_TEMPLATE_IMAGEFORMAT_FIX(format))
+{
+    const uchar *scanLine = data->texture.scanLine(y);
+    for (int i = 0; i < length; ++i)
+        buffer[i] = qt_fetchPixel<format>(scanLine, x + i, data->texture.colorTable Q_TEMPLATE_IMAGEFORMAT_CALL(format));
+    return buffer;
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION const uint * QT_FASTCALL
+qt_fetchUntransformed<QImage::Format_ARGB32_Premultiplied>(uint *, const Operator *,
+                                                         const QSpanData *data,
+                                                         int y, int x, int Q_TEMPLATE_IMAGEFORMAT_FIX(QImage::Format_ARGB32_Premultiplied))
+{
+    const uchar *scanLine = data->texture.scanLine(y);
+    return ((const uint *)scanLine) + x;
+}
+
+static const uint * QT_FASTCALL fetchTransformed(uint *buffer, const Operator *, const QSpanData *data,
+                                                         int y, int x, int length)
+{
+    FetchPixelProc fetch = fetchPixelProc[data->texture.format];
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+
+    const qreal cx = x + 0.5;
+    const qreal cy = y + 0.5;
+
+    const uint *end = buffer + length;
+    uint *b = buffer;
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        int fx = int((data->m21 * cy
+                      + data->m11 * cx + data->dx) * fixed_scale);
+        int fy = int((data->m22 * cy
+                      + data->m12 * cx + data->dy) * fixed_scale);
+
+        while (b < end) {
+            int px = fx >> 16;
+            int py = fy >> 16;
+
+            bool out = (px < 0) || (px >= image_width)
+                       || (py < 0) || (py >= image_height);
+
+            const uchar *scanLine = data->texture.scanLine(py);
+            *b = out ? uint(0) : fetch(scanLine, px, data->texture.colorTable);
+            fx += fdx;
+            fy += fdy;
+            ++b;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        qreal fx = data->m21 * cy + data->m11 * cx + data->dx;
+        qreal fy = data->m22 * cy + data->m12 * cx + data->dy;
+        qreal fw = data->m23 * cy + data->m13 * cx + data->m33;
+
+        while (b < end) {
+            const qreal iw = fw == 0 ? 1 : 1 / fw;
+            const qreal tx = fx * iw;
+            const qreal ty = fy * iw;
+            const int px = int(tx) - (tx < 0);
+            const int py = int(ty) - (ty < 0);
+
+            bool out = (px < 0) || (px >= image_width)
+                       || (py < 0) || (py >= image_height);
+
+            const uchar *scanLine = data->texture.scanLine(py);
+            *b = out ? uint(0) : fetch(scanLine, px, data->texture.colorTable);
+            fx += fdx;
+            fy += fdy;
+            fw += fdw;
+            //force increment to avoid /0
+            if (!fw) {
+                fw += fdw;
+            }
+            ++b;
+        }
+    }
+
+    return buffer;
+}
+
+static const uint * QT_FASTCALL fetchTransformedTiled(uint *buffer, const Operator *, const QSpanData *data,
+                                                              int y, int x, int length)
+{
+    FetchPixelProc fetch = fetchPixelProc[data->texture.format];
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+
+    const qreal cx = x + 0.5;
+    const qreal cy = y + 0.5;
+
+    const uint *end = buffer + length;
+    uint *b = buffer;
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        int fx = int((data->m21 * cy
+                      + data->m11 * cx + data->dx) * fixed_scale);
+        int fy = int((data->m22 * cy
+                      + data->m12 * cx + data->dy) * fixed_scale);
+
+        while (b < end) {
+            int px = fx >> 16;
+            int py = fy >> 16;
+
+            px %= image_width;
+            py %= image_height;
+            if (px < 0) px += image_width;
+            if (py < 0) py += image_height;
+
+            const uchar *scanLine = data->texture.scanLine(py);
+            *b = fetch(scanLine, px, data->texture.colorTable);
+            fx += fdx;
+            fy += fdy;
+            ++b;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        qreal fx = data->m21 * cy + data->m11 * cx + data->dx;
+        qreal fy = data->m22 * cy + data->m12 * cx + data->dy;
+        qreal fw = data->m23 * cy + data->m13 * cx + data->m33;
+
+        while (b < end) {
+            const qreal iw = fw == 0 ? 1 : 1 / fw;
+            const qreal tx = fx * iw;
+            const qreal ty = fy * iw;
+            int px = int(tx) - (tx < 0);
+            int py = int(ty) - (ty < 0);
+
+            px %= image_width;
+            py %= image_height;
+            if (px < 0) px += image_width;
+            if (py < 0) py += image_height;
+
+            const uchar *scanLine = data->texture.scanLine(py);
+            *b = fetch(scanLine, px, data->texture.colorTable);
+            fx += fdx;
+            fy += fdy;
+            fw += fdw;
+            //force increment to avoid /0
+            if (!fw) {
+                fw += fdw;
+            }
+            ++b;
+        }
+    }
+
+    return buffer;
+}
+
+static const uint * QT_FASTCALL fetchTransformedBilinear(uint *buffer, const Operator *, const QSpanData *data,
+                                                                 int y, int x, int length)
+{
+    FetchPixelProc fetch = fetchPixelProc[data->texture.format];
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+
+    const qreal cx = x + 0.5;
+    const qreal cy = y + 0.5;
+
+    const uint *end = buffer + length;
+    uint *b = buffer;
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        int fx = int((data->m21 * cy
+                      + data->m11 * cx + data->dx) * fixed_scale);
+        int fy = int((data->m22 * cy
+                      + data->m12 * cx + data->dy) * fixed_scale);
+
+        fx -= half_point;
+        fy -= half_point;
+        while (b < end) {
+            int x1 = (fx >> 16);
+            int x2 = x1 + 1;
+            int y1 = (fy >> 16);
+            int y2 = y1 + 1;
+
+            int distx = ((fx - (x1 << 16)) >> 8);
+            int disty = ((fy - (y1 << 16)) >> 8);
+            int idistx = 256 - distx;
+            int idisty = 256 - disty;
+
+            x1 = qBound(0, x1, image_width - 1);
+            x2 = qBound(0, x2, image_width - 1);
+            y1 = qBound(0, y1, image_height - 1);
+            y2 = qBound(0, y2, image_height - 1);
+
+            const uchar *s1 = data->texture.scanLine(y1);
+            const uchar *s2 = data->texture.scanLine(y2);
+
+            uint tl = fetch(s1, x1, data->texture.colorTable);
+            uint tr = fetch(s1, x2, data->texture.colorTable);
+            uint bl = fetch(s2, x1, data->texture.colorTable);
+            uint br = fetch(s2, x2, data->texture.colorTable);
+
+            uint xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+            uint xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+            *b = INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+
+            fx += fdx;
+            fy += fdy;
+            ++b;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        qreal fx = data->m21 * cy + data->m11 * cx + data->dx;
+        qreal fy = data->m22 * cy + data->m12 * cx + data->dy;
+        qreal fw = data->m23 * cy + data->m13 * cx + data->m33;
+
+        while (b < end) {
+            const qreal iw = fw == 0 ? 1 : 1 / fw;
+            const qreal px = fx * iw - 0.5;
+            const qreal py = fy * iw - 0.5;
+
+            int x1 = int(px) - (px < 0);
+            int x2 = x1 + 1;
+            int y1 = int(py) - (py < 0);
+            int y2 = y1 + 1;
+
+            int distx = int((px - x1) * 256);
+            int disty = int((py - y1) * 256);
+            int idistx = 256 - distx;
+            int idisty = 256 - disty;
+
+            x1 = qBound(0, x1, image_width - 1);
+            x2 = qBound(0, x2, image_width - 1);
+            y1 = qBound(0, y1, image_height - 1);
+            y2 = qBound(0, y2, image_height - 1);
+
+            const uchar *s1 = data->texture.scanLine(y1);
+            const uchar *s2 = data->texture.scanLine(y2);
+
+            uint tl = fetch(s1, x1, data->texture.colorTable);
+            uint tr = fetch(s1, x2, data->texture.colorTable);
+            uint bl = fetch(s2, x1, data->texture.colorTable);
+            uint br = fetch(s2, x2, data->texture.colorTable);
+
+            uint xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+            uint xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+            *b = INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+
+            fx += fdx;
+            fy += fdy;
+            fw += fdw;
+            //force increment to avoid /0
+            if (!fw) {
+                fw += fdw;
+            }
+            ++b;
+        }
+    }
+
+    return buffer;
+}
+
+static const uint * QT_FASTCALL fetchTransformedBilinearTiled(uint *buffer, const Operator *, const QSpanData *data,
+                                                                     int y, int x, int length)
+{
+    FetchPixelProc fetch = fetchPixelProc[data->texture.format];
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+
+    const qreal cx = x + 0.5;
+    const qreal cy = y + 0.5;
+
+    const uint *end = buffer + length;
+    uint *b = buffer;
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        int fx = int((data->m21 * cy + data->m11 * cx + data->dx) * fixed_scale);
+        int fy = int((data->m22 * cy + data->m12 * cx + data->dy) * fixed_scale);
+
+        fx -= half_point;
+        fy -= half_point;
+        while (b < end) {
+            int x1 = (fx >> 16);
+            int x2 = x1 + 1;
+            int y1 = (fy >> 16);
+            int y2 = y1 + 1;
+
+            int distx = ((fx - (x1 << 16)) >> 8);
+            int disty = ((fy - (y1 << 16)) >> 8);
+            int idistx = 256 - distx;
+            int idisty = 256 - disty;
+
+            x1 %= image_width;
+            x2 %= image_width;
+            y1 %= image_height;
+            y2 %= image_height;
+
+            if (x1 < 0) x1 += image_width;
+            if (x2 < 0) x2 += image_width;
+            if (y1 < 0) y1 += image_height;
+            if (y2 < 0) y2 += image_height;
+
+            Q_ASSERT(x1 >= 0 && x1 < image_width);
+            Q_ASSERT(x2 >= 0 && x2 < image_width);
+            Q_ASSERT(y1 >= 0 && y1 < image_height);
+            Q_ASSERT(y2 >= 0 && y2 < image_height);
+
+            const uchar *s1 = data->texture.scanLine(y1);
+            const uchar *s2 = data->texture.scanLine(y2);
+
+            uint tl = fetch(s1, x1, data->texture.colorTable);
+            uint tr = fetch(s1, x2, data->texture.colorTable);
+            uint bl = fetch(s2, x1, data->texture.colorTable);
+            uint br = fetch(s2, x2, data->texture.colorTable);
+
+            uint xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+            uint xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+            *b = INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+
+            fx += fdx;
+            fy += fdy;
+            ++b;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        qreal fx = data->m21 * cy + data->m11 * cx + data->dx;
+        qreal fy = data->m22 * cy + data->m12 * cx + data->dy;
+        qreal fw = data->m23 * cy + data->m13 * cx + data->m33;
+
+        while (b < end) {
+            const qreal iw = fw == 0 ? 1 : 1 / fw;
+            const qreal px = fx * iw - 0.5;
+            const qreal py = fy * iw - 0.5;
+
+            int x1 = int(px) - (px < 0);
+            int x2 = x1 + 1;
+            int y1 = int(py) - (py < 0);
+            int y2 = y1 + 1;
+
+            int distx = int((px - x1) * 256);
+            int disty = int((py - y1) * 256);
+            int idistx = 256 - distx;
+            int idisty = 256 - disty;
+
+            x1 %= image_width;
+            x2 %= image_width;
+            y1 %= image_height;
+            y2 %= image_height;
+
+            if (x1 < 0) x1 += image_width;
+            if (x2 < 0) x2 += image_width;
+            if (y1 < 0) y1 += image_height;
+            if (y2 < 0) y2 += image_height;
+
+            Q_ASSERT(x1 >= 0 && x1 < image_width);
+            Q_ASSERT(x2 >= 0 && x2 < image_width);
+            Q_ASSERT(y1 >= 0 && y1 < image_height);
+            Q_ASSERT(y2 >= 0 && y2 < image_height);
+
+            const uchar *s1 = data->texture.scanLine(y1);
+            const uchar *s2 = data->texture.scanLine(y2);
+
+            uint tl = fetch(s1, x1, data->texture.colorTable);
+            uint tr = fetch(s1, x2, data->texture.colorTable);
+            uint bl = fetch(s2, x1, data->texture.colorTable);
+            uint br = fetch(s2, x2, data->texture.colorTable);
+
+            uint xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+            uint xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+            *b = INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+
+            fx += fdx;
+            fy += fdy;
+            fw += fdw;
+            //force increment to avoid /0
+            if (!fw) {
+                fw += fdw;
+            }
+            ++b;
+        }
+    }
+
+    return buffer;
+}
+
+#if defined(Q_CC_MSVC) && _MSC_VER <= 1300 && !defined(Q_CC_INTEL)
+
+// explicit template instantiations needed to compile with VC6 and VC2002
+
+#define SPANFUNC_POINTER_FETCHUNTRANSFORMED(Arg)  \
+        const uint *qt_fetchUntransformed_##Arg(uint *buffer, const Operator *op, const QSpanData *data, \
+                                             int y, int x, int length) \
+{ \
+        return qt_fetchUntransformed<QImage::Arg>(buffer, op, data, y, x, length Q_TEMPLATE_IMAGEFORMAT_CALL(QImage::Arg)); \
+}
+
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_Mono);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_MonoLSB);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_Indexed8);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_ARGB32_Premultiplied);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_ARGB32);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_RGB16);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_ARGB8565_Premultiplied);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_RGB666);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_ARGB6666_Premultiplied);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_RGB555);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_ARGB8555_Premultiplied);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_RGB888);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_RGB444);
+SPANFUNC_POINTER_FETCHUNTRANSFORMED(Format_ARGB4444_Premultiplied);
+
+#undef SPANFUNC_POINTER_FETCHUNTRANSFORMED
+
+#define SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Arg) qt_fetchUntransformed_##Arg
+
+#else // !VC6 && !VC2002
+# define SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Arg) qt_fetchUntransformed<QImage::Arg>
+#endif
+
+static const SourceFetchProc sourceFetch[NBlendTypes][QImage::NImageFormats] = {
+    // Untransformed
+    {
+        0, // Invalid
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_Mono),   // Mono
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_MonoLSB),   // MonoLsb
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_Indexed8),   // Indexed8
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32_Premultiplied),   // RGB32
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32),   // ARGB32
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32_Premultiplied),   // ARGB32_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB16),   // RGB16
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB8565_Premultiplied),// ARGB8565_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB666),  // RGB666
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB6666_Premultiplied),// ARGB6666_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB555),  // RGB555
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB8555_Premultiplied),// ARGB8555_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB888),  // RGB888
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB444),  // RGB444
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB4444_Premultiplied) // ARGB4444_Premultiplied
+    },
+    // Tiled
+    {
+        0, // Invalid
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_Mono),   // Mono
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_MonoLSB),   // MonoLsb
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_Indexed8),   // Indexed8
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32_Premultiplied),   // RGB32
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32),   // ARGB32
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB32_Premultiplied),   // ARGB32_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB16),   // RGB16
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB8565_Premultiplied),// ARGB8565_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB666),  // RGB666
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB6666_Premultiplied),// ARGB6666_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB555),  // RGB555
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB8555_Premultiplied),// ARGB8555_Premultiplied
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB888),  // RGB888
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_RGB444),  // RGB444
+        SPANFUNC_POINTER_FETCHHUNTRANSFORMED(Format_ARGB4444_Premultiplied) // ARGB4444_Premultiplied
+    },
+    // Transformed
+    {
+        0, // Invalid
+        fetchTransformed,   // Mono
+        fetchTransformed,   // MonoLsb
+        fetchTransformed,   // Indexed8
+        fetchTransformed,   // RGB32
+        fetchTransformed,   // ARGB32
+        fetchTransformed,   // ARGB32_Premultiplied
+        fetchTransformed,   // RGB16
+        fetchTransformed,   // ARGB8565_Premultiplied
+        fetchTransformed,   // RGB666
+        fetchTransformed,   // ARGB6666_Premultiplied
+        fetchTransformed,   // RGB555
+        fetchTransformed,   // ARGB8555_Premultiplied
+        fetchTransformed,   // RGB888
+        fetchTransformed,   // RGB444
+        fetchTransformed,   // ARGB4444_Premultiplied
+    },
+    {
+        0, // TransformedTiled
+        fetchTransformedTiled,   // Mono
+        fetchTransformedTiled,   // MonoLsb
+        fetchTransformedTiled,   // Indexed8
+        fetchTransformedTiled,   // RGB32
+        fetchTransformedTiled,   // ARGB32
+        fetchTransformedTiled,   // ARGB32_Premultiplied
+        fetchTransformedTiled,   // RGB16
+        fetchTransformedTiled,   // ARGB8565_Premultiplied
+        fetchTransformedTiled,   // RGB666
+        fetchTransformedTiled,   // ARGB6666_Premultiplied
+        fetchTransformedTiled,   // RGB555
+        fetchTransformedTiled,   // ARGB8555_Premultiplied
+        fetchTransformedTiled,   // RGB888
+        fetchTransformedTiled,   // RGB444
+        fetchTransformedTiled,   // ARGB4444_Premultiplied
+    },
+    {
+        0, // Bilinear
+        fetchTransformedBilinear,   // Mono
+        fetchTransformedBilinear,   // MonoLsb
+        fetchTransformedBilinear,   // Indexed8
+        fetchTransformedBilinear,   // RGB32
+        fetchTransformedBilinear,   // ARGB32
+        fetchTransformedBilinear,   // ARGB32_Premultiplied
+        fetchTransformedBilinear,   // RGB16
+        fetchTransformedBilinear,   // ARGB8565_Premultiplied
+        fetchTransformedBilinear,   // RGB666
+        fetchTransformedBilinear,   // ARGB6666_Premultiplied
+        fetchTransformedBilinear,   // RGB555
+        fetchTransformedBilinear,   // ARGB8555_Premultiplied
+        fetchTransformedBilinear,   // RGB888
+        fetchTransformedBilinear,   // RGB444
+        fetchTransformedBilinear    // ARGB4444_Premultiplied
+    },
+    {
+        0, // BilinearTiled
+        fetchTransformedBilinearTiled,   // Mono
+        fetchTransformedBilinearTiled,   // MonoLsb
+        fetchTransformedBilinearTiled,   // Indexed8
+        fetchTransformedBilinearTiled,   // RGB32
+        fetchTransformedBilinearTiled,   // ARGB32
+        fetchTransformedBilinearTiled,   // ARGB32_Premultiplied
+        fetchTransformedBilinearTiled,   // RGB16
+        fetchTransformedBilinearTiled,   // ARGB8565_Premultiplied
+        fetchTransformedBilinearTiled,   // RGB666
+        fetchTransformedBilinearTiled,   // ARGB6666_Premultiplied
+        fetchTransformedBilinearTiled,   // RGB555
+        fetchTransformedBilinearTiled,   // ARGB8555_Premultiplied
+        fetchTransformedBilinearTiled,   // RGB888
+        fetchTransformedBilinearTiled,   // RGB444
+        fetchTransformedBilinearTiled    // ARGB4444_Premultiplied
+    },
+};
+
+
+static inline uint qt_gradient_pixel(const QGradientData *data, qreal pos)
+{
+    int ipos = int(pos * (GRADIENT_STOPTABLE_SIZE - 1) + 0.5);
+
+  // calculate the actual offset.
+    if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
+        if (data->spread == QGradient::RepeatSpread) {
+            ipos = ipos % GRADIENT_STOPTABLE_SIZE;
+            ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos;
+
+        } else if (data->spread == QGradient::ReflectSpread) {
+            const int limit = GRADIENT_STOPTABLE_SIZE * 2 - 1;
+            ipos = ipos % limit;
+            ipos = ipos < 0 ? limit + ipos : ipos;
+            ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - ipos : ipos;
+
+        } else {
+            if (ipos < 0) ipos = 0;
+            else if (ipos >= GRADIENT_STOPTABLE_SIZE) ipos = GRADIENT_STOPTABLE_SIZE-1;
+        }
+    }
+
+    Q_ASSERT(ipos >= 0);
+    Q_ASSERT(ipos < GRADIENT_STOPTABLE_SIZE);
+
+    return data->colorTable[ipos];
+}
+
+#define FIXPT_BITS 8
+#define FIXPT_SIZE (1<<FIXPT_BITS)
+
+static uint qt_gradient_pixel_fixed(const QGradientData *data, int fixed_pos)
+{
+    int ipos = (fixed_pos + (FIXPT_SIZE / 2)) >> FIXPT_BITS;
+
+    // calculate the actual offset.
+    if (ipos < 0 || ipos >= GRADIENT_STOPTABLE_SIZE) {
+        if (data->spread == QGradient::RepeatSpread) {
+            ipos = ipos % GRADIENT_STOPTABLE_SIZE;
+            ipos = ipos < 0 ? GRADIENT_STOPTABLE_SIZE + ipos : ipos;
+
+        } else if (data->spread == QGradient::ReflectSpread) {
+            const int limit = GRADIENT_STOPTABLE_SIZE * 2 - 1;
+            ipos = ipos % limit;
+            ipos = ipos < 0 ? limit + ipos : ipos;
+            ipos = ipos >= GRADIENT_STOPTABLE_SIZE ? limit - ipos : ipos;
+
+        } else {
+            if (ipos < 0) ipos = 0;
+            else if (ipos >= GRADIENT_STOPTABLE_SIZE) ipos = GRADIENT_STOPTABLE_SIZE-1;
+        }
+    }
+
+    Q_ASSERT(ipos >= 0);
+    Q_ASSERT(ipos < GRADIENT_STOPTABLE_SIZE);
+
+    return data->colorTable[ipos];
+}
+
+static void QT_FASTCALL getLinearGradientValues(LinearGradientValues *v, const QSpanData *data)
+{
+    v->dx = data->gradient.linear.end.x - data->gradient.linear.origin.x;
+    v->dy = data->gradient.linear.end.y - data->gradient.linear.origin.y;
+    v->l = v->dx * v->dx + v->dy * v->dy;
+    v->off = 0;
+    if (v->l != 0) {
+        v->dx /= v->l;
+        v->dy /= v->l;
+        v->off = -v->dx * data->gradient.linear.origin.x - v->dy * data->gradient.linear.origin.y;
+    }
+}
+
+static const uint * QT_FASTCALL fetchLinearGradient(uint *buffer, const Operator *op, const QSpanData *data,
+                                                    int y, int x, int length)
+{
+    const uint *b = buffer;
+    qreal t, inc;
+
+    bool affine = true;
+    qreal rx=0, ry=0;
+    if (op->linear.l == 0) {
+        t = inc = 0;
+    } else {
+        rx = data->m21 * (y + 0.5) + data->m11 * (x + 0.5) + data->dx;
+        ry = data->m22 * (y + 0.5) + data->m12 * (x + 0.5) + data->dy;
+        t = op->linear.dx*rx + op->linear.dy*ry + op->linear.off;
+        inc = op->linear.dx * data->m11 + op->linear.dy * data->m12;
+        affine = !data->m13 && !data->m23;
+
+        if (affine) {
+            t *= (GRADIENT_STOPTABLE_SIZE - 1);
+            inc *= (GRADIENT_STOPTABLE_SIZE - 1);
+        }
+    }
+
+    const uint *end = buffer + length;
+    if (affine) {
+        if (inc > -1e-5 && inc < 1e-5) {
+            QT_MEMFILL_UINT(buffer, length, qt_gradient_pixel_fixed(&data->gradient, int(t * FIXPT_SIZE)));
+        } else {
+            if (t+inc*length < qreal(INT_MAX >> (FIXPT_BITS + 1)) &&
+                t+inc*length > qreal(INT_MIN >> (FIXPT_BITS + 1))) {
+                // we can use fixed point math
+                int t_fixed = int(t * FIXPT_SIZE);
+                int inc_fixed = int(inc * FIXPT_SIZE);
+                while (buffer < end) {
+                    *buffer = qt_gradient_pixel_fixed(&data->gradient, t_fixed);
+                    t_fixed += inc_fixed;
+                    ++buffer;
+                }
+            } else {
+                // we have to fall back to float math
+                while (buffer < end) {
+                    *buffer = qt_gradient_pixel(&data->gradient, t/GRADIENT_STOPTABLE_SIZE);
+                    t += inc;
+                    ++buffer;
+                }
+            }
+        }
+    } else { // fall back to float math here as well
+        qreal rw = data->m23 * (y + 0.5) + data->m13 * (x + 0.5) + data->m33;
+        while (buffer < end) {
+            qreal x = rx/rw;
+            qreal y = ry/rw;
+            t = (op->linear.dx*x + op->linear.dy *y) + op->linear.off;
+
+            *buffer = qt_gradient_pixel(&data->gradient, t);
+            rx += data->m11;
+            ry += data->m12;
+            rw += data->m13;
+            if (!rw) {
+                rw += data->m13;
+            }
+            ++buffer;
+        }
+    }
+
+    return b;
+}
+
+static inline qreal determinant(qreal a, qreal b, qreal c)
+{
+    return (b * b) - (4 * a * c);
+}
+
+// function to evaluate real roots
+static inline qreal realRoots(qreal a, qreal b, qreal detSqrt)
+{
+    return (-b + detSqrt)/(2 * a);
+}
+
+static inline qreal qSafeSqrt(qreal x)
+{
+    return x > 0 ? qSqrt(x) : 0;
+}
+
+static void QT_FASTCALL getRadialGradientValues(RadialGradientValues *v, const QSpanData *data)
+{
+    v->dx = data->gradient.radial.center.x - data->gradient.radial.focal.x;
+    v->dy = data->gradient.radial.center.y - data->gradient.radial.focal.y;
+    v->a = data->gradient.radial.radius*data->gradient.radial.radius - v->dx*v->dx - v->dy*v->dy;
+}
+
+static const uint * QT_FASTCALL fetchRadialGradient(uint *buffer, const Operator *op, const QSpanData *data,
+                                                    int y, int x, int length)
+{
+    const uint *b = buffer;
+    qreal rx = data->m21 * (y + 0.5)
+               + data->dx + data->m11 * (x + 0.5);
+    qreal ry = data->m22 * (y + 0.5)
+               + data->dy + data->m12 * (x + 0.5);
+    bool affine = !data->m13 && !data->m23;
+    //qreal r  = data->gradient.radial.radius;
+
+    const uint *end = buffer + length;
+    if (affine) {
+        rx -= data->gradient.radial.focal.x;
+        ry -= data->gradient.radial.focal.y;
+
+        qreal inv_a = 1 / qreal(2 * op->radial.a);
+
+        const qreal delta_rx = data->m11;
+        const qreal delta_ry = data->m12;
+
+        qreal b = 2*(rx * op->radial.dx + ry * op->radial.dy);
+        qreal delta_b = 2*(delta_rx * op->radial.dx + delta_ry * op->radial.dy);
+        const qreal b_delta_b = 2 * b * delta_b;
+        const qreal delta_b_delta_b = 2 * delta_b * delta_b;
+
+        const qreal bb = b * b;
+        const qreal delta_bb = delta_b * delta_b;
+
+        b *= inv_a;
+        delta_b *= inv_a;
+
+        const qreal rxrxryry = rx * rx + ry * ry;
+        const qreal delta_rxrxryry = delta_rx * delta_rx + delta_ry * delta_ry;
+        const qreal rx_plus_ry = 2*(rx * delta_rx + ry * delta_ry);
+        const qreal delta_rx_plus_ry = 2 * delta_rxrxryry;
+
+        inv_a *= inv_a;
+
+        qreal det = (bb + 4 * op->radial.a * rxrxryry) * inv_a;
+        qreal delta_det = (b_delta_b + delta_bb + 4 * op->radial.a * (rx_plus_ry + delta_rxrxryry)) * inv_a;
+        const qreal delta_delta_det = (delta_b_delta_b + 4 * op->radial.a * delta_rx_plus_ry) * inv_a;
+
+        while (buffer < end) {
+            *buffer = qt_gradient_pixel(&data->gradient, qSafeSqrt(det) - b);
+
+            det += delta_det;
+            delta_det += delta_delta_det;
+            b += delta_b;
+
+            ++buffer;
+        }
+    } else {
+        qreal rw = data->m23 * (y + 0.5)
+                   + data->m33 + data->m13 * (x + 0.5);
+        if (!rw)
+            rw = 1;
+        while (buffer < end) {
+            qreal gx = rx/rw - data->gradient.radial.focal.x;
+            qreal gy = ry/rw - data->gradient.radial.focal.y;
+            qreal b  = 2*(gx*op->radial.dx + gy*op->radial.dy);
+            qreal det = determinant(op->radial.a, b , -(gx*gx + gy*gy));
+            qreal s = realRoots(op->radial.a, b, qSafeSqrt(det));
+
+            *buffer = qt_gradient_pixel(&data->gradient, s);
+
+            rx += data->m11;
+            ry += data->m12;
+            rw += data->m13;
+            if (!rw) {
+                rw += data->m13;
+            }
+            ++buffer;
+        }
+    }
+
+    return b;
+}
+
+static const uint * QT_FASTCALL fetchConicalGradient(uint *buffer, const Operator *, const QSpanData *data,
+                                                     int y, int x, int length)
+{
+    const uint *b = buffer;
+    qreal rx = data->m21 * (y + 0.5)
+               + data->dx + data->m11 * (x + 0.5);
+    qreal ry = data->m22 * (y + 0.5)
+               + data->dy + data->m12 * (x + 0.5);
+    bool affine = !data->m13 && !data->m23;
+
+    const uint *end = buffer + length;
+    if (affine) {
+        rx -= data->gradient.conical.center.x;
+        ry -= data->gradient.conical.center.y;
+        while (buffer < end) {
+            qreal angle = atan2(ry, rx) + data->gradient.conical.angle;
+
+            *buffer = qt_gradient_pixel(&data->gradient, 1 - angle / (2*Q_PI));
+
+            rx += data->m11;
+            ry += data->m12;
+            ++buffer;
+        }
+    } else {
+        qreal rw = data->m23 * (y + 0.5)
+                   + data->m33 + data->m13 * (x + 0.5);
+        if (!rw)
+            rw = 1;
+        while (buffer < end) {
+            qreal angle = atan2(ry/rw - data->gradient.conical.center.x,
+                                rx/rw - data->gradient.conical.center.y)
+                          + data->gradient.conical.angle;
+
+            *buffer = qt_gradient_pixel(&data->gradient, 1. - angle / (2*Q_PI));
+
+            rx += data->m11;
+            ry += data->m12;
+            rw += data->m13;
+            if (!rw) {
+                rw += data->m13;
+            }
+            ++buffer;
+        }
+    }
+    return b;
+}
+
+
+
+/* The constant alpha factor describes an alpha factor that gets applied
+   to the result of the composition operation combining it with the destination.
+
+   The intent is that if const_alpha == 0. we get back dest, and if const_alpha == 1.
+   we get the unmodified operation
+
+   result = src op dest
+   dest = result * const_alpha + dest * (1. - const_alpha)
+
+   This means that in the comments below, the first line is the const_alpha==255 case, the
+   second line the general one.
+
+   In the lines below:
+   s == src, sa == alpha(src), sia = 1 - alpha(src)
+   d == dest, da == alpha(dest), dia = 1 - alpha(dest)
+   ca = const_alpha, cia = 1 - const_alpha
+
+   The methods exist in two variants. One where we have a constant source, the other
+   where the source is an array of pixels.
+*/
+
+/*
+  result = 0
+  d = d * cia
+*/
+static void QT_FASTCALL comp_func_solid_Clear(uint *dest, int length, uint, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        QT_MEMFILL_UINT(dest, length, 0);
+    } else {
+        int ialpha = 255 - const_alpha;
+        for (int i = 0; i < length; ++i)
+            dest[i] = BYTE_MUL(dest[i], ialpha);
+    }
+}
+
+static void QT_FASTCALL comp_func_Clear(uint *dest, const uint *, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        QT_MEMFILL_UINT(dest, length, 0);
+    } else {
+        int ialpha = 255 - const_alpha;
+        for (int i = 0; i < length; ++i)
+            dest[i] = BYTE_MUL(dest[i], ialpha);
+    }
+}
+
+/*
+  result = s
+  dest = s * ca + d * cia
+*/
+static void QT_FASTCALL comp_func_solid_Source(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        QT_MEMFILL_UINT(dest, length, color);
+    } else {
+        int ialpha = 255 - const_alpha;
+        color = BYTE_MUL(color, const_alpha);
+        for (int i = 0; i < length; ++i)
+            dest[i] = color + BYTE_MUL(dest[i], ialpha);
+    }
+}
+
+static void QT_FASTCALL comp_func_Source(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        ::memcpy(dest, src, length * sizeof(uint));
+    } else {
+        int ialpha = 255 - const_alpha;
+        for (int i = 0; i < length; ++i)
+            dest[i] = INTERPOLATE_PIXEL_255(src[i], const_alpha, dest[i], ialpha);
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_Destination(uint *, int, uint, uint)
+{
+}
+
+static void QT_FASTCALL comp_func_Destination(uint *, const uint *, int, uint)
+{
+}
+
+/*
+  result = s + d * sia
+  dest = (s + d * sia) * ca + d * cia
+       = s * ca + d * (sia * ca + cia)
+       = s * ca + d * (1 - sa*ca)
+*/
+static void QT_FASTCALL comp_func_solid_SourceOver(uint *dest, int length, uint color, uint const_alpha)
+{
+    if ((const_alpha & qAlpha(color)) == 255) {
+        QT_MEMFILL_UINT(dest, length, color);
+    } else {
+        if (const_alpha != 255)
+            color = BYTE_MUL(color, const_alpha);
+        for (int i = 0; i < length; ++i)
+            dest[i] = color + BYTE_MUL(dest[i], qAlpha(~color));
+    }
+}
+
+static void QT_FASTCALL comp_func_SourceOver(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            uint s = src[i];
+            dest[i] = s + BYTE_MUL(dest[i], qAlpha(~s));
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            uint s = BYTE_MUL(src[i], const_alpha);
+            dest[i] = s + BYTE_MUL(dest[i], qAlpha(~s));
+        }
+    }
+}
+
+/*
+  result = d + s * dia
+  dest = (d + s * dia) * ca + d * cia
+       = d + s * dia * ca
+*/
+static void QT_FASTCALL comp_func_solid_DestinationOver(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha != 255)
+        color = BYTE_MUL(color, const_alpha);
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        dest[i] = d + BYTE_MUL(color, qAlpha(~d));
+    }
+}
+
+static void QT_FASTCALL comp_func_DestinationOver(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            uint d = dest[i];
+            dest[i] = d + BYTE_MUL(src[i], qAlpha(~d));
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            uint d = dest[i];
+            uint s = BYTE_MUL(src[i], const_alpha);
+            dest[i] = d + BYTE_MUL(s, qAlpha(~d));
+        }
+    }
+}
+
+/*
+  result = s * da
+  dest = s * da * ca + d * cia
+*/
+static void QT_FASTCALL comp_func_solid_SourceIn(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i)
+            dest[i] = BYTE_MUL(color, qAlpha(dest[i]));
+    } else {
+        color = BYTE_MUL(color, const_alpha);
+        uint cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(d), d, cia);
+        }
+    }
+}
+
+static void QT_FASTCALL comp_func_SourceIn(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i)
+            dest[i] = BYTE_MUL(src[i], qAlpha(dest[i]));
+    } else {
+        uint cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            uint d = dest[i];
+            uint s = BYTE_MUL(src[i], const_alpha);
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, cia);
+        }
+    }
+}
+
+/*
+  result = d * sa
+  dest = d * sa * ca + d * cia
+       = d * (sa * ca + cia)
+*/
+static void QT_FASTCALL comp_func_solid_DestinationIn(uint *dest, int length, uint color, uint const_alpha)
+{
+    uint a = qAlpha(color);
+    if (const_alpha != 255) {
+        a = BYTE_MUL(a, const_alpha) + 255 - const_alpha;
+    }
+    for (int i = 0; i < length; ++i) {
+        dest[i] = BYTE_MUL(dest[i], a);
+    }
+}
+
+static void QT_FASTCALL comp_func_DestinationIn(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i)
+            dest[i] = BYTE_MUL(dest[i], qAlpha(src[i]));
+    } else {
+        int cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            uint a = BYTE_MUL(qAlpha(src[i]), const_alpha) + cia;
+            dest[i] = BYTE_MUL(dest[i], a);
+        }
+    }
+}
+
+/*
+  result = s * dia
+  dest = s * dia * ca + d * cia
+*/
+
+static void QT_FASTCALL comp_func_solid_SourceOut(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i)
+            dest[i] = BYTE_MUL(color, qAlpha(~dest[i]));
+    } else {
+        color = BYTE_MUL(color, const_alpha);
+        int cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(~d), d, cia);
+        }
+    }
+}
+
+static void QT_FASTCALL comp_func_SourceOut(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i)
+            dest[i] = BYTE_MUL(src[i], qAlpha(~dest[i]));
+    } else {
+        int cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            uint s = BYTE_MUL(src[i], const_alpha);
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, cia);
+        }
+    }
+}
+
+/*
+  result = d * sia
+  dest = d * sia * ca + d * cia
+       = d * (sia * ca + cia)
+*/
+static void QT_FASTCALL comp_func_solid_DestinationOut(uint *dest, int length, uint color, uint const_alpha)
+{
+    uint a = qAlpha(~color);
+    if (const_alpha != 255)
+        a = BYTE_MUL(a, const_alpha) + 255 - const_alpha;
+    for (int i = 0; i < length; ++i)
+        dest[i] = BYTE_MUL(dest[i], a);
+}
+
+static void QT_FASTCALL comp_func_DestinationOut(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i)
+            dest[i] = BYTE_MUL(dest[i], qAlpha(~src[i]));
+    } else {
+        int cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            uint sia = BYTE_MUL(qAlpha(~src[i]), const_alpha) + cia;
+            dest[i] = BYTE_MUL(dest[i], sia);
+        }
+    }
+}
+
+/*
+  result = s*da + d*sia
+  dest = s*da*ca + d*sia*ca + d *cia
+       = s*ca * da + d * (sia*ca + cia)
+       = s*ca * da + d * (1 - sa*ca)
+*/
+static void QT_FASTCALL comp_func_solid_SourceAtop(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha != 255) {
+        color = BYTE_MUL(color, const_alpha);
+    }
+    uint sia = qAlpha(~color);
+    for (int i = 0; i < length; ++i)
+        dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(dest[i]), dest[i], sia);
+}
+
+static void QT_FASTCALL comp_func_SourceAtop(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            uint s = src[i];
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, qAlpha(~s));
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            uint s = BYTE_MUL(src[i], const_alpha);
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, qAlpha(~s));
+        }
+    }
+}
+
+/*
+  result = d*sa + s*dia
+  dest = d*sa*ca + s*dia*ca + d *cia
+       = s*ca * dia + d * (sa*ca + cia)
+*/
+static void QT_FASTCALL comp_func_solid_DestinationAtop(uint *dest, int length, uint color, uint const_alpha)
+{
+    uint a = qAlpha(color);
+    if (const_alpha != 255) {
+        color = BYTE_MUL(color, const_alpha);
+        a = qAlpha(color) + 255 - const_alpha;
+    }
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        dest[i] = INTERPOLATE_PIXEL_255(d, a, color, qAlpha(~d));
+    }
+}
+
+static void QT_FASTCALL comp_func_DestinationAtop(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            uint s = src[i];
+            uint d = dest[i];
+            dest[i] = INTERPOLATE_PIXEL_255(d, qAlpha(s), s, qAlpha(~d));
+        }
+    } else {
+        int cia = 255 - const_alpha;
+        for (int i = 0; i < length; ++i) {
+            uint s = BYTE_MUL(src[i], const_alpha);
+            uint d = dest[i];
+            uint a = qAlpha(s) + cia;
+            dest[i] = INTERPOLATE_PIXEL_255(d, a, s, qAlpha(~d));
+        }
+    }
+}
+
+/*
+  result = d*sia + s*dia
+  dest = d*sia*ca + s*dia*ca + d *cia
+       = s*ca * dia + d * (sia*ca + cia)
+       = s*ca * dia + d * (1 - sa*ca)
+*/
+static void QT_FASTCALL comp_func_solid_XOR(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha != 255)
+        color = BYTE_MUL(color, const_alpha);
+    uint sia = qAlpha(~color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(~d), d, sia);
+    }
+}
+
+static void QT_FASTCALL comp_func_XOR(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255) {
+        for (int i = 0; i < length; ++i) {
+            uint d = dest[i];
+            uint s = src[i];
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, qAlpha(~s));
+        }
+    } else {
+        for (int i = 0; i < length; ++i) {
+            uint d = dest[i];
+            uint s = BYTE_MUL(src[i], const_alpha);
+            dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, qAlpha(~s));
+        }
+    }
+}
+
+static const uint AMASK = 0xff000000;
+static const uint RMASK = 0x00ff0000;
+static const uint GMASK = 0x0000ff00;
+static const uint BMASK = 0x000000ff;
+
+struct QFullCoverage {
+    inline void store(uint *dest, const uint src) const
+    {
+        *dest = src;
+    }
+};
+
+struct QPartialCoverage {
+    inline QPartialCoverage(uint const_alpha)
+        : ca(const_alpha)
+        , ica(255 - const_alpha)
+    {
+    }
+
+    inline void store(uint *dest, const uint src) const
+    {
+        *dest = INTERPOLATE_PIXEL_255(src, ca, *dest, ica);
+    }
+
+private:
+    const uint ca;
+    const uint ica;
+};
+
+static inline int mix_alpha(int da, int sa)
+{
+    return 255 - ((255 - sa) * (255 - da) >> 8);
+}
+
+/*
+    Dca' = Sca.Da + Dca.Sa + Sca.(1 - Da) + Dca.(1 - Sa)
+         = Sca + Dca
+*/
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Plus_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    uint s = color;
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+#define MIX(mask) (qMin(((qint64(s)&mask) + (qint64(d)&mask)), qint64(mask)))
+        d = (MIX(AMASK) | MIX(RMASK) | MIX(GMASK) | MIX(BMASK));
+#undef MIX
+        coverage.store(&dest[i], d);
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_Plus(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Plus_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Plus_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Plus_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+#define MIX(mask) (qMin(((qint64(s)&mask) + (qint64(d)&mask)), qint64(mask)))
+        d = (MIX(AMASK) | MIX(RMASK) | MIX(GMASK) | MIX(BMASK));
+#undef MIX
+
+        coverage.store(&dest[i], d);
+    }
+}
+
+static void QT_FASTCALL comp_func_Plus(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Plus_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Plus_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    Dca' = Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline int multiply_op(int dst, int src, int da, int sa)
+{
+    return qt_div_255(src * dst + src * (255 - da) + dst * (255 - sa));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Multiply_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) multiply_op(a, b, da, sa)
+        int r = OP(  qRed(d), sr);
+        int b = OP( qBlue(d), sb);
+        int g = OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_Multiply(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Multiply_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Multiply_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Multiply_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) multiply_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_Multiply(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Multiply_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Multiply_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    Dca' = (Sca.Da + Dca.Sa - Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)
+         = Sca + Dca - Sca.Dca
+*/
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Screen_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) 255 - qt_div_255((255-a) * (255-b))
+        int r = OP(  qRed(d), sr);
+        int b = OP( qBlue(d), sb);
+        int g = OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_Screen(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Screen_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Screen_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Screen_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) 255 - (((255-a) * (255-b)) >> 8)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_Screen(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Screen_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Screen_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    if 2.Dca < Da
+        Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
+    otherwise
+        Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline int overlay_op(int dst, int src, int da, int sa)
+{
+    const int temp = src * (255 - da) + dst * (255 - sa);
+    if (2 * dst < da)
+        return qt_div_255(2 * src * dst + temp);
+    else
+        return qt_div_255(sa * da - 2 * (da - dst) * (sa - src) + temp);
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Overlay_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) overlay_op(a, b, da, sa)
+        int r = OP(  qRed(d), sr);
+        int b = OP( qBlue(d), sb);
+        int g = OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_Overlay(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Overlay_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Overlay_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Overlay_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) overlay_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_Overlay(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Overlay_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Overlay_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    Dca' = min(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
+    Da'  = Sa + Da - Sa.Da
+*/
+static inline int darken_op(int dst, int src, int da, int sa)
+{
+    return qt_div_255(qMin(src * da, dst * sa) + src * (255 - da) + dst * (255 - sa));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Darken_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) darken_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_Darken(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Darken_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Darken_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Darken_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) darken_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_Darken(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Darken_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Darken_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+   Dca' = max(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
+   Da'  = Sa + Da - Sa.Da
+*/
+static inline int lighten_op(int dst, int src, int da, int sa)
+{
+    return qt_div_255(qMax(src * da, dst * sa) + src * (255 - da) + dst * (255 - sa));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Lighten_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) lighten_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_Lighten(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Lighten_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Lighten_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Lighten_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) lighten_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_Lighten(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Lighten_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Lighten_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+   if Sca.Da + Dca.Sa >= Sa.Da
+       Dca' = Sa.Da + Sca.(1 - Da) + Dca.(1 - Sa)
+   otherwise
+       Dca' = Dca.Sa/(1-Sca/Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline int color_dodge_op(int dst, int src, int da, int sa)
+{
+    const int sa_da = sa * da;
+    const int dst_sa = dst * sa;
+    const int src_da = src * da;
+
+    const int temp = src * (255 - da) + dst * (255 - sa);
+    if (src_da + dst_sa >= sa_da)
+        return qt_div_255(sa_da + temp);
+    else
+        return qt_div_255(255 * dst_sa / (255 - 255 * src / sa) + temp);
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_ColorDodge_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a,b) color_dodge_op(a, b, da, sa)
+        int r = OP(  qRed(d), sr);
+        int b = OP( qBlue(d), sb);
+        int g = OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_ColorDodge(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_ColorDodge_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_ColorDodge_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_ColorDodge_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) color_dodge_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_ColorDodge(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_ColorDodge_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_ColorDodge_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+   if Sca.Da + Dca.Sa <= Sa.Da
+       Dca' = Sca.(1 - Da) + Dca.(1 - Sa)
+   otherwise
+       Dca' = Sa.(Sca.Da + Dca.Sa - Sa.Da)/Sca + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline int color_burn_op(int dst, int src, int da, int sa)
+{
+    const int src_da = src * da;
+    const int dst_sa = dst * sa;
+    const int sa_da = sa * da;
+
+    const int temp = src * (255 - da) + dst * (255 - sa);
+
+    if (src == 0 || src_da + dst_sa <= sa_da)
+        return qt_div_255(temp);
+    else
+        return qt_div_255(sa * (src_da + dst_sa - sa_da) / src + temp);
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_ColorBurn_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) color_burn_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_ColorBurn(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_ColorBurn_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_ColorBurn_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_ColorBurn_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) color_burn_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_ColorBurn(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_ColorBurn_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_ColorBurn_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    if 2.Sca < Sa
+        Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
+    otherwise
+        Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline uint hardlight_op(int dst, int src, int da, int sa)
+{
+    const uint temp = src * (255 - da) + dst * (255 - sa);
+
+    if (2 * src < sa)
+        return qt_div_255(2 * src * dst + temp);
+    else
+        return qt_div_255(sa * da - 2 * (da - dst) * (sa - src) + temp);
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_HardLight_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) hardlight_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_HardLight(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_HardLight_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_HardLight_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_HardLight_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) hardlight_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_HardLight(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_HardLight_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_HardLight_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+   if 2.Sca < Sa
+       Dca' = Dca.(Sa - (1 - Dca/Da).(2.Sca - Sa)) + Sca.(1 - Da) + Dca.(1 - Sa)
+   otherwise if 8.Dca <= Da
+       Dca' = Dca.(Sa - (1 - Dca/Da).(2.Sca - Sa).(3 - 8.Dca/Da)) + Sca.(1 - Da) + Dca.(1 - Sa)
+   otherwise
+       Dca' = (Dca.Sa + ((Dca/Da)^(0.5).Da - Dca).(2.Sca - Sa)) + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+static inline int soft_light_op(int dst, int src, int da, int sa)
+{
+    const int src2 = src << 1;
+    const int dst_np = da != 0 ? (255 * dst) / da : 0;
+    const int temp = (src * (255 - da) + dst * (255 - sa)) * 255;
+
+    if (src2 < sa)
+        return (dst * ((sa * 255) - (255 - dst_np) * (src2 - sa)) + temp) / 65025;
+    else if (8 * dst <= da)
+        return (dst * ((sa * 255) - ((255 - dst_np) * (src2 - sa) * ((3 * 255) - 8 * dst_np)) / 255) + temp) / 65025;
+    else {
+        // sqrt is too expensive to do three times per pixel, so skipping it for now
+        // a future possibility is to use a LUT
+        return ((dst * sa * 255) + (int(dst_np) * da - (dst * 255)) * (src2 - sa) + temp) / 65025;
+    }
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_SoftLight_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) soft_light_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_SoftLight(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_SoftLight_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_SoftLight_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_SoftLight_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) soft_light_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_SoftLight(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_SoftLight_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_SoftLight_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+   Dca' = abs(Dca.Sa - Sca.Da) + Sca.(1 - Da) + Dca.(1 - Sa)
+        = Sca + Dca - 2.min(Sca.Da, Dca.Sa)
+*/
+static inline int difference_op(int dst, int src, int da, int sa)
+{
+    return src + dst - qt_div_255(2 * qMin(src * da, dst * sa));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Difference_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) difference_op(a, b, da, sa)
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_Difference(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Difference_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Difference_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Difference_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) difference_op(a, b, da, sa)
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_Difference(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Difference_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Difference_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+/*
+    Dca' = (Sca.Da + Dca.Sa - 2.Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)
+*/
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void QT_FASTCALL comp_func_solid_Exclusion_impl(uint *dest, int length, uint color, const T &coverage)
+{
+    int sa = qAlpha(color);
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        int da = qAlpha(d);
+
+#define OP(a, b) (a + b - qt_div_255(2*(a*b)))
+        int r =  OP(  qRed(d), sr);
+        int b =  OP( qBlue(d), sb);
+        int g =  OP(qGreen(d), sg);
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_solid_Exclusion(uint *dest, int length, uint color, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_solid_Exclusion_impl(dest, length, color, QFullCoverage());
+    else
+        comp_func_solid_Exclusion_impl(dest, length, color, QPartialCoverage(const_alpha));
+}
+
+template <typename T>
+Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Exclusion_impl(uint *dest, const uint *src, int length, const T &coverage)
+{
+    for (int i = 0; i < length; ++i) {
+        uint d = dest[i];
+        uint s = src[i];
+
+        int da = qAlpha(d);
+        int sa = qAlpha(s);
+
+#define OP(a, b) (a + b - ((a*b) >> 7))
+        int r = OP(  qRed(d),   qRed(s));
+        int b = OP( qBlue(d),  qBlue(s));
+        int g = OP(qGreen(d), qGreen(s));
+        int a = mix_alpha(da, sa);
+#undef OP
+
+        coverage.store(&dest[i], qRgba(r, g, b, a));
+    }
+}
+
+static void QT_FASTCALL comp_func_Exclusion(uint *dest, const uint *src, int length, uint const_alpha)
+{
+    if (const_alpha == 255)
+        comp_func_Exclusion_impl(dest, src, length, QFullCoverage());
+    else
+        comp_func_Exclusion_impl(dest, src, length, QPartialCoverage(const_alpha));
+}
+
+static void QT_FASTCALL rasterop_solid_SourceOrDestination(uint *dest,
+                                                           int length,
+                                                           uint color,
+                                                           uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--)
+        *dest++ |= color;
+}
+
+static void QT_FASTCALL rasterop_SourceOrDestination(uint *dest,
+                                                     const uint *src,
+                                                     int length,
+                                                     uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--)
+        *dest++ |= *src++;
+}
+
+static void QT_FASTCALL rasterop_solid_SourceAndDestination(uint *dest,
+                                                            int length,
+                                                            uint color,
+                                                            uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color |= 0xff000000;
+    while (length--)
+        *dest++ &= color;
+}
+
+static void QT_FASTCALL rasterop_SourceAndDestination(uint *dest,
+                                                      const uint *src,
+                                                      int length,
+                                                      uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (*src & *dest) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+static void QT_FASTCALL rasterop_solid_SourceXorDestination(uint *dest,
+                                                            int length,
+                                                            uint color,
+                                                            uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color &= 0x00ffffff;
+    while (length--)
+        *dest++ ^= color;
+}
+
+static void QT_FASTCALL rasterop_SourceXorDestination(uint *dest,
+                                                      const uint *src,
+                                                      int length,
+                                                      uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (*src ^ *dest) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+static void QT_FASTCALL rasterop_solid_NotSourceAndNotDestination(uint *dest,
+                                                                  int length,
+                                                                  uint color,
+                                                                  uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color = ~color;
+    while (length--) {
+        *dest = (color & ~(*dest)) | 0xff000000;
+        ++dest;
+    }
+}
+
+static void QT_FASTCALL rasterop_NotSourceAndNotDestination(uint *dest,
+                                                            const uint *src,
+                                                            int length,
+                                                            uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (~(*src) & ~(*dest)) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+static void QT_FASTCALL rasterop_solid_NotSourceOrNotDestination(uint *dest,
+                                                                 int length,
+                                                                 uint color,
+                                                                 uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color = ~color | 0xff000000;
+    while (length--) {
+        *dest = color | ~(*dest);
+        ++dest;
+    }
+}
+
+static void QT_FASTCALL rasterop_NotSourceOrNotDestination(uint *dest,
+                                                           const uint *src,
+                                                           int length,
+                                                           uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = ~(*src) | ~(*dest) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+static void QT_FASTCALL rasterop_solid_NotSourceXorDestination(uint *dest,
+                                                               int length,
+                                                               uint color,
+                                                               uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color = ~color & 0x00ffffff;
+    while (length--) {
+        *dest = color ^ (*dest);
+        ++dest;
+    }
+}
+
+static void QT_FASTCALL rasterop_NotSourceXorDestination(uint *dest,
+                                                         const uint *src,
+                                                         int length,
+                                                         uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = ((~(*src)) ^ (*dest)) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+static void QT_FASTCALL rasterop_solid_NotSource(uint *dest, int length,
+                                                 uint color, uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    qt_memfill(dest, ~color | 0xff000000, length);
+}
+
+static void QT_FASTCALL rasterop_NotSource(uint *dest, const uint *src,
+                                           int length, uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--)
+        *dest++ = ~(*src++) | 0xff000000;
+}
+
+static void QT_FASTCALL rasterop_solid_NotSourceAndDestination(uint *dest,
+                                                               int length,
+                                                               uint color,
+                                                               uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    color = ~color | 0xff000000;
+    while (length--) {
+        *dest = color & *dest;
+        ++dest;
+    }
+}
+
+static void QT_FASTCALL rasterop_NotSourceAndDestination(uint *dest,
+                                                         const uint *src,
+                                                         int length,
+                                                         uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (~(*src) & *dest) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+static void QT_FASTCALL rasterop_solid_SourceAndNotDestination(uint *dest,
+                                                               int length,
+                                                               uint color,
+                                                               uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (color & ~(*dest)) | 0xff000000;
+        ++dest;
+    }
+}
+
+static void QT_FASTCALL rasterop_SourceAndNotDestination(uint *dest,
+                                                         const uint *src,
+                                                         int length,
+                                                         uint const_alpha)
+{
+    Q_UNUSED(const_alpha);
+    while (length--) {
+        *dest = (*src & ~(*dest)) | 0xff000000;
+        ++dest; ++src;
+    }
+}
+
+static const CompositionFunctionSolid functionForModeSolid_C[] = {
+        comp_func_solid_SourceOver,
+        comp_func_solid_DestinationOver,
+        comp_func_solid_Clear,
+        comp_func_solid_Source,
+        comp_func_solid_Destination,
+        comp_func_solid_SourceIn,
+        comp_func_solid_DestinationIn,
+        comp_func_solid_SourceOut,
+        comp_func_solid_DestinationOut,
+        comp_func_solid_SourceAtop,
+        comp_func_solid_DestinationAtop,
+        comp_func_solid_XOR,
+        comp_func_solid_Plus,
+        comp_func_solid_Multiply,
+        comp_func_solid_Screen,
+        comp_func_solid_Overlay,
+        comp_func_solid_Darken,
+        comp_func_solid_Lighten,
+        comp_func_solid_ColorDodge,
+        comp_func_solid_ColorBurn,
+        comp_func_solid_HardLight,
+        comp_func_solid_SoftLight,
+        comp_func_solid_Difference,
+        comp_func_solid_Exclusion,
+        rasterop_solid_SourceOrDestination,
+        rasterop_solid_SourceAndDestination,
+        rasterop_solid_SourceXorDestination,
+        rasterop_solid_NotSourceAndNotDestination,
+        rasterop_solid_NotSourceOrNotDestination,
+        rasterop_solid_NotSourceXorDestination,
+        rasterop_solid_NotSource,
+        rasterop_solid_NotSourceAndDestination,
+        rasterop_solid_SourceAndNotDestination
+};
+
+static const CompositionFunctionSolid *functionForModeSolid = functionForModeSolid_C;
+
+static const CompositionFunction functionForMode_C[] = {
+        comp_func_SourceOver,
+        comp_func_DestinationOver,
+        comp_func_Clear,
+        comp_func_Source,
+        comp_func_Destination,
+        comp_func_SourceIn,
+        comp_func_DestinationIn,
+        comp_func_SourceOut,
+        comp_func_DestinationOut,
+        comp_func_SourceAtop,
+        comp_func_DestinationAtop,
+        comp_func_XOR,
+        comp_func_Plus,
+        comp_func_Multiply,
+        comp_func_Screen,
+        comp_func_Overlay,
+        comp_func_Darken,
+        comp_func_Lighten,
+        comp_func_ColorDodge,
+        comp_func_ColorBurn,
+        comp_func_HardLight,
+        comp_func_SoftLight,
+        comp_func_Difference,
+        comp_func_Exclusion,
+        rasterop_SourceOrDestination,
+        rasterop_SourceAndDestination,
+        rasterop_SourceXorDestination,
+        rasterop_NotSourceAndNotDestination,
+        rasterop_NotSourceOrNotDestination,
+        rasterop_NotSourceXorDestination,
+        rasterop_NotSource,
+        rasterop_NotSourceAndDestination,
+        rasterop_SourceAndNotDestination
+};
+
+static const CompositionFunction *functionForMode = functionForMode_C;
+
+static TextureBlendType getBlendType(const QSpanData *data)
+{
+    TextureBlendType ft;
+    if (data->txop <= QTransform::TxTranslate)
+        if (data->texture.type == QTextureData::Tiled)
+            ft = BlendTiled;
+        else
+            ft = BlendUntransformed;
+    else if (data->bilinear)
+        if (data->texture.type == QTextureData::Tiled)
+            ft = BlendTransformedBilinearTiled;
+        else
+            ft = BlendTransformedBilinear;
+    else
+        if (data->texture.type == QTextureData::Tiled)
+            ft = BlendTransformedTiled;
+        else
+            ft = BlendTransformed;
+    return ft;
+}
+
+static inline Operator getOperator(const QSpanData *data, const QSpan *spans, int spanCount)
+{
+    Operator op;
+    bool solidSource = false;
+
+    switch(data->type) {
+    case QSpanData::Solid:
+        solidSource = (qAlpha(data->solid.color) == 255);
+        break;
+    case QSpanData::LinearGradient:
+        solidSource = !data->gradient.alphaColor;
+        getLinearGradientValues(&op.linear, data);
+        op.src_fetch = fetchLinearGradient;
+        break;
+    case QSpanData::RadialGradient:
+        solidSource = !data->gradient.alphaColor;
+        getRadialGradientValues(&op.radial, data);
+        op.src_fetch = fetchRadialGradient;
+        break;
+    case QSpanData::ConicalGradient:
+        solidSource = !data->gradient.alphaColor;
+        op.src_fetch = fetchConicalGradient;
+        break;
+    case QSpanData::Texture:
+        op.src_fetch = sourceFetch[getBlendType(data)][data->texture.format];
+        solidSource = !data->texture.hasAlpha;
+    default:
+        break;
+    }
+
+    op.mode = data->rasterBuffer->compositionMode;
+    if (op.mode == QPainter::CompositionMode_SourceOver && solidSource)
+        op.mode = QPainter::CompositionMode_Source;
+
+    op.dest_fetch = destFetchProc[data->rasterBuffer->format];
+    if (op.mode == QPainter::CompositionMode_Source) {
+        switch (data->rasterBuffer->format) {
+        case QImage::Format_RGB32:
+        case QImage::Format_ARGB32_Premultiplied:
+            // don't clear dest_fetch as it sets up the pointer correctly to save one copy
+            break;
+        default: {
+            const QSpan *lastSpan = spans + spanCount;
+            bool alphaSpans = false;
+            while (spans < lastSpan) {
+                if (spans->coverage != 255) {
+                    alphaSpans = true;
+                    break;
+                }
+                ++spans;
+            }
+            if (!alphaSpans)
+                op.dest_fetch = 0;
+        }
+        }
+    }
+
+    op.dest_store = destStoreProc[data->rasterBuffer->format];
+
+    op.funcSolid = functionForModeSolid[op.mode];
+    op.func = functionForMode[op.mode];
+
+    return op;
+}
+
+
+
+// -------------------- blend methods ---------------------
+
+enum SpanMethod {
+    RegularSpans,
+    CallbackSpans
+};
+
+#if !defined(Q_CC_SUN)
+static
+#endif
+void drawBufferSpan(QSpanData *data, const uint *buffer, int bufsize,
+                           int x, int y, int length, uint const_alpha)
+{
+#if defined (Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+    data->rasterEngine->drawBufferSpan(buffer, bufsize, x, y, length, const_alpha);
+#else
+    Q_UNUSED(data);
+    Q_UNUSED(buffer);
+    Q_UNUSED(bufsize);
+    Q_UNUSED(x);
+    Q_UNUSED(y);
+    Q_UNUSED(length);
+    Q_UNUSED(const_alpha);
+#endif
+}
+
+#if !defined(Q_CC_SUN)
+static
+#endif
+void blend_color_generic(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    uint buffer[buffer_size];
+    Operator op = getOperator(data, spans, count);
+
+    while (count--) {
+        int x = spans->x;
+        int length = spans->len;
+        while (length) {
+            int l = qMin(buffer_size, length);
+            uint *dest = op.dest_fetch ? op.dest_fetch(buffer, data->rasterBuffer, x, spans->y, l) : buffer;
+            op.funcSolid(dest, l, data->solid.color, spans->coverage);
+            if (op.dest_store)
+                op.dest_store(data->rasterBuffer, x, spans->y, dest, l);
+            length -= l;
+            x += l;
+        }
+        ++spans;
+    }
+}
+
+#if defined (Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+static void blend_color_generic_callback(int count, const QSpan *spans, void *userData)
+{
+    // ### Falcon
+    Q_UNUSED(count);
+    Q_UNUSED(spans);
+    Q_UNUSED(userData);
+//     QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+//     data->rasterEngine->drawColorSpans(spans, count, data->solid.color);
+}
+#endif // QT_NO_RASTERCALLBACKS
+
+static void blend_color_argb(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    Operator op = getOperator(data, spans, count);
+
+    if (op.mode == QPainter::CompositionMode_Source) {
+        // inline for performance
+        while (count--) {
+            uint *target = ((uint *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+            if (spans->coverage == 255) {
+                QT_MEMFILL_UINT(target, spans->len, data->solid.color);
+            } else {
+                uint c = BYTE_MUL(data->solid.color, spans->coverage);
+                int ialpha = 255 - spans->coverage;
+                for (int i = 0; i < spans->len; ++i)
+                    target[i] = c + BYTE_MUL(target[i], ialpha);
+            }
+            ++spans;
+        }
+        return;
+    }
+
+    while (count--) {
+        uint *target = ((uint *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+        op.funcSolid(target, spans->len, data->solid.color, spans->coverage);
+        ++spans;
+    }
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_FUNCTION void blendColor(int count, const QSpan *spans, void *userData
+                       Q_TEMPLATE_FIX(T))
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    Operator op = getOperator(data, spans, count);
+
+    if (op.mode == QPainter::CompositionMode_Source) {
+        const T c = qt_colorConvert<T, quint32p>(quint32p::fromRawData(data->solid.color), 0);
+        while (count--) {
+            T *target = ((T*)data->rasterBuffer->scanLine(spans->y))
+                        + spans->x;
+            if (spans->coverage == 255) {
+                qt_memfill(target, c, spans->len);
+            } else {
+                const quint8 alpha = T::alpha(spans->coverage);
+                const T color = c.byte_mul(alpha);
+                const int ialpha = T::ialpha(spans->coverage);
+                const T *end = target + spans->len;
+                while (target < end) {
+                    *target = color + target->byte_mul(ialpha);
+                    ++target;
+                }
+            }
+            ++spans;
+        }
+        return;
+    }
+
+    if (op.mode == QPainter::CompositionMode_SourceOver) {
+        while (count--) {
+            const quint32 color = BYTE_MUL(data->solid.color, spans->coverage);
+            const T c = qt_colorConvert<T, quint32p>(quint32p::fromRawData(color), 0);
+            const quint8 ialpha = T::alpha(qAlpha(~color));
+            T *target = ((T*)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+            const T *end = target + spans->len;
+            while (target != end) {
+                *target = c + target->byte_mul(ialpha);
+                ++target;
+            }
+            ++spans;
+        }
+        return;
+    }
+
+    blend_color_generic(count, spans, userData);
+}
+
+#if defined(Q_CC_MSVC) && _MSC_VER <= 1300 && !defined(Q_CC_INTEL)
+#define BLEND_COLOR_DECL(DST)                                           \
+    static void blendColor_##DST(int count,                             \
+                                 const QSpan *spans,                    \
+                                 void *userData)                        \
+    {                                                                   \
+        blendColor<DST>(count, spans, userData Q_TEMPLATE_CALL(DST));   \
+    }
+
+BLEND_COLOR_DECL(qargb8565)
+BLEND_COLOR_DECL(qrgb666)
+BLEND_COLOR_DECL(qargb6666)
+BLEND_COLOR_DECL(qrgb555)
+BLEND_COLOR_DECL(qargb8555)
+BLEND_COLOR_DECL(qrgb888)
+BLEND_COLOR_DECL(qrgb444)
+BLEND_COLOR_DECL(qargb4444)
+#undef DEST_FETCH_DECL
+#define SPANFUNC_POINTER_BLENDCOLOR(DST) blendColor_##DST
+#else // !VC6 && !VC2002
+# define SPANFUNC_POINTER_BLENDCOLOR(DST) blendColor<DST>
+#endif
+
+static void blend_color_rgb16(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    /*
+        We duplicate a little logic from getOperator() and calculate the
+        composition mode directly.  This allows blend_color_rgb16 to be used
+        from qt_gradient_quint16 with minimal overhead.
+     */
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+    if (mode == QPainter::CompositionMode_SourceOver &&
+        qAlpha(data->solid.color) == 255)
+        mode = QPainter::CompositionMode_Source;
+
+    if (mode == QPainter::CompositionMode_Source) {
+        // inline for performance
+        ushort c = qConvertRgb32To16(data->solid.color);
+        while (count--) {
+            ushort *target = ((ushort *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+            if (spans->coverage == 255) {
+                QT_MEMFILL_USHORT(target, spans->len, c);
+            } else {
+                ushort color = BYTE_MUL_RGB16(c, spans->coverage);
+                int ialpha = 255 - spans->coverage;
+                const ushort *end = target + spans->len;
+                while (target < end) {
+                    *target = color + BYTE_MUL_RGB16(*target, ialpha);
+                    ++target;
+                }
+            }
+            ++spans;
+        }
+        return;
+    }
+
+    if (mode == QPainter::CompositionMode_SourceOver) {
+        while (count--) {
+            uint color = BYTE_MUL(data->solid.color, spans->coverage);
+            int ialpha = qAlpha(~color);
+            ushort c = qConvertRgb32To16(color);
+            ushort *target = ((ushort *)data->rasterBuffer->scanLine(spans->y)) + spans->x;
+            int len = spans->len;
+            bool pre = (((quintptr)target) & 0x3) != 0;
+            bool post = false;
+            if (pre) {
+                // skip to word boundary
+                *target = c + BYTE_MUL_RGB16(*target, ialpha);
+                ++target;
+                --len;
+            }
+            if (len & 0x1) {
+                post = true;
+                --len;
+            }
+            uint *target32 = (uint*)target;
+            uint c32 = c | (c<<16);
+            len >>= 1;
+            uint salpha = (ialpha+1) >> 3; // calculate here rather than in loop
+            while (len--) {
+                // blend full words
+                *target32 = c32 + BYTE_MUL_RGB16_32(*target32, salpha);
+                ++target32;
+                target += 2;
+            }
+            if (post) {
+                // one last pixel beyond a full word
+                *target = c + BYTE_MUL_RGB16(*target, ialpha);
+            }
+            ++spans;
+        }
+        return;
+    }
+
+    blend_color_generic(count, spans, userData);
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_src_generic(int count, const QSpan *spans, void *userData
+                              Q_TEMPLATE_ENUM_FIX(SpanMethod, spanMethod))
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    uint buffer[buffer_size];
+    uint src_buffer[buffer_size];
+    Operator op = getOperator(data, spans, count);
+
+    uint const_alpha = 256;
+    if (data->type == QSpanData::Texture)
+        const_alpha = data->texture.const_alpha;
+
+    while (count--) {
+        int x = spans->x;
+        int length = spans->len;
+        const int coverage = (spans->coverage * const_alpha) >> 8;
+        while (length) {
+            int l = qMin(buffer_size, length);
+            const uint *src = op.src_fetch(src_buffer, &op, data, spans->y, x, l);
+            if (spanMethod == RegularSpans) {
+                uint *dest = op.dest_fetch ? op.dest_fetch(buffer, data->rasterBuffer, x, spans->y, l) : buffer;
+                op.func(dest, src, l, coverage);
+                if (op.dest_store)
+                    op.dest_store(data->rasterBuffer, x, spans->y, dest, l);
+            } else {
+                drawBufferSpan(data, src, l, x, spans->y, l, coverage);
+            }
+            x += l;
+            length -= l;
+        }
+        ++spans;
+    }
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_untransformed_generic(int count, const QSpan *spans, void *userData
+                                        Q_TEMPLATE_ENUM_FIX(SpanMethod, spanMethod))
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    uint buffer[buffer_size];
+    uint src_buffer[buffer_size];
+    Operator op = getOperator(data, spans, count);
+
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx);
+    int yoff = -qRound(-data->dy);
+
+    while (count--) {
+        int x = spans->x;
+        int length = spans->len;
+        int sx = xoff + x;
+        int sy = yoff + spans->y;
+        if (sy >= 0 && sy < image_height && sx < image_width) {
+            if (sx < 0) {
+                x -= sx;
+                length += sx;
+                sx = 0;
+            }
+            if (sx + length > image_width)
+                length = image_width - sx;
+            if (length > 0) {
+                const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+                while (length) {
+                    int l = qMin(buffer_size, length);
+                    const uint *src = op.src_fetch(src_buffer, &op, data, sy, sx, l);
+                    if (spanMethod == RegularSpans) {
+                        uint *dest = op.dest_fetch ? op.dest_fetch(buffer, data->rasterBuffer, x, spans->y, l) : buffer;
+                        op.func(dest, src, l, coverage);
+                        if (op.dest_store)
+                            op.dest_store(data->rasterBuffer, x, spans->y, dest, l);
+                    } else {
+                        drawBufferSpan(data, src, l, x, spans->y,
+                                       l, coverage);
+                    }
+                    x += l;
+                    sx += l;
+                    length -= l;
+                }
+            }
+        }
+        ++spans;
+    }
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_untransformed_argb(int count, const QSpan *spans, void *userData
+                                     Q_TEMPLATE_ENUM_FIX(SpanMethod, spanMethod))
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    if (data->texture.format != QImage::Format_ARGB32_Premultiplied
+        && data->texture.format != QImage::Format_RGB32) {
+        blend_untransformed_generic<spanMethod>(count, spans, userData Q_TEMPLATE_ENUM_CALL(SpanMethod, spanMethod));
+        return;
+    }
+
+    Operator op = getOperator(data, spans, count);
+
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx);
+    int yoff = -qRound(-data->dy);
+
+    while (count--) {
+        int x = spans->x;
+        int length = spans->len;
+        int sx = xoff + x;
+        int sy = yoff + spans->y;
+        if (sy >= 0 && sy < image_height && sx < image_width) {
+            if (sx < 0) {
+                x -= sx;
+                length += sx;
+                sx = 0;
+            }
+            if (sx + length > image_width)
+                length = image_width - sx;
+            if (length > 0) {
+                const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+                const uint *src = (uint *)data->texture.scanLine(sy) + sx;
+                if (spanMethod == RegularSpans) {
+                    uint *dest = ((uint *)data->rasterBuffer->scanLine(spans->y)) + x;
+                    op.func(dest, src, length, coverage);
+                } else {
+                    drawBufferSpan(data, src, length, x,
+                                   spans->y, length, coverage);
+                }
+            }
+        }
+        ++spans;
+    }
+}
+
+static inline quint16 interpolate_pixel_rgb16_255(quint16 x, quint8 a,
+                                                  quint16 y, quint8 b)
+{
+    quint16 t = ((((x & 0x07e0) * a) + ((y & 0x07e0) * b)) >> 5) & 0x07e0;
+    t |= ((((x & 0xf81f) * a) + ((y & 0xf81f) * b)) >> 5) & 0xf81f;
+
+    return t;
+}
+
+static inline quint32 interpolate_pixel_rgb16x2_255(quint32 x, quint8 a,
+                                                    quint32 y, quint8 b)
+{
+    uint t;
+    t = ((((x & 0xf81f07e0) >> 5) * a) + (((y & 0xf81f07e0) >> 5) * b)) & 0xf81f07e0;
+    t |= ((((x & 0x07e0f81f) * a) + ((y & 0x07e0f81f) * b)) >> 5) & 0x07e0f81f;
+    return t;
+}
+
+static inline void blend_sourceOver_rgb16_rgb16(quint16 *dest,
+                                                const quint16 *src,
+                                                int length,
+                                                const quint8 alpha,
+                                                const quint8 ialpha)
+{
+    const int dstAlign = ((quintptr)dest) & 0x3;
+    if (dstAlign) {
+        *dest = interpolate_pixel_rgb16_255(*src, alpha, *dest, ialpha);
+        ++dest;
+        ++src;
+        --length;
+    }
+    const int srcAlign = ((quintptr)src) & 0x3;
+    int length32 = length >> 1;
+    if (length32 && srcAlign == 0) {
+        while (length32--) {
+            const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+            quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+            *dest32 = interpolate_pixel_rgb16x2_255(*src32, alpha,
+                                                    *dest32, ialpha);
+            dest += 2;
+            src += 2;
+        }
+        length &= 0x1;
+    }
+    while (length--) {
+        *dest = interpolate_pixel_rgb16_255(*src, alpha, *dest, ialpha);
+        ++dest;
+        ++src;
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline void madd_2(DST *dest, const quint16 alpha, const SRC *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+    dest[0] = dest[0].byte_mul(alpha >> 8) + DST(src[0]);
+    dest[1] = dest[1].byte_mul(alpha & 0xff) + DST(src[1]);
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline void madd_4(DST *dest, const quint32 alpha, const SRC *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+    dest[0] = dest[0].byte_mul(alpha >> 24) + DST(src[0]);
+    dest[1] = dest[1].byte_mul((alpha >> 16) & 0xff) + DST(src[1]);
+    dest[2] = dest[2].byte_mul((alpha >> 8) & 0xff) + DST(src[2]);
+    dest[3] = dest[3].byte_mul(alpha & 0xff) + DST(src[3]);
+}
+
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline void madd_4(qargb8565 *dest, const quint32 a, const qargb8565 *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+    quint32 x, y, t;
+    quint8 a8;
+
+    {
+        x = dest32[0];
+        y = src32[0];
+
+        a8 = a >> 24;
+
+        // a0,g0
+        t = ((((x & 0x0007e0ff) * a8) >> 5) & 0x0007e0ff) + (y & 0x0007c0f8);
+
+        // r0,b0
+        t |= ((((x & 0x00f81f00) * a8) >> 5) & 0x00f81f00) + (y & 0x00f81f00);
+
+        a8 = (a >> 16) & 0xff;
+
+        // a1
+        t |= ((((x & 0xff000000) >> 5) * a8) & 0xff000000) + (y & 0xf8000000);
+
+        dest32[0] = t;
+    }
+    {
+        x = dest32[1];
+        y = src32[1];
+
+        // r1,b1
+        t = ((((x & 0x0000f81f) * a8) >> 5) & 0x0000f81f) + (y & 0x0000f81f);
+
+        // g1
+        t |= ((((x & 0x000007e0) * a8) >> 5) & 0x000007e0) + (y & 0x000007c0);
+
+        a8 = (a >> 8) & 0xff;
+
+        // a2
+        t |= ((((x & 0x00ff0000) * a8) >> 5)  & 0x00ff0000) + (y & 0x00f80000);
+
+        {
+            // rgb2
+            quint16 x16 = (x >> 24) | ((dest32[2] & 0x000000ff) << 8);
+            quint16 y16 = (y >> 24) | ((src32[2] & 0x000000ff) << 8);
+            quint16 t16;
+
+            t16 = ((((x16 & 0xf81f) * a8) >> 5) & 0xf81f)  + (y16 & 0xf81f);
+            t16 |= ((((x16 & 0x07e0) * a8) >> 5) & 0x07e0)  + (y16 & 0x07c0);
+
+            // rg2
+            t |= ((t16 & 0x00ff) << 24);
+
+            dest32[1] = t;
+
+            x = dest32[2];
+            y = src32[2];
+
+            // gb2
+            t = (t16 >> 8);
+        }
+    }
+    {
+        a8 = a & 0xff;
+
+        // g3,a3
+        t |= ((((x & 0x07e0ff00) * a8) >> 5) & 0x07e0ff00) + (y & 0x07c0f800);
+
+        // r3,b3
+        t |= ((((x & 0xf81f0000) >> 5) * a8) & 0xf81f0000)+ (y & 0xf81f0000);
+
+        dest32[2] = t;
+    }
+}
+#endif
+
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline void madd_4(qargb8555 *dest, const quint32 a, const qargb8555 *src)
+{
+    Q_ASSERT((quintptr(dest) & 0x3) == 0);
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+    quint32 x, y, t;
+    quint8 a8;
+
+    {
+        x = dest32[0];
+        y = src32[0];
+
+        a8 = a >> 24;
+
+        // a0,g0
+        t = ((((x & 0x0003e0ff) * a8) >> 5) & 0x0003e0ff) + (y & 0x0003e0f8);
+
+        // r0,b0
+        t |= ((((x & 0x007c1f00) * a8) >> 5) & 0x007c1f00) + (y & 0x007c1f00);
+
+        a8 = (a >> 16) & 0xff;
+
+        // a1
+        t |= ((((x & 0xff000000) >> 5) * a8) & 0xff000000) + (y & 0xf8000000);
+
+        dest32[0] = t;
+    }
+    {
+        x = dest32[1];
+        y = src32[1];
+
+        // r1,b1
+        t = ((((x & 0x00007c1f) * a8) >> 5) & 0x00007c1f) + (y & 0x00007c1f);
+
+        // g1
+        t |= ((((x & 0x000003e0) * a8) >> 5) & 0x000003e0) + (y & 0x000003e0);
+
+        a8 = (a >> 8) & 0xff;
+
+        // a2
+        t |= ((((x & 0x00ff0000) * a8) >> 5)  & 0x00ff0000) + (y & 0x00f80000);
+
+        {
+            // rgb2
+            quint16 x16 = (x >> 24) | ((dest32[2] & 0x000000ff) << 8);
+            quint16 y16 = (y >> 24) | ((src32[2] & 0x000000ff) << 8);
+            quint16 t16;
+
+            t16 = ((((x16 & 0x7c1f) * a8) >> 5) & 0x7c1f)  + (y16 & 0x7c1f);
+            t16 |= ((((x16 & 0x03e0) * a8) >> 5) & 0x03e0)  + (y16 & 0x03e0);
+
+            // rg2
+            t |= ((t16 & 0x00ff) << 24);
+
+            dest32[1] = t;
+
+            x = dest32[2];
+            y = src32[2];
+
+            // gb2
+            t = (t16 >> 8);
+        }
+    }
+    {
+        a8 = a & 0xff;
+
+        // g3,a3
+        t |= ((((x & 0x03e0ff00) * a8) >> 5) & 0x03e0ff00) + (y & 0x03e0f800);
+
+        // r3,b3
+        t |= ((((x & 0x7c1f0000) >> 5) * a8) & 0x7c1f0000)+ (y & 0x7c1f0000);
+
+        dest32[2] = t;
+    }
+}
+#endif
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 alpha_2(const T *src)
+{
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    if (T::hasAlpha())
+        return (src[0].alpha() << 8) | src[1].alpha();
+    else
+        return 0xffff;
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 alpha_4(const T *src)
+{
+    Q_ASSERT((quintptr(src) & 0x3) == 0);
+
+    if (T::hasAlpha()) {
+        return (src[0].alpha() << 24) | (src[1].alpha() << 16)
+            | (src[2].alpha() << 8) | src[3].alpha();
+    } else {
+        return 0xffffffff;
+    }
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 alpha_4(const qargb8565 *src)
+{
+    const quint8 *src8 = reinterpret_cast<const quint8*>(src);
+    return src8[0] << 24 | src8[3] << 16 | src8[6] << 8 | src8[9];
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 alpha_4(const qargb6666 *src)
+{
+    const quint8 *src8 = reinterpret_cast<const quint8*>(src);
+    return ((src8[2] & 0xfc) | (src8[2] >> 6)) << 24
+        | ((src8[5] & 0xfc) | (src8[5] >> 6))  << 16
+        | ((src8[8] & 0xfc) | (src8[8] >> 6)) << 8
+        | ((src8[11] & 0xfc) | (src8[11] >> 6));
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 alpha_4(const qargb8555 *src)
+{
+    Q_ASSERT((long(src) & 0x3) == 0);
+    const quint8 *src8 = reinterpret_cast<const quint8*>(src);
+    return src8[0] << 24 | src8[3] << 16 | src8[6] << 8 | src8[9];
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 alpha_2(const qargb4444 *src)
+{
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    const quint32 t = (*src32 & 0xf000f000) |
+                      ((*src32 & 0xf000f000) >> 4);
+    return (t >> 24) | (t & 0xff00);
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_alpha_2(quint16 alpha, const T*)
+{
+    return (T::alpha((alpha >> 8) & 0xff) << 8)
+        | T::alpha(alpha & 0xff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_alpha_2(quint16 a, const qrgb565*)
+{
+    return ((((a & 0xff00) + 0x0100) >> 3) & 0xff00)
+        | ((((a & 0x00ff) + 0x0001) >> 3) & 0x00ff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_alpha_2(quint16 a, const qrgb444*)
+{
+    return (((a & 0x00ff) + 0x0001) >> 4)
+        | ((((a & 0xff00) + 0x0100) >> 4) & 0xff00);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_alpha_2(quint16 a, const qargb4444*)
+{
+    return (((a & 0x00ff) + 0x0001) >> 4)
+        | ((((a & 0xff00) + 0x0100) >> 4) & 0xff00);
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_ialpha_2(quint16 alpha, const T*)
+{
+    return (T::ialpha((alpha >> 8) & 0xff) << 8)
+        | T::ialpha(alpha & 0xff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_ialpha_2(quint16 a, const qrgb565 *dummy)
+{
+    return 0x2020 - eff_alpha_2(a, dummy);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_ialpha_2(quint16 a, const qargb4444 *dummy)
+{
+    return 0x1010 - eff_alpha_2(a, dummy);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint16 eff_ialpha_2(quint16 a, const qrgb444 *dummy)
+{
+    return 0x1010 - eff_alpha_2(a, dummy);
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 alpha, const T*)
+{
+    return (T::alpha(alpha >> 24) << 24)
+        | (T::alpha((alpha >> 16) & 0xff) << 16)
+        | (T::alpha((alpha >> 8) & 0xff) << 8)
+        | T::alpha(alpha & 0xff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 a, const qrgb888*)
+{
+    return a;
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 a, const qargb8565*)
+{
+    return ((((a & 0xff00ff00) + 0x01000100) >> 3) & 0xff00ff00)
+        | ((((a & 0x00ff00ff) + 0x00010001) >> 3) & 0x00ff00ff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 a, const qargb6666*)
+{
+    return ((((a & 0xff00ff00) >> 2) + 0x00400040) & 0xff00ff00)
+        | ((((a & 0x00ff00ff) + 0x00010001) >> 2) & 0x00ff00ff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 a, const qrgb666*)
+{
+    return ((((a & 0xff00ff00) >> 2) + 0x00400040) & 0xff00ff00)
+        | ((((a & 0x00ff00ff) + 0x00010001) >> 2) & 0x00ff00ff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_alpha_4(quint32 a, const qargb8555*)
+{
+    return ((((a & 0xff00ff00) + 0x01000100) >> 3) & 0xff00ff00)
+        | ((((a & 0x00ff00ff) + 0x00010001) >> 3) & 0x00ff00ff);
+}
+
+template <class T>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 alpha, const T*)
+{
+    return (T::ialpha(alpha >> 24) << 24)
+        | (T::ialpha((alpha >> 16) & 0xff) << 16)
+        | (T::ialpha((alpha >> 8) & 0xff) << 8)
+        | T::ialpha(alpha & 0xff);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 a, const qrgb888*)
+{
+    return ~a;
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 a, const qargb8565 *dummy)
+{
+    return 0x20202020 - eff_alpha_4(a, dummy);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 a, const qargb6666 *dummy)
+{
+    return 0x40404040 - eff_alpha_4(a, dummy);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 a, const qrgb666 *dummy)
+{
+    return 0x40404040 - eff_alpha_4(a, dummy);
+}
+
+template <>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+inline quint32 eff_ialpha_4(quint32 a, const qargb8555 *dummy)
+{
+    return 0x20202020 - eff_alpha_4(a, dummy);
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel_unaligned_2(DST *dest, const SRC *src,
+                                          quint16 alpha)
+{
+    const quint16 a = eff_alpha_2(alpha, dest);
+    const quint16 ia = eff_ialpha_2(alpha, dest);
+    dest[0] = DST(src[0]).byte_mul(a >> 8) + dest[0].byte_mul(ia >> 8);
+    dest[1] = DST(src[1]).byte_mul(a & 0xff) + dest[1].byte_mul(ia & 0xff);
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel_2(DST *dest, const SRC *src, quint16 alpha)
+{
+    Q_ASSERT((long(dest) & 0x3) == 0);
+    Q_ASSERT((long(src) & 0x3) == 0);
+
+    const quint16 a = eff_alpha_2(alpha, dest);
+    const quint16 ia = eff_ialpha_2(alpha, dest);
+
+    dest[0] = DST(src[0]).byte_mul(a >> 8) + dest[0].byte_mul(ia >> 8);
+    dest[1] = DST(src[1]).byte_mul(a & 0xff) + dest[1].byte_mul(ia & 0xff);
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel(DST &dest, quint8 a, const SRC &src, quint8 b)
+{
+    if (SRC::hasAlpha() && !DST::hasAlpha())
+        interpolate_pixel(dest, a, DST(src), b);
+    else
+        dest = dest.byte_mul(a) + DST(src).byte_mul(b);
+}
+
+template <>
+inline void interpolate_pixel(qargb8565 &dest, quint8 a,
+                              const qargb8565 &src, quint8 b)
+{
+    quint8 *d = reinterpret_cast<quint8*>(&dest);
+    const quint8 *s = reinterpret_cast<const quint8*>(&src);
+    d[0] = (d[0] * a + s[0] * b) >> 5;
+
+    const quint16 x = (d[2] << 8) | d[1];
+    const quint16 y = (s[2] << 8) | s[1];
+    quint16 t = (((x & 0x07e0) * a + (y & 0x07e0) * b) >> 5) & 0x07e0;
+    t |= (((x & 0xf81f) * a + (y & 0xf81f) * b) >> 5) & 0xf81f;
+
+    d[1] = t & 0xff;
+    d[2] = t >> 8;
+}
+
+template <>
+inline void interpolate_pixel(qrgb565 &dest, quint8 a,
+                              const qrgb565 &src, quint8 b)
+{
+    const quint16 x = dest.rawValue();
+    const quint16 y = src.rawValue();
+    quint16 t = (((x & 0x07e0) * a + (y & 0x07e0) * b) >> 5) & 0x07e0;
+    t |= (((x & 0xf81f) * a + (y & 0xf81f) * b) >> 5) & 0xf81f;
+    dest = t;
+}
+
+template <>
+inline void interpolate_pixel(qrgb555 &dest, quint8 a,
+                              const qrgb555 &src, quint8 b)
+{
+    const quint16 x = dest.rawValue();
+    const quint16 y = src.rawValue();
+    quint16 t = (((x & 0x03e0) * a + (y & 0x03e0) * b) >> 5) & 0x03e0;
+    t |= ((((x & 0x7c1f) * a) + ((y & 0x7c1f) * b)) >> 5) & 0x7c1f;
+    dest = t;
+}
+
+template <>
+inline void interpolate_pixel(qrgb444 &dest, quint8 a,
+                              const qrgb444 &src, quint8 b)
+{
+    const quint16 x = dest.rawValue();
+    const quint16 y = src.rawValue();
+    quint16 t = ((x & 0x00f0) * a + (y & 0x00f0) * b) & 0x0f00;
+    t |= ((x & 0x0f0f) * a + (y & 0x0f0f) * b) & 0xf0f0;
+    quint16 *d = reinterpret_cast<quint16*>(&dest);
+    *d = (t >> 4);
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel_2(DST *dest, quint8 a,
+                                const SRC *src, quint8 b)
+{
+    Q_ASSERT((long(dest) & 0x3) == 0);
+    Q_ASSERT((long(src) & 0x3) == 0);
+
+    Q_ASSERT(!SRC::hasAlpha());
+
+    dest[0] = dest[0].byte_mul(a) + DST(src[0]).byte_mul(b);
+    dest[1] = dest[1].byte_mul(a) + DST(src[1]).byte_mul(b);
+}
+
+template <>
+inline void interpolate_pixel_2(qrgb565 *dest, quint8 a,
+                                const qrgb565 *src, quint8 b)
+{
+    quint32 *x = reinterpret_cast<quint32*>(dest);
+    const quint32 *y = reinterpret_cast<const quint32*>(src);
+    quint32 t = (((*x & 0xf81f07e0) >> 5) * a +
+                 ((*y & 0xf81f07e0) >> 5) * b) & 0xf81f07e0;
+    t |= (((*x & 0x07e0f81f) * a
+           + (*y & 0x07e0f81f) * b) >> 5) & 0x07e0f81f;
+    *x = t;
+}
+
+template <>
+inline void interpolate_pixel_2(qrgb555 *dest, quint8 a,
+                                const qrgb555 *src, quint8 b)
+{
+    quint32 *x = reinterpret_cast<quint32*>(dest);
+    const quint32 *y = reinterpret_cast<const quint32*>(src);
+    quint32 t = (((*x & 0x7c1f03e0) >> 5) * a +
+                 ((*y & 0x7c1f03e0) >> 5) * b) & 0x7c1f03e0;
+    t |= (((*x & 0x03e07c1f) * a
+           + (*y & 0x03e07c1f) * b) >> 5) & 0x03e07c1f;
+    *x = t;
+}
+
+template <>
+inline void interpolate_pixel_2(qrgb444 *dest, quint8 a,
+                                const qrgb444 *src, quint8 b)
+{
+    quint32 *x = reinterpret_cast<quint32*>(dest);
+    const quint32 *y = reinterpret_cast<const quint32*>(src);
+    quint32 t = ((*x & 0x0f0f0f0f) * a + (*y & 0x0f0f0f0f) * b) & 0xf0f0f0f0;
+    t |= ((*x & 0x00f000f0) * a + (*y & 0x00f000f0) * b) & 0x0f000f00;
+    *x = t >> 4;
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel_4(DST *dest, const SRC *src, quint32 alpha)
+{
+    Q_ASSERT((long(dest) & 0x3) == 0);
+    Q_ASSERT((long(src) & 0x3) == 0);
+
+    const quint32 a = eff_alpha_4(alpha, dest);
+    const quint32 ia = eff_ialpha_4(alpha, dest);
+    dest[0] = DST(src[0]).byte_mul(a >> 24)
+              + dest[0].byte_mul(ia >> 24);
+    dest[1] = DST(src[1]).byte_mul((a >> 16) & 0xff)
+              + dest[1].byte_mul((ia >> 16) & 0xff);
+    dest[2] = DST(src[2]).byte_mul((a >> 8) & 0xff)
+              + dest[2].byte_mul((ia >> 8) & 0xff);
+    dest[3] = DST(src[3]).byte_mul(a & 0xff)
+              + dest[3].byte_mul(ia & 0xff);
+}
+
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+template <>
+inline void interpolate_pixel_4(qargb8565 *dest, const qargb8565 *src,
+                                quint32 alpha)
+{
+    Q_ASSERT((long(dest) & 0x3) == 0);
+    Q_ASSERT((long(src) & 0x3) == 0);
+
+    const quint32 a = eff_alpha_4(alpha, dest);
+    const quint32 ia = eff_ialpha_4(alpha, dest);
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+
+    quint32 x, y, t;
+    quint8 a8, ia8;
+    {
+        x = src32[0];
+        y = dest32[0];
+
+        a8 = a >> 24;
+        ia8 = ia >> 24;
+
+        // a0,g0
+        t = (((x & 0x0007e0ff) * a8 + (y & 0x0007e0ff) * ia8) >> 5)
+            & 0x0007e0ff;
+
+        // r0,b0
+        t |= (((x & 0x00f81f00) * a8 + (y & 0x00f81f00) * ia8) >> 5)
+             & 0x00f81f00;
+
+        a8 = (a >> 16) & 0xff;
+        ia8 = (ia >> 16) & 0xff;
+
+        // a1
+        t |= (((x & 0xff000000) >> 5) * a8 + ((y & 0xff000000) >> 5) * ia8)
+             & 0xff000000;
+
+        dest32[0] = t;
+    }
+    {
+        x = src32[1];
+        y = dest32[1];
+
+        // r1,b1
+        t = (((x & 0x0000f81f) * a8 + (y & 0x0000f81f) * ia8) >> 5)
+            & 0x0000f81f;
+
+        // g1
+        t |= (((x & 0x000007e0) * a8 + (y & 0x000007e0) * ia8) >> 5)
+             & 0x000007e0;
+
+        a8 = (a >> 8) & 0xff;
+        ia8 = (ia >> 8) & 0xff;
+
+        // a2
+        t |= (((x & 0x00ff0000) * a8 + (y & 0x00ff0000) * ia8) >> 5)
+             & 0x00ff0000;
+
+        {
+            // rgb2
+            quint16 x16 = (x >> 24) | ((src32[2] & 0x000000ff) << 8);
+            quint16 y16 = (y >> 24) | ((dest32[2] & 0x000000ff) << 8);
+            quint16 t16;
+
+            t16 = (((x16 & 0xf81f) * a8 + (y16 & 0xf81f) * ia8) >> 5) & 0xf81f;
+            t16 |= (((x16 & 0x07e0) * a8 + (y16 & 0x07e0) * ia8) >> 5) & 0x07e0;
+
+            // rg2
+            t |= ((t16 & 0x00ff) << 24);
+
+            dest32[1] = t;
+
+            x = src32[2];
+            y = dest32[2];
+
+            // gb2
+            t = (t16 >> 8);
+        }
+    }
+    {
+        a8 = a & 0xff;
+        ia8 = ia & 0xff;
+
+        // g3,a3
+        t |= (((x & 0x07e0ff00) * a8 + (y & 0x07e0ff00) * ia8) >> 5)
+             & 0x07e0ff00;
+
+        // r3,b3
+        t |= (((x & 0xf81f0000) >> 5) * a8 + ((y & 0xf81f0000) >> 5) * ia8)
+             & 0xf81f0000;
+
+        dest32[2] = t;
+    }
+}
+#endif
+
+#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
+template <>
+inline void interpolate_pixel_4(qargb8555 *dest, const qargb8555 *src,
+                                quint32 alpha)
+{
+    Q_ASSERT((long(dest) & 0x3) == 0);
+    Q_ASSERT((long(src) & 0x3) == 0);
+
+
+    const quint32 a = eff_alpha_4(alpha, dest);
+    const quint32 ia = eff_ialpha_4(alpha, dest);
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+
+    quint32 x, y, t;
+    quint8 a8, ia8;
+    {
+        x = src32[0];
+        y = dest32[0];
+
+        a8 = a >> 24;
+        ia8 = ia >> 24;
+
+        // a0,g0
+        t = (((x & 0x0003e0ff) * a8 + (y & 0x0003e0ff) * ia8) >> 5)
+            & 0x0003e0ff;
+
+        // r0,b0
+        t |= (((x & 0x007c1f00) * a8 + (y & 0x007c1f00) * ia8) >> 5)
+             & 0x007c1f00;
+
+        a8 = (a >> 16) & 0xff;
+        ia8 = (ia >> 16) & 0xff;
+
+        // a1
+        t |= (((x & 0xff000000) >> 5) * a8 + ((y & 0xff000000) >> 5) * ia8)
+             & 0xff000000;
+
+        dest32[0] = t;
+    }
+    {
+        x = src32[1];
+        y = dest32[1];
+
+        // r1,b1
+        t = (((x & 0x00007c1f) * a8 + (y & 0x00007c1f) * ia8) >> 5)
+            & 0x00007c1f;
+
+        // g1
+        t |= (((x & 0x000003e0) * a8 + (y & 0x000003e0) * ia8) >> 5)
+             & 0x000003e0;
+
+        a8 = (a >> 8) & 0xff;
+        ia8 = (ia >> 8) & 0xff;
+
+        // a2
+        t |= (((x & 0x00ff0000) * a8 + (y & 0x00ff0000) * ia8) >> 5)
+             & 0x00ff0000;
+
+        {
+            // rgb2
+            quint16 x16 = (x >> 24) | ((src32[2] & 0x000000ff) << 8);
+            quint16 y16 = (y >> 24) | ((dest32[2] & 0x000000ff) << 8);
+            quint16 t16;
+
+            t16 = (((x16 & 0x7c1f) * a8 + (y16 & 0x7c1f) * ia8) >> 5) & 0x7c1f;
+            t16 |= (((x16 & 0x03e0) * a8 + (y16 & 0x03e0) * ia8) >> 5) & 0x03e0;
+
+            // rg2
+            t |= ((t16 & 0x00ff) << 24);
+
+            dest32[1] = t;
+
+            x = src32[2];
+            y = dest32[2];
+
+            // gb2
+            t = (t16 >> 8);
+        }
+    }
+    {
+        a8 = a & 0xff;
+        ia8 = ia & 0xff;
+
+        // g3,a3
+        t |= (((x & 0x03e0ff00) * a8 + (y & 0x03e0ff00) * ia8) >> 5)
+             & 0x03e0ff00;
+
+        // r3,b3
+        t |= (((x & 0x7c1f0000) >> 5) * a8 + ((y & 0x7c1f0000) >> 5) * ia8)
+             & 0x7c1f0000;
+
+        dest32[2] = t;
+    }
+}
+#endif
+
+template <>
+inline void interpolate_pixel_4(qrgb888 *dest, const qrgb888 *src,
+                                quint32 alpha)
+{
+    Q_ASSERT((long(dest) & 0x3) == 0);
+    Q_ASSERT((long(src) & 0x3) == 0);
+
+    const quint32 a = eff_alpha_4(alpha, dest);
+    const quint32 ia = eff_ialpha_4(alpha, dest);
+    const quint32 *src32 = reinterpret_cast<const quint32*>(src);
+    quint32 *dest32 = reinterpret_cast<quint32*>(dest);
+
+    {
+        quint32 x = src32[0];
+        quint32 y = dest32[0];
+
+        quint32 t;
+        t = ((x >> 8) & 0xff00ff) * (a >> 24)
+            + ((y >> 8) & 0xff00ff) * (ia >> 24);
+        t = (t + ((t >> 8) & 0xff00ff) + 0x800080);
+        t &= 0xff00ff00;
+
+        x = (x & 0xff0000) * (a >> 24)
+            + (x & 0x0000ff) * ((a >> 16) & 0xff)
+            + (y & 0xff0000) * (ia >> 24)
+            + (y & 0x0000ff) * ((ia >> 16) & 0xff);
+        x = (x + ((x >> 8) & 0xff00ff) + 0x800080) >> 8;
+        x &= 0x00ff00ff;
+
+        dest32[0] = x | t;
+    }
+    {
+        quint32 x = src32[1];
+        quint32 y = dest32[1];
+
+        quint32 t;
+        t = ((x >> 8) & 0xff0000) * ((a >> 16) & 0xff)
+            + ((x >> 8) & 0x0000ff) * ((a >> 8) & 0xff)
+            + ((y >> 8) & 0xff0000) * ((ia >> 16) & 0xff)
+            + ((y >> 8) & 0x0000ff) * ((ia >> 8) & 0xff);
+        t = (t + ((t >> 8) & 0xff00ff) + 0x800080);
+        t &= 0xff00ff00;
+
+        x = (x & 0xff0000) * ((a >> 16) & 0xff)
+            + (x & 0x0000ff) * ((a >> 8) & 0xff)
+            + (y & 0xff0000) * ((ia >> 16) & 0xff)
+            + (y & 0x0000ff) * ((ia >> 8) & 0xff);
+        x = (x + ((x >> 8) & 0xff00ff) + 0x800080) >> 8;
+        x &= 0x00ff00ff;
+
+        dest32[1] = x | t;
+    }
+    {
+        quint32 x = src32[2];
+        quint32 y = dest32[2];
+
+        quint32 t;
+        t = ((x >> 8) & 0xff0000) * ((a >> 8) & 0xff)
+            + ((x >> 8) & 0x0000ff) * (a & 0xff)
+            + ((y >> 8) & 0xff0000) * ((ia >> 8) & 0xff)
+            + ((y >> 8) & 0x0000ff) * (ia & 0xff);
+        t = (t + ((t >> 8) & 0xff00ff) + 0x800080);
+        t &= 0xff00ff00;
+
+        x = (x & 0xff00ff) * (a & 0xff)
+            + (y & 0xff00ff) * (ia & 0xff);
+        x = (x + ((x >> 8) & 0xff00ff) + 0x800080) >> 8;
+        x &= 0x00ff00ff;
+
+        dest32[2] = x | t;
+    }
+}
+
+template <class DST, class SRC>
+inline void interpolate_pixel_4(DST *dest, quint8 a,
+                                const SRC *src, quint8 b)
+{
+    Q_ASSERT((long(dest) & 0x3) == 0);
+    Q_ASSERT((long(src) & 0x3) == 0);
+
+    dest[0] = dest[0].byte_mul(a) + DST(src[0]).byte_mul(b);
+    dest[1] = dest[1].byte_mul(a) + DST(src[1]).byte_mul(b);
+    dest[2] = dest[2].byte_mul(a) + DST(src[2]).byte_mul(b);
+    dest[3] = dest[3].byte_mul(a) + DST(src[3]).byte_mul(b);
+}
+
+template <class DST, class SRC>
+inline void blend_sourceOver_4(DST *dest, const SRC *src)
+{
+    Q_ASSERT((long(dest) & 0x3) == 0);
+    Q_ASSERT((long(src) & 0x3) == 0);
+
+    const quint32 a = alpha_4(src);
+    if (a == 0xffffffff) {
+        qt_memconvert(dest, src, 4);
+    } else if (a > 0) {
+        quint32 buf[3]; // array of quint32 to get correct alignment
+        qt_memconvert((DST*)(void*)buf, src, 4);
+        madd_4(dest, eff_ialpha_4(a, dest), (DST*)(void*)buf);
+    }
+}
+
+template <>
+inline void blend_sourceOver_4(qargb8565 *dest, const qargb8565 *src)
+{
+    Q_ASSERT((long(dest) & 0x3) == 0);
+    Q_ASSERT((long(src) & 0x3) == 0);
+
+    const quint32 a = alpha_4(src);
+    if (a == 0xffffffff) {
+        qt_memconvert(dest, src, 4);
+    } else if (a > 0) {
+        madd_4(dest, eff_ialpha_4(a, dest), src);
+    }
+}
+
+template <>
+inline void blend_sourceOver_4(qargb8555 *dest, const qargb8555 *src)
+{
+    Q_ASSERT((long(dest) & 0x3) == 0);
+    Q_ASSERT((long(src) & 0x3) == 0);
+
+    const quint32 a = alpha_4(src);
+    if (a == 0xffffffff) {
+        qt_memconvert(dest, src, 4);
+    } else if (a > 0) {
+        madd_4(dest, eff_ialpha_4(a, dest), src);
+    }
+}
+
+template <>
+inline void blend_sourceOver_4(qargb6666 *dest, const qargb6666 *src)
+{
+    Q_ASSERT((long(dest) & 0x3) == 0);
+    Q_ASSERT((long(src) & 0x3) == 0);
+
+    const quint32 a = alpha_4(src);
+    if (a == 0xffffffff) {
+        qt_memconvert(dest, src, 4);
+    } else if (a > 0) {
+        madd_4(dest, eff_ialpha_4(a, dest), src);
+    }
+}
+
+template <class DST, class SRC>
+void QT_FASTCALL blendUntransformed_unaligned(DST *dest, const SRC *src,
+                                              quint8 coverage, int length)
+{
+    Q_ASSERT(coverage > 0);
+
+    if (coverage < 255) {
+        if (SRC::hasAlpha()) {
+            for (int i = 0; i < length; ++i) {
+                if (src[i].alpha()) {
+                    const quint8 alpha = qt_div_255(int(src[i].alpha()) * int(coverage));
+                    interpolate_pixel(dest[i], DST::ialpha(alpha),
+                            src[i], DST::alpha(alpha));
+                }
+            }
+        } else {
+            const quint8 alpha = DST::alpha(coverage);
+            const quint8 ialpha = DST::ialpha(coverage);
+            if (alpha) {
+                for (int i = 0; i < length; ++i)
+                    interpolate_pixel(dest[i], ialpha, src[i], alpha);
+            }
+        }
+        return;
+    }
+
+    Q_ASSERT(coverage == 0xff);
+    Q_ASSERT(SRC::hasAlpha());
+
+    if (SRC::hasAlpha()) {
+        for (int i = 0; i < length; ++i) {
+            const quint8 a = src->alpha();
+            if (a == 0xff)
+                *dest = DST(*src);
+            else if (a > 0) {
+                if (DST::hasAlpha())
+                    *dest = DST(*src).truncedAlpha() + dest->byte_mul(DST::ialpha(a));
+                else
+                    *dest = DST(SRC(*src).truncedAlpha()) + dest->byte_mul(DST::ialpha(a));
+            }
+            ++src;
+            ++dest;
+        }
+    }
+}
+
+template <class DST, class SRC>
+void QT_FASTCALL blendUntransformed_dest16(DST *dest, const SRC *src,
+                                           quint8 coverage, int length)
+{
+    Q_ASSERT(sizeof(DST) == 2);
+    Q_ASSERT(sizeof(SRC) == 2);
+    Q_ASSERT((long(dest) & 0x3) == (long(src) & 0x3));
+    Q_ASSERT(coverage > 0);
+
+    const int align = quintptr(dest) & 0x3;
+
+    if (coverage < 255) {
+        // align
+        if (align) {
+            const quint8 alpha = SRC::hasAlpha()
+                                 ? qt_div_255(int(src->alpha()) * int(coverage))
+                                 : coverage;
+            if (alpha) {
+                interpolate_pixel(*dest, DST::ialpha(alpha),
+                                  *src, DST::alpha(alpha));
+            }
+            ++dest;
+            ++src;
+            --length;
+        }
+
+        if (SRC::hasAlpha()) {
+            while (length >= 2) {
+                const quint16 alpha16 = BYTE_MUL(uint(alpha_2(src)), uint(coverage));
+                interpolate_pixel_2(dest, src, alpha16);
+                length -= 2;
+                src += 2;
+                dest += 2;
+            }
+        } else {
+            const quint8 alpha = DST::alpha(coverage);
+            const quint8 ialpha = DST::ialpha(coverage);
+
+            while (length >= 2) {
+                interpolate_pixel_2(dest, ialpha, src, alpha);
+                length -= 2;
+                src += 2;
+                dest += 2;
+            }
+        }
+
+        // tail
+        if (length) {
+            const quint8 alpha = SRC::hasAlpha()
+                                 ? qt_div_255(int(src->alpha()) * int(coverage))
+                                 : coverage;
+            if (alpha) {
+                interpolate_pixel(*dest, DST::ialpha(alpha),
+                                  *src, DST::alpha(alpha));
+            }
+        }
+
+        return;
+    }
+
+    Q_ASSERT(SRC::hasAlpha());
+    if (SRC::hasAlpha()) {
+        if (align) {
+            const quint8 alpha = src->alpha();
+            if (alpha == 0xff)
+                *dest = DST(*src);
+            else if (alpha > 0)
+                *dest = DST(*src).truncedAlpha() + dest->byte_mul(DST::ialpha(alpha));
+            ++dest;
+            ++src;
+            --length;
+        }
+
+        while (length >= 2) {
+            Q_ASSERT((long(dest) & 3) == 0);
+            Q_ASSERT((long(src) & 3) == 0);
+
+            const quint16 a = alpha_2(src);
+            if (a == 0xffff) {
+                qt_memconvert(dest, src, 2);
+            } else if (a > 0) {
+                quint32 buf;
+                if (sizeof(DST) == 2)
+                    qt_memconvert((DST*)(void*)&buf, src, 2);
+                madd_2(dest, eff_ialpha_2(a, dest), (DST*)(void*)&buf);
+            }
+
+            length -= 2;
+            src += 2;
+            dest += 2;
+        }
+
+        if (length) {
+            const quint8 alpha = src->alpha();
+            if (alpha == 0xff)
+                *dest = DST(*src);
+            else if (alpha > 0)
+                *dest = DST(*src).truncedAlpha() + dest->byte_mul(DST::ialpha(alpha));
+        }
+    }
+}
+
+template <class DST, class SRC>
+void QT_FASTCALL blendUntransformed_dest24(DST *dest, const SRC *src,
+                                           quint8 coverage, int length)
+{
+    Q_ASSERT((long(dest) & 0x3) == (long(src) & 0x3));
+    Q_ASSERT(sizeof(DST) == 3);
+    Q_ASSERT(coverage > 0);
+
+    const int align = quintptr(dest) & 0x3;
+
+    if (coverage < 255) {
+        // align
+        for (int i = 0; i < align; ++i) {
+            if (SRC::hasAlpha()) {
+                const quint8 alpha = qt_div_255(int(src->alpha()) * int(coverage));
+                if (alpha)
+                    interpolate_pixel(*dest, DST::ialpha(alpha),
+                                      *src, DST::alpha(alpha));
+            } else {
+                interpolate_pixel(*dest, DST::ialpha(coverage),
+                                  *src, DST::alpha(coverage));
+            }
+            ++dest;
+            ++src;
+            --length;
+        }
+
+        if (SRC::hasAlpha()) {
+            while (length >= 4) {
+                const quint32 alpha = BYTE_MUL(uint(alpha_4(src)), uint(coverage));
+                if (alpha)
+                    interpolate_pixel_4(dest, src, alpha);
+                length -= 4;
+                src += 4;
+                dest += 4;
+            }
+        } else {
+            const quint8 alpha = DST::alpha(coverage);
+            const quint8 ialpha = DST::ialpha(coverage);
+            while (length >= 4) {
+                interpolate_pixel_4(dest, ialpha, src, alpha);
+                length -= 4;
+                src += 4;
+                dest += 4;
+            }
+        }
+
+        // tail
+        while (length--) {
+            if (SRC::hasAlpha()) {
+                const quint8 alpha = qt_div_255(int(src->alpha()) * int(coverage));
+                if (alpha)
+                    interpolate_pixel(*dest, DST::ialpha(alpha),
+                                      *src, DST::alpha(alpha));
+            } else {
+                interpolate_pixel(*dest, DST::ialpha(coverage),
+                                  *src, DST::alpha(coverage));
+            }
+            ++dest;
+            ++src;
+        }
+
+        return;
+    }
+
+
+    Q_ASSERT(coverage == 255);
+    Q_ASSERT(SRC::hasAlpha());
+
+    if (SRC::hasAlpha()) {
+        // align
+        for (int i = 0; i < align; ++i) {
+            const quint8 a = src->alpha();
+            if (a == 0xff) {
+                *dest = DST(*src);
+            } else if (a > 0) {
+                *dest = DST(*src).truncedAlpha() + dest->byte_mul(DST::ialpha(a));
+            }
+            ++dest;
+            ++src;
+            --length;
+        }
+
+        while (length >= 4) {
+            blend_sourceOver_4(dest, src);
+            length -= 4;
+            src += 4;
+            dest += 4;
+        }
+
+        // tail
+        while (length--) {
+            const quint8 a = src->alpha();
+            if (a == 0xff) {
+                *dest = DST(*src);
+            } else if (a > 0) {
+                *dest = DST(*src).truncedAlpha() + dest->byte_mul(DST::ialpha(a));
+            }
+            ++dest;
+            ++src;
+        }
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_SPECIALIZATION
+void QT_FASTCALL blendUntransformed(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+
+    if (mode != QPainter::CompositionMode_SourceOver &&
+        mode != QPainter::CompositionMode_Source)
+    {
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+        return;
+    }
+
+    const bool modeSource = !SRC::hasAlpha() ||
+                            mode == QPainter::CompositionMode_Source;
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx);
+    int yoff = -qRound(-data->dy);
+
+    while (count--) {
+        const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+        if (coverage == 0) {
+            ++spans;
+            continue;
+        }
+
+        int x = spans->x;
+        int length = spans->len;
+        int sx = xoff + x;
+        int sy = yoff + spans->y;
+        if (sy >= 0 && sy < image_height && sx < image_width) {
+            if (sx < 0) {
+                x -= sx;
+                length += sx;
+                sx = 0;
+            }
+            if (sx + length > image_width)
+                length = image_width - sx;
+            if (length > 0) {
+                DST *dest = ((DST*)data->rasterBuffer->scanLine(spans->y)) + x;
+                const SRC *src = (SRC*)data->texture.scanLine(sy) + sx;
+                if (modeSource && coverage == 255) {
+                    qt_memconvert<DST, SRC>(dest, src, length);
+                } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && length >= 3 &&
+                           (quintptr(dest) & 3) == (quintptr(src) & 3))
+                {
+                    blendUntransformed_dest24(dest, src, coverage, length);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && length >= 3 &&
+                           (quintptr(dest) & 3) == (quintptr(src) & 3))
+                {
+                    blendUntransformed_dest16(dest, src, coverage, length);
+                } else {
+                    blendUntransformed_unaligned(dest, src, coverage, length);
+                }
+            }
+        }
+        ++spans;
+    }
+}
+
+static void blend_untransformed_rgb888(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_24)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB888)
+        blendUntransformed<qrgb888, qrgb888>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData
+                                                  Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_untransformed_argb6666(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendUntransformed<qargb6666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendUntransformed<qargb6666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData
+                                                  Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_untransformed_rgb666(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendUntransformed<qrgb666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendUntransformed<qrgb666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData
+                                                  Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_untransformed_argb8565(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendUntransformed<qargb8565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendUntransformed<qargb8565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData
+                                                  Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_untransformed_rgb565(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendUntransformed<qrgb565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendUntransformed<qrgb565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData
+                                                  Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_untransformed_argb8555(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendUntransformed<qargb8555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendUntransformed<qargb8555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData
+                                                  Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_untransformed_rgb555(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendUntransformed<qrgb555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendUntransformed<qrgb555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData
+                                                  Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_untransformed_argb4444(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendUntransformed<qargb4444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendUntransformed<qargb4444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData
+                                                  Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_untransformed_rgb444(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendUntransformed<qrgb444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendUntransformed<qrgb444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_untransformed_generic<RegularSpans>(count, spans, userData
+                                                  Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_tiled_generic(int count, const QSpan *spans, void *userData
+                                Q_TEMPLATE_ENUM_FIX(SpanMethod, spanMethod))
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    uint buffer[buffer_size];
+    uint src_buffer[buffer_size];
+    Operator op = getOperator(data, spans, count);
+
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx) % image_width;
+    int yoff = -qRound(-data->dy) % image_height;
+
+    if (xoff < 0)
+        xoff += image_width;
+    if (yoff < 0)
+        yoff += image_height;
+
+    while (count--) {
+        int x = spans->x;
+        int length = spans->len;
+        int sx = (xoff + spans->x) % image_width;
+        int sy = (spans->y + yoff) % image_height;
+        if (sx < 0)
+            sx += image_width;
+        if (sy < 0)
+            sy += image_height;
+
+        const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+        while (length) {
+            int l = qMin(image_width - sx, length);
+            if (buffer_size < l)
+                l = buffer_size;
+            const uint *src = op.src_fetch(src_buffer, &op, data, sy, sx, l);
+            if (spanMethod == RegularSpans) {
+                uint *dest = op.dest_fetch ? op.dest_fetch(buffer, data->rasterBuffer, x, spans->y, l) : buffer;
+                op.func(dest, src, l, coverage);
+                if (op.dest_store)
+                    op.dest_store(data->rasterBuffer, x, spans->y, dest, l);
+            } else {
+                drawBufferSpan(data, src, l, x, spans->y, l,
+                               coverage);
+            }
+            x += l;
+            sx += l;
+            length -= l;
+            if (sx >= image_width)
+                sx = 0;
+        }
+        ++spans;
+    }
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_tiled_argb(int count, const QSpan *spans, void *userData
+                             Q_TEMPLATE_ENUM_FIX(SpanMethod, spanMethod))
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    if (data->texture.format != QImage::Format_ARGB32_Premultiplied
+        && data->texture.format != QImage::Format_RGB32) {
+        blend_tiled_generic<spanMethod>(count, spans, userData Q_TEMPLATE_ENUM_CALL(SpanMethod, spanMethod));
+        return;
+    }
+
+    Operator op = getOperator(data, spans, count);
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx) % image_width;
+    int yoff = -qRound(-data->dy) % image_height;
+
+    if (xoff < 0)
+        xoff += image_width;
+    if (yoff < 0)
+        yoff += image_height;
+
+    while (count--) {
+        int x = spans->x;
+        int length = spans->len;
+        int sx = (xoff + spans->x) % image_width;
+        int sy = (spans->y + yoff) % image_height;
+        if (sx < 0)
+            sx += image_width;
+        if (sy < 0)
+            sy += image_height;
+
+        const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+        while (length) {
+            int l = qMin(image_width - sx, length);
+            if (buffer_size < l)
+                l = buffer_size;
+            const uint *src = (uint *)data->texture.scanLine(sy) + sx;
+            if (spanMethod == RegularSpans) {
+                uint *dest = ((uint *)data->rasterBuffer->scanLine(spans->y)) + x;
+                op.func(dest, src, l, coverage);
+            } else {
+                drawBufferSpan(data, src, buffer_size,
+                               x, spans->y, l, coverage);
+            }
+            x += l;
+            length -= l;
+            sx = 0;
+        }
+        ++spans;
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION void blendTiled(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+
+    if (mode != QPainter::CompositionMode_SourceOver &&
+        mode != QPainter::CompositionMode_Source)
+    {
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+        return;
+    }
+
+    const bool modeSource = !SRC::hasAlpha() ||
+                            mode == QPainter::CompositionMode_Source;
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+    int xoff = -qRound(-data->dx) % image_width;
+    int yoff = -qRound(-data->dy) % image_height;
+
+    if (xoff < 0)
+        xoff += image_width;
+    if (yoff < 0)
+        yoff += image_height;
+
+    while (count--) {
+        const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+        if (coverage == 0) {
+            ++spans;
+            continue;
+        }
+
+        int x = spans->x;
+        int length = spans->len;
+        int sx = (xoff + spans->x) % image_width;
+        int sy = (spans->y + yoff) % image_height;
+        if (sx < 0)
+            sx += image_width;
+        if (sy < 0)
+            sy += image_height;
+
+        while (length) {
+            int l = qMin(image_width - sx, length);
+            if (buffer_size < l)
+                l = buffer_size;
+
+            DST *dest = ((DST*)data->rasterBuffer->scanLine(spans->y)) + x;
+            const SRC *src = (SRC*)data->texture.scanLine(sy) + sx;
+            if (modeSource && coverage == 255) {
+                qt_memconvert<DST, SRC>(dest, src, l);
+            } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
+                       (quintptr(dest) & 3) == (quintptr(src) & 3))
+            {
+                blendUntransformed_dest24(dest, src, coverage, l);
+            } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                       (quintptr(dest) & 3) == (quintptr(src) & 3))
+            {
+                blendUntransformed_dest16(dest, src, coverage, l);
+            } else {
+                blendUntransformed_unaligned(dest, src, coverage, l);
+            }
+
+            x += l;
+            length -= l;
+            sx = 0;
+        }
+        ++spans;
+    }
+}
+
+static void blend_tiled_rgb888(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_24)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB888)
+        blendTiled<qrgb888, qrgb888>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData
+                                          Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_tiled_argb6666(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTiled<qargb6666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTiled<qargb6666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData
+                                          Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_tiled_rgb666(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTiled<qrgb666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTiled<qrgb666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData
+                                          Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_tiled_argb8565(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTiled<qargb8565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTiled<qargb8565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData
+                                          Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_tiled_rgb565(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTiled<qrgb565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTiled<qrgb565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData
+                                          Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_tiled_argb8555(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTiled<qargb8555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTiled<qargb8555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData
+                                          Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_tiled_rgb555(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTiled<qrgb555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTiled<qrgb555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData
+                                          Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_tiled_argb4444(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTiled<qargb4444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTiled<qargb4444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData
+                                          Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_tiled_rgb444(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTiled<qrgb444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTiled<qrgb444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_tiled_generic<RegularSpans>(count, spans, userData
+                                          Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_argb(int count, const QSpan *spans, void *userData
+                                            Q_TEMPLATE_ENUM_FIX(SpanMethod, spanMethod))
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    if (data->texture.format != QImage::Format_ARGB32_Premultiplied
+        && data->texture.format != QImage::Format_RGB32) {
+        blend_src_generic<spanMethod>(count, spans, userData Q_TEMPLATE_ENUM_CALL(SpanMethod, spanMethod));
+        return;
+    }
+
+    CompositionFunction func = functionForMode[data->rasterBuffer->compositionMode];
+    uint buffer[buffer_size];
+
+    int image_x1 = data->texture.x1;
+    int image_y1 = data->texture.y1;
+    int image_x2 = data->texture.x2;
+    int image_y2 = data->texture.y2;
+    const int scanline_offset = data->texture.bytesPerLine / 4;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + 0.5;
+            const qreal cy = spans->y + 0.5;
+
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale) - half_point;
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale) - half_point;
+
+            int length = spans->len;
+            const int coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    int x1 = (x >> 16);
+                    int x2 = x1 + 1;
+                    int y1 = (y >> 16);
+                    int y2 = y1 + 1;
+
+                    int distx = ((x - (x1 << 16)) >> 8);
+                    int disty = ((y - (y1 << 16)) >> 8);
+                    int idistx = 256 - distx;
+                    int idisty = 256 - disty;
+
+                    x1 = qBound(image_x1, x1, image_x2 - 1);
+                    x2 = qBound(image_x1, x2, image_x2 - 1);
+                    y1 = qBound(image_y1, y1, image_y2 - 1);
+                    y2 = qBound(image_y1, y2, image_y2 - 1);
+
+                    int y1_offset = y1 * scanline_offset;
+                    int y2_offset = y2 * scanline_offset;
+
+#if defined(Q_IRIX_GCC3_3_WORKAROUND)
+                    uint tl = gccBug(image_bits[y1_offset + x1]);
+                    uint tr = gccBug(image_bits[y1_offset + x2]);
+                    uint bl = gccBug(image_bits[y2_offset + x1]);
+                    uint br = gccBug(image_bits[y2_offset + x2]);
+#else
+                    uint tl = image_bits[y1_offset + x1];
+                    uint tr = image_bits[y1_offset + x2];
+                    uint bl = image_bits[y2_offset + x1];
+                    uint br = image_bits[y2_offset + x2];
+#endif
+
+                    uint xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+                    uint xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+                    *b = INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + 0.5;
+            const qreal cy = spans->y + 0.5;
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            int length = spans->len;
+            const int coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal px = x * iw - 0.5;
+                    const qreal py = y * iw - 0.5;
+
+                    int x1 = int(px) - (px < 0);
+                    int x2 = x1 + 1;
+                    int y1 = int(py) - (py < 0);
+                    int y2 = y1 + 1;
+
+                    int distx = int((px - x1) * 256);
+                    int disty = int((py - y1) * 256);
+                    int idistx = 256 - distx;
+                    int idisty = 256 - disty;
+
+                    x1 = qBound(image_x1, x1, image_x2 - 1);
+                    x2 = qBound(image_x1, x2, image_x2 - 1);
+                    y1 = qBound(image_y1, y1, image_y2 - 1);
+                    y2 = qBound(image_y1, y2, image_y2 - 1);
+
+                    int y1_offset = y1 * scanline_offset;
+                    int y2_offset = y2 * scanline_offset;
+
+#if defined(Q_IRIX_GCC3_3_WORKAROUND)
+                    uint tl = gccBug(image_bits[y1_offset + x1]);
+                    uint tr = gccBug(image_bits[y1_offset + x2]);
+                    uint bl = gccBug(image_bits[y2_offset + x1]);
+                    uint br = gccBug(image_bits[y2_offset + x2]);
+#else
+                    uint tl = image_bits[y1_offset + x1];
+                    uint tr = image_bits[y1_offset + x2];
+                    uint bl = image_bits[y2_offset + x1];
+                    uint br = image_bits[y2_offset + x2];
+#endif
+
+                    uint xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+                    uint xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+                    *b = INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION void blendTransformedBilinear(int count, const QSpan *spans,
+                                     void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+
+
+    if (mode != QPainter::CompositionMode_SourceOver) {
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+        return;
+    }
+
+    SRC buffer[buffer_size];
+
+    const int src_minx = data->texture.x1;
+    const int src_miny = data->texture.y1;
+    const int src_maxx = data->texture.x2 - 1;
+    const int src_maxy = data->texture.y2 - 1;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        const int fdx = (int)(data->m11 * fixed_scale);
+        const int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale) - half_point;
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale) - half_point;
+            int length = spans->len;
+
+            while (length) {
+                const int l = qMin(length, buffer_size);
+
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    int x1 = (x >> 16);
+                    int x2 = x1 + 1;
+                    int y1 = (y >> 16);
+                    int y2 = y1 + 1;
+
+                    const int distx = ((x - (x1 << 16)) >> 8);
+                    const int disty = ((y - (y1 << 16)) >> 8);
+                    x1 = qBound(src_minx, x1, src_maxx);
+                    x2 = qBound(src_minx, x2, src_maxx);
+                    y1 = qBound(src_miny, y1, src_maxy);
+                    y2 = qBound(src_miny, y2, src_maxy);
+
+#if 0
+                    if (x1 == x2) {
+                        if (y1 == y2) {
+                            *b = ((SRC*)data->texture.scanLine(y1))[x1];
+                        } else {
+                            *b = ((SRC*)data->texture.scanLine(y1))[x1];
+                            const SRC t = data->texture.scanLine(y2)[x1];
+                            interpolate_pixel(*b, SRC::ialpha(disty),
+                                              t, SRC::alpha(disty));
+                        }
+                    } else if (y1 == y2) {
+                        *b = ((SRC*)data->texture.scanLine(y1))[x1];
+                        const SRC t = ((SRC*)data->texture.scanLine(y1))[x2];
+                        interpolate_pixel(*b, SRC::ialpha(distx),
+                                          t, SRC::alpha(distx));
+                    } else
+#endif
+                    {
+                        const SRC *src1 = (SRC*)data->texture.scanLine(y1);
+                        const SRC *src2 = (SRC*)data->texture.scanLine(y2);
+                        SRC tl = src1[x1];
+                        const SRC tr = src1[x2];
+                        SRC bl = src2[x1];
+                        const SRC br = src2[x2];
+                        const quint8 ax = SRC::alpha(distx);
+                        const quint8 iax = SRC::ialpha(distx);
+
+                        interpolate_pixel(tl, iax, tr, ax);
+                        interpolate_pixel(bl, iax, br, ax);
+                        interpolate_pixel(tl, SRC::ialpha(disty),
+                                          bl, SRC::alpha(disty));
+                        *b = tl;
+                    }
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                }
+
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            int length = spans->len;
+            while (length) {
+                const int l = qMin(length, buffer_size);
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal px = x * iw - qreal(0.5);
+                    const qreal py = y * iw - qreal(0.5);
+
+                    int x1 = int(px) - (px < 0);
+                    int x2 = x1 + 1;
+                    int y1 = int(py) - (py < 0);
+                    int y2 = y1 + 1;
+
+                    const int distx = int((px - x1) * 256);
+                    const int disty = int((py - y1) * 256);
+
+                    x1 = qBound(src_minx, x1, src_maxx);
+                    x2 = qBound(src_minx, x2, src_maxx);
+                    y1 = qBound(src_miny, y1, src_maxy);
+                    y2 = qBound(src_miny, y2, src_maxy);
+
+                    const SRC *src1 = (SRC*)data->texture.scanLine(y1);
+                    const SRC *src2 = (SRC*)data->texture.scanLine(y2);
+                    SRC tl = src1[x1];
+                    const SRC tr = src1[x2];
+                    SRC bl = src2[x1];
+                    const SRC br = src2[x2];
+                    const quint8 ax = SRC::alpha(distx);
+                    const quint8 iax = SRC::ialpha(distx);
+
+                    interpolate_pixel(tl, iax, tr, ax);
+                    interpolate_pixel(bl, iax, br, ax);
+                    interpolate_pixel(tl, SRC::ialpha(disty),
+                                      bl, SRC::alpha(disty));
+                    *b = tl;
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+                }
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+static void blend_transformed_bilinear_rgb888(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_24)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB888)
+        blendTransformedBilinear<qrgb888, qrgb888>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_bilinear_argb6666(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformedBilinear<qargb6666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformedBilinear<qargb6666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_bilinear_rgb666(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformedBilinear<qrgb666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformedBilinear<qrgb666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_bilinear_argb8565(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformedBilinear<qargb8565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTransformedBilinear<qargb8565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_bilinear_rgb565(int count, const QSpan *spans,
+                                              void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB16)
+        blendTransformedBilinear<qrgb565, qrgb565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformedBilinear<qrgb565, qargb8565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_bilinear_argb8555(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformedBilinear<qargb8555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformedBilinear<qargb8555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_bilinear_rgb555(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformedBilinear<qrgb555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformedBilinear<qrgb555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_bilinear_argb4444(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformedBilinear<qargb4444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformedBilinear<qargb4444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_bilinear_rgb444(int count, const QSpan *spans, void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformedBilinear<qrgb444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformedBilinear<qrgb444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_bilinear_tiled_argb(int count, const QSpan *spans, void *userData
+                                                  Q_TEMPLATE_ENUM_FIX(SpanMethod, spanMethod))
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    if (data->texture.format != QImage::Format_ARGB32_Premultiplied
+        && data->texture.format != QImage::Format_RGB32) {
+        blend_src_generic<spanMethod>(count, spans, userData Q_TEMPLATE_ENUM_CALL(SpanMethod, spanMethod));
+        return;
+    }
+
+    CompositionFunction func = functionForMode[data->rasterBuffer->compositionMode];
+    uint buffer[buffer_size];
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+    const int scanline_offset = data->texture.bytesPerLine / 4;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + 0.5;
+            const qreal cy = spans->y + 0.5;
+
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale) - half_point;
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale) - half_point;
+
+            int length = spans->len;
+            const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    int x1 = (x >> 16);
+                    int x2 = (x1 + 1);
+                    int y1 = (y >> 16);
+                    int y2 = (y1 + 1);
+
+                    int distx = ((x - (x1 << 16)) >> 8);
+                    int disty = ((y - (y1 << 16)) >> 8);
+                    int idistx = 256 - distx;
+                    int idisty = 256 - disty;
+
+                    x1 %= image_width;
+                    x2 %= image_width;
+                    y1 %= image_height;
+                    y2 %= image_height;
+
+                    if (x1 < 0) x1 += image_width;
+                    if (x2 < 0) x2 += image_width;
+                    if (y1 < 0) y1 += image_height;
+                    if (y2 < 0) y2 += image_height;
+
+                    Q_ASSERT(x1 >= 0 && x1 < image_width);
+                    Q_ASSERT(x2 >= 0 && x2 < image_width);
+                    Q_ASSERT(y1 >= 0 && y1 < image_height);
+                    Q_ASSERT(y2 >= 0 && y2 < image_height);
+
+                    int y1_offset = y1 * scanline_offset;
+                    int y2_offset = y2 * scanline_offset;
+
+#if defined(Q_IRIX_GCC3_3_WORKAROUND)
+                    uint tl = gccBug(image_bits[y1_offset + x1]);
+                    uint tr = gccBug(image_bits[y1_offset + x2]);
+                    uint bl = gccBug(image_bits[y2_offset + x1]);
+                    uint br = gccBug(image_bits[y2_offset + x2]);
+#else
+                    uint tl = image_bits[y1_offset + x1];
+                    uint tr = image_bits[y1_offset + x2];
+                    uint bl = image_bits[y2_offset + x1];
+                    uint br = image_bits[y2_offset + x2];
+#endif
+
+                    uint xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+                    uint xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+                    *b = INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+                    ++b;
+                    x += fdx;
+                    y += fdy;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + 0.5;
+            const qreal cy = spans->y + 0.5;
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            int length = spans->len;
+            const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal px = x * iw - 0.5;
+                    const qreal py = y * iw - 0.5;
+
+                    int x1 = int(px) - (px < 0);
+                    int x2 = x1 + 1;
+                    int y1 = int(py) - (py < 0);
+                    int y2 = y1 + 1;
+
+                    int distx = int((px - x1) * 256);
+                    int disty = int((py - y1) * 256);
+                    int idistx = 256 - distx;
+                    int idisty = 256 - disty;
+
+                    x1 %= image_width;
+                    x2 %= image_width;
+                    y1 %= image_height;
+                    y2 %= image_height;
+
+                    if (x1 < 0) x1 += image_width;
+                    if (x2 < 0) x2 += image_width;
+                    if (y1 < 0) y1 += image_height;
+                    if (y2 < 0) y2 += image_height;
+
+                    Q_ASSERT(x1 >= 0 && x1 < image_width);
+                    Q_ASSERT(x2 >= 0 && x2 < image_width);
+                    Q_ASSERT(y1 >= 0 && y1 < image_height);
+                    Q_ASSERT(y2 >= 0 && y2 < image_height);
+
+                    int y1_offset = y1 * scanline_offset;
+                    int y2_offset = y2 * scanline_offset;
+
+#if defined(Q_IRIX_GCC3_3_WORKAROUND)
+                    uint tl = gccBug(image_bits[y1_offset + x1]);
+                    uint tr = gccBug(image_bits[y1_offset + x2]);
+                    uint bl = gccBug(image_bits[y2_offset + x1]);
+                    uint br = gccBug(image_bits[y2_offset + x2]);
+#else
+                    uint tl = image_bits[y1_offset + x1];
+                    uint tr = image_bits[y1_offset + x2];
+                    uint bl = image_bits[y2_offset + x1];
+                    uint br = image_bits[y2_offset + x2];
+#endif
+
+                    uint xtop = INTERPOLATE_PIXEL_256(tl, idistx, tr, distx);
+                    uint xbot = INTERPOLATE_PIXEL_256(bl, idistx, br, distx);
+                    *b = INTERPOLATE_PIXEL_256(xtop, idisty, xbot, disty);
+                    ++b;
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_argb(int count, const QSpan *spans, void *userData
+                                   Q_TEMPLATE_ENUM_FIX(SpanMethod, spanMethod))
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    if (data->texture.format != QImage::Format_ARGB32_Premultiplied
+        && data->texture.format != QImage::Format_RGB32) {
+        blend_src_generic<spanMethod>(count, spans, userData Q_TEMPLATE_ENUM_CALL(SpanMethod, spanMethod));
+        return;
+    }
+
+    CompositionFunction func = functionForMode[data->rasterBuffer->compositionMode];
+    uint buffer[buffer_size];
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+    const int scanline_offset = data->texture.bytesPerLine / 4;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + 0.5;
+            const qreal cy = spans->y + 0.5;
+
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale);
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale);
+
+            int length = spans->len;
+            const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    int px = x >> 16;
+                    int py = y >> 16;
+
+                    bool out = (px < 0) || (px >= image_width)
+                               || (py < 0) || (py >= image_height);
+
+                    int y_offset = py * scanline_offset;
+                    *b = out ? uint(0) : image_bits[y_offset + px];
+                    x += fdx;
+                    y += fdy;
+                    ++b;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + 0.5;
+            const qreal cy = spans->y + 0.5;
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            int length = spans->len;
+            const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal tx = x * iw;
+                    const qreal ty = y * iw;
+                    const int px = int(tx) - (tx < 0);
+                    const int py = int(ty) - (ty < 0);
+
+                    bool out = (px < 0) || (px >= image_width)
+                               || (py < 0) || (py >= image_height);
+
+                    int y_offset = py * scanline_offset;
+                    *b = out ? uint(0) : image_bits[y_offset + px];
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+
+                    ++b;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION void blendTransformed(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+
+    if (mode != QPainter::CompositionMode_SourceOver) {
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+        return;
+    }
+
+    SRC buffer[buffer_size];
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        const int fdx = (int)(data->m11 * fixed_scale);
+        const int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale);
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale);
+            int length = spans->len;
+
+            while (length) {
+                const int l = qMin(length, buffer_size);
+
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    const int px = (x >> 16);
+                    const int py = (y >> 16);
+
+                    if ((px < 0) || (px >= image_width) ||
+                        (py < 0) || (py >= image_height))
+                    {
+                        *b = 0;
+                    } else {
+                        *b = ((SRC*)data->texture.scanLine(py))[px];
+                    }
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                }
+
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            int length = spans->len;
+            while (length) {
+                const int l = qMin(length, buffer_size);
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal tx = x * iw;
+                    const qreal ty = y * iw;
+
+                    const int px = int(tx) - (tx < 0);
+                    const int py = int(ty) - (ty < 0);
+
+                    if ((px < 0) || (px >= image_width) ||
+                        (py < 0) || (py >= image_height))
+                    {
+                        *b = 0;
+                    } else {
+                        *b = ((SRC*)data->texture.scanLine(py))[px];
+                    }
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+                }
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+static void blend_transformed_rgb888(int count, const QSpan *spans,
+                                     void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_24)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB888)
+        blendTransformed<qrgb888, qrgb888>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_argb6666(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformed<qargb6666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformed<qargb6666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_rgb666(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformed<qrgb666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformed<qrgb666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_argb8565(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformed<qargb8565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTransformed<qargb8565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_rgb565(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformed<qrgb565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTransformed<qrgb565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_argb8555(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformed<qargb8555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformed<qargb8555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_rgb555(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformed<qrgb555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformed<qrgb555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_argb4444(int count, const QSpan *spans,
+                                         void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformed<qargb4444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformed<qargb4444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_rgb444(int count, const QSpan *spans,
+                                       void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformed<qrgb444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformed<qrgb444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+template <SpanMethod spanMethod>
+Q_STATIC_TEMPLATE_FUNCTION void blend_transformed_tiled_argb(int count, const QSpan *spans, void *userData
+                                         Q_TEMPLATE_ENUM_FIX(SpanMethod, spanMethod))
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    if (data->texture.format != QImage::Format_ARGB32_Premultiplied
+        && data->texture.format != QImage::Format_RGB32) {
+        blend_src_generic<spanMethod>(count, spans, userData Q_TEMPLATE_ENUM_CALL(SpanMethod, spanMethod));
+        return;
+    }
+
+    CompositionFunction func = functionForMode[data->rasterBuffer->compositionMode];
+    uint buffer[buffer_size];
+
+    int image_width = data->texture.width;
+    int image_height = data->texture.height;
+    const int scanline_offset = data->texture.bytesPerLine / 4;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        int fdx = (int)(data->m11 * fixed_scale);
+        int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + 0.5;
+            const qreal cy = spans->y + 0.5;
+
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale);
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale);
+
+            const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+            int length = spans->len;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    int px = x >> 16;
+                    int py = y >> 16;
+                    px %= image_width;
+                    py %= image_height;
+                    if (px < 0) px += image_width;
+                    if (py < 0) py += image_height;
+                    int y_offset = py * scanline_offset;
+
+                    Q_ASSERT(px >= 0 && px < image_width);
+                    Q_ASSERT(py >= 0 && py < image_height);
+
+                    *b = image_bits[y_offset + px];
+                    x += fdx;
+                    y += fdy;
+                    ++b;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+        while (count--) {
+            void *t = data->rasterBuffer->scanLine(spans->y);
+
+            uint *target = ((uint *)t) + spans->x;
+            uint *image_bits = (uint *)data->texture.imageData;
+
+            const qreal cx = spans->x + 0.5;
+            const qreal cy = spans->y + 0.5;
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            const int coverage = (spans->coverage * data->texture.const_alpha) >> 8;
+            int length = spans->len;
+            while (length) {
+                int l = qMin(length, buffer_size);
+                const uint *end = buffer + l;
+                uint *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal tx = x * iw;
+                    const qreal ty = y * iw;
+                    int px = int(tx) - (tx < 0);
+                    int py = int(ty) - (ty < 0);
+
+                    px %= image_width;
+                    py %= image_height;
+                    if (px < 0) px += image_width;
+                    if (py < 0) py += image_height;
+                    int y_offset = py * scanline_offset;
+
+                    Q_ASSERT(px >= 0 && px < image_width);
+                    Q_ASSERT(py >= 0 && py < image_height);
+
+                    *b = image_bits[y_offset + px];
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+                    //force increment to avoid /0
+                    if (!w) {
+                        w += fdw;
+                    }
+                    ++b;
+                }
+                if (spanMethod == RegularSpans)
+                    func(target, buffer, l, coverage);
+                else
+                    drawBufferSpan(data, buffer, buffer_size,
+                                   spans->x + spans->len - length,
+                                   spans->y, l, coverage);
+                target += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+template <class DST, class SRC>
+Q_STATIC_TEMPLATE_FUNCTION void blendTransformedTiled(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData*>(userData);
+    QPainter::CompositionMode mode = data->rasterBuffer->compositionMode;
+
+    if (mode != QPainter::CompositionMode_SourceOver) {
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+        return;
+    }
+
+    SRC buffer[buffer_size];
+    const int image_width = data->texture.width;
+    const int image_height = data->texture.height;
+
+    if (data->fast_matrix) {
+        // The increment pr x in the scanline
+        const int fdx = (int)(data->m11 * fixed_scale);
+        const int fdy = (int)(data->m12 * fixed_scale);
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+            int x = int((data->m21 * cy
+                         + data->m11 * cx + data->dx) * fixed_scale);
+            int y = int((data->m22 * cy
+                         + data->m12 * cx + data->dy) * fixed_scale);
+            int length = spans->len;
+
+            while (length) {
+                const int l = qMin(length, buffer_size);
+
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    int px = (x >> 16) % image_width;
+                    int py = (y >> 16) % image_height;
+
+                    if (px < 0)
+                        px += image_width;
+                    if (py < 0)
+                        py += image_height;
+
+                    *b = ((SRC*)data->texture.scanLine(py))[px];
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                }
+
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    } else {
+        const qreal fdx = data->m11;
+        const qreal fdy = data->m12;
+        const qreal fdw = data->m13;
+
+        while (count--) {
+            const quint8 coverage = (data->texture.const_alpha * spans->coverage) >> 8;
+            if (coverage == 0) {
+                ++spans;
+                continue;
+            }
+
+            DST *dest = (DST*)data->rasterBuffer->scanLine(spans->y)
+                        + spans->x;
+
+            const qreal cx = spans->x + qreal(0.5);
+            const qreal cy = spans->y + qreal(0.5);
+
+            qreal x = data->m21 * cy + data->m11 * cx + data->dx;
+            qreal y = data->m22 * cy + data->m12 * cx + data->dy;
+            qreal w = data->m23 * cy + data->m13 * cx + data->m33;
+
+            int length = spans->len;
+            while (length) {
+                const int l = qMin(length, buffer_size);
+                const SRC *end = buffer + l;
+                SRC *b = buffer;
+                while (b < end) {
+                    const qreal iw = w == 0 ? 1 : 1 / w;
+                    const qreal tx = x * iw;
+                    const qreal ty = y * iw;
+
+                    int px = int(tx) - (tx < 0);
+                    int py = int(ty) - (ty < 0);
+
+                    if (px < 0)
+                        px += image_width;
+                    if (py < 0)
+                        py += image_height;
+
+                    *b = ((SRC*)data->texture.scanLine(py))[px];
+                    ++b;
+
+                    x += fdx;
+                    y += fdy;
+                    w += fdw;
+                    // force increment to avoid /0
+                    if (!w)
+                        w += fdw;
+                }
+                if (!SRC::hasAlpha() && coverage == 255) {
+                    qt_memconvert(dest, buffer, l);
+                } else if (sizeof(DST) == 3 && sizeof(SRC) == 3 && l >= 4 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3))
+                {
+                    blendUntransformed_dest24(dest, buffer, coverage, l);
+                } else if (sizeof(DST) == 2 && sizeof(SRC) == 2 && l >= 2 &&
+                           (quintptr(dest) & 3) == (quintptr(buffer) & 3)) {
+                    blendUntransformed_dest16(dest, buffer, coverage, l);
+                } else {
+                    blendUntransformed_unaligned(dest, buffer, coverage, l);
+                }
+
+                dest += l;
+                length -= l;
+            }
+            ++spans;
+        }
+    }
+}
+
+static void blend_transformed_tiled_rgb888(int count, const QSpan *spans,
+                                           void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_24)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_RGB888)
+        blendTransformedTiled<qrgb888, qrgb888>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_tiled_argb6666(int count, const QSpan *spans,
+                                             void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformedTiled<qargb6666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformedTiled<qargb6666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_tiled_rgb666(int count, const QSpan *spans,
+                                           void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_18)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB6666_Premultiplied)
+        blendTransformedTiled<qrgb666, qargb6666>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB666)
+        blendTransformedTiled<qrgb666, qrgb666>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_tiled_argb8565(int count, const QSpan *spans,
+                                             void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformedTiled<qargb8565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTransformedTiled<qargb8565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_tiled_rgb565(int count, const QSpan *spans,
+                                           void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_16)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8565_Premultiplied)
+        blendTransformedTiled<qrgb565, qargb8565>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB16)
+        blendTransformedTiled<qrgb565, qrgb565>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_tiled_argb8555(int count, const QSpan *spans,
+                                             void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformedTiled<qargb8555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformedTiled<qargb8555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_tiled_rgb555(int count, const QSpan *spans,
+                                           void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_15)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB8555_Premultiplied)
+        blendTransformedTiled<qrgb555, qargb8555>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB555)
+        blendTransformedTiled<qrgb555, qrgb555>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_tiled_argb4444(int count, const QSpan *spans,
+                                             void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformedTiled<qargb4444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformedTiled<qargb4444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+static void blend_transformed_tiled_rgb444(int count, const QSpan *spans,
+                                           void *userData)
+{
+#if !defined(Q_WS_QWS) || defined(QT_QWS_DEPTH_12)
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    if (data->texture.format == QImage::Format_ARGB4444_Premultiplied)
+        blendTransformedTiled<qrgb444, qargb4444>(count, spans, userData);
+    else if (data->texture.format == QImage::Format_RGB444)
+        blendTransformedTiled<qrgb444, qrgb444>(count, spans, userData);
+    else
+#endif
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+}
+
+#if defined(Q_CC_MSVC) && _MSC_VER <= 1300 && !defined(Q_CC_INTEL)
+
+// explicit template instantiations needed to compile with VC6 and VC2002
+
+#define SPANFUNC_INSTANTIATION(Name, Arg)  \
+static inline void Name##_##Arg(int count, const QSpan *spans, void *userData) \
+{ \
+    Name<Arg>(count, spans, userData Q_TEMPLATE_ENUM_CALL(SpanMethod, Arg)); \
+}
+
+SPANFUNC_INSTANTIATION(blend_untransformed_generic, RegularSpans);
+SPANFUNC_INSTANTIATION(blend_untransformed_argb, RegularSpans);
+SPANFUNC_INSTANTIATION(blend_tiled_generic, RegularSpans);
+SPANFUNC_INSTANTIATION(blend_tiled_argb, RegularSpans);
+SPANFUNC_INSTANTIATION(blend_src_generic, RegularSpans);
+SPANFUNC_INSTANTIATION(blend_transformed_argb, RegularSpans);
+SPANFUNC_INSTANTIATION(blend_transformed_tiled_argb, RegularSpans);
+SPANFUNC_INSTANTIATION(blend_transformed_bilinear_argb, RegularSpans);
+SPANFUNC_INSTANTIATION(blend_transformed_bilinear_tiled_argb, RegularSpans);
+#undef SPANFUNC_INSTANTIATION
+
+#define SPANFUNC_POINTER(Name, Arg) Name##_##Arg
+
+#else // !VC6 && !VC2002
+# define SPANFUNC_POINTER(Name, Arg) Name<Arg>
+#endif
+
+
+/* Image formats here are target formats */
+static const ProcessSpans processTextureSpans[NBlendTypes][QImage::NImageFormats] = {
+    // Untransformed
+    {
+        0, // Invalid
+        SPANFUNC_POINTER(blend_untransformed_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_untransformed_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_untransformed_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_untransformed_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_untransformed_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_untransformed_argb, RegularSpans), // ARGB32_Premultiplied
+        blend_untransformed_rgb565,
+        blend_untransformed_argb8565,
+        blend_untransformed_rgb666,
+        blend_untransformed_argb6666,
+        blend_untransformed_rgb555,
+        blend_untransformed_argb8555,
+        blend_untransformed_rgb888,
+        blend_untransformed_rgb444,
+        blend_untransformed_argb4444,
+    },
+    // Tiled
+    {
+        0, // Invalid
+        SPANFUNC_POINTER(blend_tiled_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_tiled_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_tiled_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_tiled_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_tiled_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_tiled_argb, RegularSpans), // ARGB32_Premultiplied
+        blend_tiled_rgb565,
+        blend_tiled_argb8565,
+        blend_tiled_rgb666,
+        blend_tiled_argb6666,
+        blend_tiled_rgb555,
+        blend_tiled_argb8555,
+        blend_tiled_rgb888,
+        blend_tiled_rgb444,
+        blend_tiled_argb4444,
+    },
+    // Transformed
+    {
+        0, // Invalid
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_transformed_argb, RegularSpans), // ARGB32_Premultiplied
+        blend_transformed_rgb565,
+        blend_transformed_argb8565,
+        blend_transformed_rgb666,
+        blend_transformed_argb6666,
+        blend_transformed_rgb555,
+        blend_transformed_argb8555,
+        blend_transformed_rgb888,
+        blend_transformed_rgb444,
+        blend_transformed_argb4444,
+    },
+     // TransformedTiled
+    {
+        0,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_transformed_tiled_argb, RegularSpans), // ARGB32_Premultiplied
+        blend_transformed_tiled_rgb565,
+        blend_transformed_tiled_argb8565,
+        blend_transformed_tiled_rgb666,
+        blend_transformed_tiled_argb6666,
+        blend_transformed_tiled_rgb555,
+        blend_transformed_tiled_argb8555,
+        blend_transformed_tiled_rgb888,
+        blend_transformed_tiled_rgb444,
+        blend_transformed_tiled_argb4444
+    },
+    // Bilinear
+    {
+        0,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_transformed_bilinear_argb, RegularSpans), // ARGB32_Premultiplied
+        blend_transformed_bilinear_rgb565,
+        blend_transformed_bilinear_argb8565,
+        blend_transformed_bilinear_rgb666,
+        blend_transformed_bilinear_argb6666,
+        blend_transformed_bilinear_rgb555,
+        blend_transformed_bilinear_argb8555,
+        blend_transformed_bilinear_rgb888,
+        blend_transformed_bilinear_rgb444,
+        blend_transformed_bilinear_argb4444,
+    },
+    // BilinearTiled
+    {
+        0,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Mono
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // MonoLsb
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // Indexed8
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB32
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB32
+        SPANFUNC_POINTER(blend_transformed_bilinear_tiled_argb, RegularSpans), // ARGB32_Premultiplied
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB16
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB8565_Premultiplied
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB666
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB6666_Premultiplied
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB555
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB8555_Premultiplied
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB888
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // RGB444
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans), // ARGB4444_Premultiplied
+    }
+};
+
+#if defined (Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+static const ProcessSpans processTextureSpansCallback[NBlendTypes][QImage::NImageFormats] = {
+    // Untransformed
+    {
+        0, // Invalid
+        blend_untransformed_generic<CallbackSpans>,   // Mono
+        blend_untransformed_generic<CallbackSpans>,   // MonoLsb
+        blend_untransformed_generic<CallbackSpans>,   // Indexed8
+        blend_untransformed_generic<CallbackSpans>,   // RGB32
+        blend_untransformed_generic<CallbackSpans>,   // ARGB32
+        blend_untransformed_argb<CallbackSpans>,      // ARGB32_Premultiplied
+        blend_untransformed_generic<CallbackSpans>,   // RGB16
+        blend_untransformed_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_untransformed_generic<CallbackSpans>,   // RGB666
+        blend_untransformed_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_untransformed_generic<CallbackSpans>,   // RGB555
+        blend_untransformed_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_untransformed_generic<CallbackSpans>,   // RGB888
+        blend_untransformed_generic<CallbackSpans>,   // RGB444
+        blend_untransformed_generic<CallbackSpans>    // ARGB4444_Premultiplied
+    },
+    // Tiled
+    {
+        0, // Invalid
+        blend_tiled_generic<CallbackSpans>,   // Mono
+        blend_tiled_generic<CallbackSpans>,   // MonoLsb
+        blend_tiled_generic<CallbackSpans>,   // Indexed8
+        blend_tiled_generic<CallbackSpans>,   // RGB32
+        blend_tiled_generic<CallbackSpans>,   // ARGB32
+        blend_tiled_argb<CallbackSpans>,      // ARGB32_Premultiplied
+        blend_tiled_generic<CallbackSpans>,   // RGB16
+        blend_tiled_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_tiled_generic<CallbackSpans>,   // RGB666
+        blend_tiled_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_tiled_generic<CallbackSpans>,   // RGB555
+        blend_tiled_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_tiled_generic<CallbackSpans>,   // RGB888
+        blend_tiled_generic<CallbackSpans>,   // RGB444
+        blend_tiled_generic<CallbackSpans>    // ARGB4444_Premultiplied
+    },
+    // Transformed
+    {
+        0, // Invalid
+        blend_src_generic<CallbackSpans>,   // Mono
+        blend_src_generic<CallbackSpans>,   // MonoLsb
+        blend_src_generic<CallbackSpans>,   // Indexed8
+        blend_src_generic<CallbackSpans>,   // RGB32
+        blend_src_generic<CallbackSpans>,   // ARGB32
+        blend_transformed_argb<CallbackSpans>, // ARGB32_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB16
+        blend_src_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB666
+        blend_src_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB555
+        blend_src_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB888
+        blend_src_generic<CallbackSpans>,   // RGB444
+        blend_src_generic<CallbackSpans>,   // ARGB4444_Premultiplied
+    },
+     // TransformedTiled
+    {
+        0,
+        blend_src_generic<CallbackSpans>,   // Mono
+        blend_src_generic<CallbackSpans>,   // MonoLsb
+        blend_src_generic<CallbackSpans>,   // Indexed8
+        blend_src_generic<CallbackSpans>,   // RGB32
+        blend_src_generic<CallbackSpans>,   // ARGB32
+        blend_transformed_tiled_argb<CallbackSpans>, // ARGB32_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB16
+        blend_src_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB666
+        blend_src_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB555
+        blend_src_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB888
+        blend_src_generic<CallbackSpans>,   // RGB444
+        blend_src_generic<CallbackSpans>    // ARGB4444_Premultiplied
+    },
+    // Bilinear
+    {
+        0,
+        blend_src_generic<CallbackSpans>,   // Mono
+        blend_src_generic<CallbackSpans>,   // MonoLsb
+        blend_src_generic<CallbackSpans>,   // Indexed8
+        blend_src_generic<CallbackSpans>,   // RGB32
+        blend_src_generic<CallbackSpans>,   // ARGB32
+        blend_transformed_bilinear_argb<CallbackSpans>, // ARGB32_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB16
+        blend_src_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB666
+        blend_src_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB555
+        blend_src_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB888
+        blend_src_generic<CallbackSpans>,   // RGB444
+        blend_src_generic<CallbackSpans>    // ARGB4444_Premultiplied
+    },
+    // BilinearTiled
+    {
+        0,
+        blend_src_generic<CallbackSpans>,   // Mono
+        blend_src_generic<CallbackSpans>,   // MonoLsb
+        blend_src_generic<CallbackSpans>,   // Indexed8
+        blend_src_generic<CallbackSpans>,   // RGB32
+        blend_src_generic<CallbackSpans>,   // ARGB32
+        blend_transformed_bilinear_tiled_argb<CallbackSpans>, // ARGB32_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB16
+        blend_src_generic<CallbackSpans>,   // ARGB8565_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB666
+        blend_src_generic<CallbackSpans>,   // ARGB6666_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB555
+        blend_src_generic<CallbackSpans>,   // ARGB8555_Premultiplied
+        blend_src_generic<CallbackSpans>,   // RGB888
+        blend_src_generic<CallbackSpans>,   // RGB444
+        blend_src_generic<CallbackSpans>    // ARGB4444_Premultiplied
+    }
+};
+#endif // QT_NO_RASTERCALLBACKS
+
+void qBlendTexture(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    ProcessSpans proc = processTextureSpans[getBlendType(data)][data->rasterBuffer->format];
+    proc(count, spans, userData);
+}
+
+#if defined (Q_WS_QWS) &&  !defined(QT_NO_RASTERCALLBACKS)
+void qBlendTextureCallback(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+    ProcessSpans proc = processTextureSpansCallback[getBlendType(data)][data->rasterBuffer->format];
+    proc(count, spans, userData);
+}
+#endif // QT_NO_RASTERCALLBACKS
+
+template <class DST>
+inline void qt_bitmapblit_template(QRasterBuffer *rasterBuffer,
+                                   int x, int y, quint32 color,
+                                   const uchar *map,
+                                   int mapWidth, int mapHeight, int mapStride,
+                                   DST dummy = 0)
+{
+    Q_UNUSED(dummy);
+    const DST c = qt_colorConvert<DST, quint32>(color, 0);
+    DST *dest = reinterpret_cast<DST*>(rasterBuffer->scanLine(y)) + x;
+    const int destStride = rasterBuffer->bytesPerLine() / sizeof(DST);
+
+    if (mapWidth > 8) {
+        while (mapHeight--) {
+            int x0 = 0;
+            int n = 0;
+            for (int x = 0; x < mapWidth; x += 8) {
+                uchar s = map[x >> 3];
+                for (int i = 0; i < 8; ++i) {
+                    if (s & 0x80) {
+                        ++n;
+                    } else {
+                        if (n) {
+                            qt_memfill(dest + x0, c, n);
+                            x0 += n + 1;
+                            n = 0;
+                        } else {
+                            ++x0;
+                        }
+                        if (!s) {
+                            x0 += 8 - 1 - i;
+                            break;
+                        }
+                    }
+                    s <<= 1;
+                }
+            }
+            if (n)
+                qt_memfill(dest + x0, c, n);
+            dest += destStride;
+            map += mapStride;
+        }
+    } else {
+        while (mapHeight--) {
+            int x0 = 0;
+            int n = 0;
+            for (uchar s = *map; s; s <<= 1) {
+                if (s & 0x80) {
+                    ++n;
+                } else if (n) {
+                    qt_memfill(dest + x0, c, n);
+                    x0 += n + 1;
+                    n = 0;
+                } else {
+                    ++x0;
+                }
+            }
+            if (n)
+                qt_memfill(dest + x0, c, n);
+            dest += destStride;
+            map += mapStride;
+        }
+    }
+}
+
+static void qt_gradient_quint32(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    bool isVerticalGradient =
+        data->txop <= QTransform::TxScale &&
+        data->type == QSpanData::LinearGradient &&
+        data->gradient.linear.end.x == data->gradient.linear.origin.x;
+
+    if (isVerticalGradient) {
+        LinearGradientValues linear;
+        getLinearGradientValues(&linear, data);
+
+        CompositionFunctionSolid funcSolid =
+            functionForModeSolid[data->rasterBuffer->compositionMode];
+
+        /*
+            The logic for vertical gradient calculations is a mathematically
+            reduced copy of that in fetchLinearGradient() - which is basically:
+
+                qreal ry = data->m22 * (y + 0.5) + data->dy;
+                qreal t = linear.dy*ry + linear.off;
+                t *= (GRADIENT_STOPTABLE_SIZE - 1);
+                quint32 color =
+                    qt_gradient_pixel_fixed(&data->gradient,
+                                            int(t * FIXPT_SIZE));
+
+            This has then been converted to fixed point to improve performance.
+         */
+        const int gss = GRADIENT_STOPTABLE_SIZE - 1;
+        int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE);
+        int off = int((((linear.dy * (data->m22 * 0.5 + data->dy) + linear.off) * gss) * FIXPT_SIZE));
+
+        while (count--) {
+            int y = spans->y;
+            int x = spans->x;
+
+            quint32 *dst = (quint32 *)(data->rasterBuffer->scanLine(y)) + x;
+            quint32 color =
+                qt_gradient_pixel_fixed(&data->gradient, yinc * y + off);
+
+            funcSolid(dst, spans->len, color, spans->coverage);
+            ++spans;
+        }
+
+    } else {
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+    }
+}
+
+static void qt_gradient_quint16(int count, const QSpan *spans, void *userData)
+{
+    QSpanData *data = reinterpret_cast<QSpanData *>(userData);
+
+    bool isVerticalGradient =
+        data->txop <= QTransform::TxScale &&
+        data->type == QSpanData::LinearGradient &&
+        data->gradient.linear.end.x == data->gradient.linear.origin.x;
+
+    if (isVerticalGradient) {
+
+        LinearGradientValues linear;
+        getLinearGradientValues(&linear, data);
+
+        /*
+            The logic for vertical gradient calculations is a mathematically
+            reduced copy of that in fetchLinearGradient() - which is basically:
+
+                qreal ry = data->m22 * (y + 0.5) + data->dy;
+                qreal t = linear.dy*ry + linear.off;
+                t *= (GRADIENT_STOPTABLE_SIZE - 1);
+                quint32 color =
+                    qt_gradient_pixel_fixed(&data->gradient,
+                                            int(t * FIXPT_SIZE));
+
+            This has then been converted to fixed point to improve performance.
+         */
+        const int gss = GRADIENT_STOPTABLE_SIZE - 1;
+        int yinc = int((linear.dy * data->m22 * gss) * FIXPT_SIZE);
+        int off = int((((linear.dy * (data->m22 * 0.5 + data->dy) + linear.off) * gss) * FIXPT_SIZE));
+
+        uint oldColor = data->solid.color;
+        while (count--) {
+            int y = spans->y;
+
+            quint32 color = qt_gradient_pixel_fixed(&data->gradient, yinc * y + off);
+
+            data->solid.color = color;
+            blend_color_rgb16(1, spans, userData);
+            ++spans;
+        }
+        data->solid.color = oldColor;
+
+    } else {
+        blend_src_generic<RegularSpans>(count, spans, userData
+                                        Q_TEMPLATE_ENUM_CALL(SpanMethod, RegularSpans));
+    }
+}
+
+inline static void qt_bitmapblit_quint32(QRasterBuffer *rasterBuffer,
+                                   int x, int y, quint32 color,
+                                   const uchar *map,
+                                   int mapWidth, int mapHeight, int mapStride)
+{
+    qt_bitmapblit_template<quint32>(rasterBuffer, x,  y,  color,
+                                    map, mapWidth, mapHeight, mapStride);
+}
+
+inline static void qt_bitmapblit_quint16(QRasterBuffer *rasterBuffer,
+                                   int x, int y, quint32 color,
+                                   const uchar *map,
+                                   int mapWidth, int mapHeight, int mapStride)
+{
+    qt_bitmapblit_template<quint16>(rasterBuffer, x,  y,  color,
+                                    map, mapWidth, mapHeight, mapStride);
+}
+
+
+uchar qt_pow_rgb_gamma[256];
+uchar qt_pow_rgb_invgamma[256];
+
+uint qt_pow_gamma[256];
+uchar qt_pow_invgamma[2048];
+
+static void qt_alphamapblit_quint16(QRasterBuffer *rasterBuffer,
+                                    int x, int y, quint32 color,
+                                    const uchar *map,
+                                    int mapWidth, int mapHeight, int mapStride,
+                                    const QClipData *)
+{
+    const quint16 c = qt_colorConvert<quint16, quint32>(color, 0);
+    quint16 *dest = reinterpret_cast<quint16*>(rasterBuffer->scanLine(y)) + x;
+    const int destStride = rasterBuffer->bytesPerLine() / sizeof(quint16);
+
+    while (mapHeight--) {
+        for (int i = 0; i < mapWidth; ++i) {
+            const int coverage = map[i];
+
+            if (coverage == 0) {
+                // nothing
+            } else if (coverage == 255) {
+                dest[i] = c;
+            } else {
+                int ialpha = 255 - coverage;
+                dest[i] = BYTE_MUL_RGB16(c, coverage)
+                          + BYTE_MUL_RGB16(dest[i], ialpha);
+            }
+        }
+        dest += destStride;
+        map += mapStride;
+    }
+}
+
+void qt_build_pow_tables() {
+    qreal smoothing = 1.7;
+
+#ifdef Q_WS_WIN
+    int winSmooth;
+    if (SystemParametersInfo(0x200C /* SPI_GETFONTSMOOTHINGCONTRAST */, 0, &winSmooth, 0))
+        smoothing = winSmooth / 1000.0;
+#endif
+
+#ifdef Q_WS_X11
+    Q_UNUSED(smoothing);
+    for (int i=0; i<256; ++i) {
+        qt_pow_rgb_gamma[i] = uchar(i);
+        qt_pow_rgb_invgamma[i] = uchar(i);
+    }
+#else
+    for (int i=0; i<256; ++i) {
+        qt_pow_rgb_gamma[i] = uchar(qRound(pow(i / 255.0, smoothing) * 255));
+        qt_pow_rgb_invgamma[i] = uchar(qRound(pow(i / 255.0, 1 / smoothing) * 255));
+    }
+#endif
+
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+    const qreal gray_gamma = 2.31;
+    for (int i=0; i<256; ++i)
+        qt_pow_gamma[i] = uint(qRound(pow(i / 255.0, gray_gamma) * 2047));
+    for (int i=0; i<2048; ++i)
+        qt_pow_invgamma[i] = uchar(qRound(pow(i / 2047.0, 1 / gray_gamma) * 255));
+#endif
+}
+
+static inline void rgbBlendPixel(quint32 *dst, int coverage, int sr, int sg, int sb)
+{
+    // Do a gray alphablend...
+    int da = qAlpha(*dst);
+    int dr = qRed(*dst);
+    int dg = qGreen(*dst);
+    int db = qBlue(*dst);
+
+    if (da != 255
+#if defined (Q_WS_WIN)
+        // Work around GDI messing up alpha channel
+        && qRed(*dst) <= da && qBlue(*dst) <= da && qGreen(*dst) <= da
+#endif
+        ) {
+
+        int a = qGray(coverage);
+        sr = qt_div_255(sr * a);
+        sg = qt_div_255(sg * a);
+        sb = qt_div_255(sb * a);
+
+        int ia = 255 - a;
+        dr = qt_div_255(dr * ia);
+        dg = qt_div_255(dg * ia);
+        db = qt_div_255(db * ia);
+
+        *dst = ((a + qt_div_255((255 - a) * da)) << 24)
+            |  ((sr + dr) << 16)
+            |  ((sg + dg) << 8)
+            |  ((sb + db));
+        return;
+    }
+
+    int mr = qRed(coverage);
+    int mg = qGreen(coverage);
+    int mb = qBlue(coverage);
+
+    dr = qt_pow_rgb_gamma[dr];
+    dg = qt_pow_rgb_gamma[dg];
+    db = qt_pow_rgb_gamma[db];
+
+    int nr = qt_div_255((sr - dr) * mr) + dr;
+    int ng = qt_div_255((sg - dg) * mg) + dg;
+    int nb = qt_div_255((sb - db) * mb) + db;
+
+    nr = qt_pow_rgb_invgamma[nr];
+    ng = qt_pow_rgb_invgamma[ng];
+    nb = qt_pow_rgb_invgamma[nb];
+
+    *dst = qRgb(nr, ng, nb);
+}
+
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+static inline void grayBlendPixel(quint32 *dst, int coverage, int sr, int sg, int sb)
+{
+    // Do a gammacorrected gray alphablend...
+    int dr = qRed(*dst);
+    int dg = qGreen(*dst);
+    int db = qBlue(*dst);
+
+    dr = qt_pow_gamma[dr];
+    dg = qt_pow_gamma[dg];
+    db = qt_pow_gamma[db];
+
+    int alpha = coverage;
+    int ialpha = 255 - alpha;
+    int nr = (sr * alpha + ialpha * dr) / 255;
+    int ng = (sg * alpha + ialpha * dg) / 255;
+    int nb = (sb * alpha + ialpha * db) / 255;
+
+    nr = qt_pow_invgamma[nr];
+    ng = qt_pow_invgamma[ng];
+    nb = qt_pow_invgamma[nb];
+
+    *dst = qRgb(nr, ng, nb);
+}
+#endif
+
+static void qt_alphamapblit_quint32(QRasterBuffer *rasterBuffer,
+                                    int x, int y, quint32 color,
+                                    const uchar *map,
+                                    int mapWidth, int mapHeight, int mapStride,
+                                    const QClipData *clip)
+{
+    const quint32 c = color;
+    const int destStride = rasterBuffer->bytesPerLine() / sizeof(quint32);
+
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+
+    sr = qt_pow_gamma[sr];
+    sg = qt_pow_gamma[sg];
+    sb = qt_pow_gamma[sb];
+    bool opaque_src = (qAlpha(color) == 255);
+#endif
+
+    if (!clip) {
+        quint32 *dest = reinterpret_cast<quint32*>(rasterBuffer->scanLine(y)) + x;
+        while (mapHeight--) {
+            for (int i = 0; i < mapWidth; ++i) {
+                const int coverage = map[i];
+
+                if (coverage == 0) {
+                    // nothing
+                } else if (coverage == 255) {
+                    dest[i] = c;
+                } else {
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+                    if (QSysInfo::WindowsVersion >= QSysInfo::WV_XP && opaque_src
+                        && qAlpha(dest[i]) == 255) {
+                        grayBlendPixel(dest+i, coverage, sr, sg, sb);
+                    } else
+#endif
+                    {
+                        int ialpha = 255 - coverage;
+                        dest[i] = BYTE_MUL(c, uint(coverage)) + BYTE_MUL(dest[i], ialpha);
+                    }
+                }
+            }
+            dest += destStride;
+            map += mapStride;
+        }
+    } else {
+        int bottom = qMin(y + mapHeight, rasterBuffer->height());
+
+        int top = qMax(y, 0);
+        map += (top - y) * mapStride;
+
+        const_cast<QClipData *>(clip)->initialize();
+        for (int yp = top; yp<bottom; ++yp) {
+            const QClipData::ClipLine &line = clip->m_clipLines[yp];
+
+            quint32 *dest = reinterpret_cast<quint32 *>(rasterBuffer->scanLine(yp));
+
+            for (int i=0; i<line.count; ++i) {
+                const QSpan &clip = line.spans[i];
+
+                int start = qMax<int>(x, clip.x);
+                int end = qMin<int>(x + mapWidth, clip.x + clip.len);
+
+                for (int xp=start; xp<end; ++xp) {
+                    const int coverage = map[xp - x];
+
+                    if (coverage == 0) {
+                        // nothing
+                    } else if (coverage == 255) {
+                        dest[xp] = c;
+                    } else {
+#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)
+                        if (QSysInfo::WindowsVersion >= QSysInfo::WV_XP && opaque_src
+                            && qAlpha(dest[xp]) == 255) {
+                            grayBlendPixel(dest+xp, coverage, sr, sg, sb);
+                        } else
+#endif
+                        {
+                            int ialpha = 255 - coverage;
+                            dest[xp] = BYTE_MUL(c, uint(coverage)) + BYTE_MUL(dest[xp], ialpha);
+                        }
+                    }
+
+                } // for (i -> line.count)
+            } // for (yp -> bottom)
+            map += mapStride;
+        }
+    }
+}
+
+static void qt_alphargbblit_quint32(QRasterBuffer *rasterBuffer,
+                                    int x, int y, quint32 color,
+                                    const uint *src, int mapWidth, int mapHeight, int srcStride,
+                                    const QClipData *clip)
+{
+    const quint32 c = color;
+
+    int sr = qRed(color);
+    int sg = qGreen(color);
+    int sb = qBlue(color);
+    int sa = qAlpha(color);
+
+    sr = qt_pow_rgb_gamma[sr];
+    sg = qt_pow_rgb_gamma[sg];
+    sb = qt_pow_rgb_gamma[sb];
+
+    if (sa == 0)
+        return;
+
+    if (!clip) {
+        quint32 *dst = reinterpret_cast<quint32*>(rasterBuffer->scanLine(y)) + x;
+        const int destStride = rasterBuffer->bytesPerLine() / sizeof(quint32);
+        while (mapHeight--) {
+            for (int i = 0; i < mapWidth; ++i) {
+                const uint coverage = src[i];
+                if (coverage == 0xffffffff) {
+                    dst[i] = c;
+                } else if (coverage != 0xff000000) {
+                    rgbBlendPixel(dst+i, coverage, sr, sg, sb);
+                }
+            }
+
+            dst += destStride;
+            src += srcStride;
+        }
+    } else {
+        int bottom = qMin(y + mapHeight, rasterBuffer->height());
+
+        int top = qMax(y, 0);
+        src += (top - y) * srcStride;
+
+        const_cast<QClipData *>(clip)->initialize();
+        for (int yp = top; yp<bottom; ++yp) {
+            const QClipData::ClipLine &line = clip->m_clipLines[yp];
+
+            quint32 *dst = reinterpret_cast<quint32 *>(rasterBuffer->scanLine(yp));
+
+            for (int i=0; i<line.count; ++i) {
+                const QSpan &clip = line.spans[i];
+
+                int start = qMax<int>(x, clip.x);
+                int end = qMin<int>(x + mapWidth, clip.x + clip.len);
+
+                for (int xp=start; xp<end; ++xp) {
+                    const uint coverage = src[xp - x];
+                    if (coverage == 0xffffffff) {
+                        dst[xp] = c;
+                    } else if (coverage != 0xff000000) {
+                        rgbBlendPixel(dst+xp, coverage, sr, sg, sb);
+                    }
+                }
+            } // for (i -> line.count)
+            src += srcStride;
+        } // for (yp -> bottom)
+
+    }
+}
+
+template <class T>
+inline void qt_rectfill_template(QRasterBuffer *rasterBuffer,
+                                 int x, int y, int width, int height,
+                                 quint32 color, T dummy = 0)
+{
+    Q_UNUSED(dummy);
+
+    qt_rectfill<T>(reinterpret_cast<T*>(rasterBuffer->buffer()),
+                   qt_colorConvert<T, quint32p>(quint32p::fromRawData(color), 0),
+                   x, y, width, height, rasterBuffer->bytesPerLine());
+}
+
+#define QT_RECTFILL(T)                                                  \
+    inline static void qt_rectfill_##T(QRasterBuffer *rasterBuffer,     \
+                                       int x, int y, int width, int height, \
+                                       quint32 color)                   \
+    {                                                                   \
+        qt_rectfill_template<T>(rasterBuffer, x, y, width, height, color); \
+    }
+
+QT_RECTFILL(quint32)
+QT_RECTFILL(quint16)
+QT_RECTFILL(qargb8565)
+QT_RECTFILL(qrgb666);
+QT_RECTFILL(qargb6666);
+QT_RECTFILL(qrgb555)
+QT_RECTFILL(qargb8555)
+QT_RECTFILL(qrgb888)
+QT_RECTFILL(qrgb444);
+QT_RECTFILL(qargb4444);
+#undef QT_RECTFILL
+
+
+// Map table for destination image format. Contains function pointers
+// for blends of various types unto the destination
+
+DrawHelper qDrawHelper[QImage::NImageFormats] =
+{
+    // Format_Invalid,
+    { 0, 0, 0, 0, 0, 0 },
+    // Format_Mono,
+    {
+        blend_color_generic,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0, 0
+    },
+    // Format_MonoLSB,
+    {
+        blend_color_generic,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0, 0
+    },
+    // Format_Indexed8,
+    {
+        blend_color_generic,
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0, 0
+    },
+    // Format_RGB32,
+    {
+        blend_color_argb,
+        qt_gradient_quint32,
+        qt_bitmapblit_quint32,
+        qt_alphamapblit_quint32,
+        qt_alphargbblit_quint32,
+        qt_rectfill_quint32
+    },
+    // Format_ARGB32,
+    {
+        blend_color_generic,
+        qt_gradient_quint32,
+        qt_bitmapblit_quint32,
+        qt_alphamapblit_quint32,
+        qt_alphargbblit_quint32,
+        qt_rectfill_quint32
+    },
+    // Format_ARGB32_Premultiplied
+    {
+        blend_color_argb,
+        qt_gradient_quint32,
+        qt_bitmapblit_quint32,
+        qt_alphamapblit_quint32,
+        qt_alphargbblit_quint32,
+        qt_rectfill_quint32
+    },
+    // Format_RGB16
+    {
+        blend_color_rgb16,
+        qt_gradient_quint16,
+        qt_bitmapblit_quint16,
+        qt_alphamapblit_quint16,
+        0,
+        qt_rectfill_quint16
+    },
+    // Format_ARGB8565_Premultiplied
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qargb8565),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qargb8565
+    },
+    // Format_RGB666
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qrgb666),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qrgb666
+    },
+    // Format_ARGB6666_Premultiplied
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qargb6666),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qargb6666
+    },
+    // Format_RGB555
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qrgb555),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qrgb555
+    },
+    // Format_ARGB8555_Premultiplied
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qargb8555),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qargb8555
+    },
+    // Format_RGB888
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qrgb888),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qrgb888
+    },
+    // Format_RGB444
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qrgb444),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qrgb444
+    },
+    // Format_ARGB4444_Premultiplied
+    {
+        SPANFUNC_POINTER_BLENDCOLOR(qargb4444),
+        SPANFUNC_POINTER(blend_src_generic, RegularSpans),
+        0, 0, 0,
+        qt_rectfill_qargb4444
+    }
+};
+
+#if defined (Q_WS_QWS) && !defined(QT_NO_RASTERCALLBACKS)
+DrawHelper qDrawHelperCallback[QImage::NImageFormats] =
+{
+    // Format_Invalid,
+    { 0, 0, 0, 0, 0, 0 },
+    // Format_Mono,
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_MonoLSB,
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_Indexed8,
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB32,
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB32,
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB32_Premultiplied
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB16
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB8565_Premultiplied
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB666
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB6666_Premultiplied
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB555
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB8555_Premultiplied
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB888
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_RGB444
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    },
+    // Format_ARGB4444_Premultiplied
+    {
+        blend_color_generic_callback,
+        blend_src_generic<CallbackSpans>,
+        0, 0, 0, 0
+    }
+};
+#endif
+
+
+
+#if defined(Q_CC_MSVC) && !defined(_MIPS_)
+template <class DST, class SRC>
+inline void qt_memfill_template(DST *dest, SRC color, int count)
+{
+    const DST c = qt_colorConvert<DST, SRC>(color, 0);
+    while (count--)
+        *dest++ = c;
+}
+
+#else
+
+template <class DST, class SRC>
+inline void qt_memfill_template(DST *dest, SRC color, int count)
+{
+    const DST c = qt_colorConvert<DST, SRC>(color, 0);
+    int n = (count + 7) / 8;
+    switch (count & 0x07)
+    {
+    case 0: do { *dest++ = c;
+    case 7:      *dest++ = c;
+    case 6:      *dest++ = c;
+    case 5:      *dest++ = c;
+    case 4:      *dest++ = c;
+    case 3:      *dest++ = c;
+    case 2:      *dest++ = c;
+    case 1:      *dest++ = c;
+    } while (--n > 0);
+    }
+}
+
+template <>
+inline void qt_memfill_template(quint16 *dest, quint16 value, int count)
+{
+    if (count < 3) {
+        switch (count) {
+        case 2: *dest++ = value;
+        case 1: *dest = value;
+        }
+        return;
+    }
+
+    const int align = (quintptr)(dest) & 0x3;
+    switch (align) {
+    case 2: *dest++ = value; --count;
+    }
+
+    const quint32 value32 = (value << 16) | value;
+    qt_memfill(reinterpret_cast<quint32*>(dest), value32, count / 2);
+    if (count & 0x1)
+        dest[count - 1] = value;
+}
+#endif
+
+static void qt_memfill_quint16(quint16 *dest, quint16 color, int count)
+{
+    qt_memfill_template<quint16, quint16>(dest, color, count);
+}
+
+typedef void (*qt_memfill32_func)(quint32 *dest, quint32 value, int count);
+typedef void (*qt_memfill16_func)(quint16 *dest, quint16 value, int count);
+static void qt_memfill32_setup(quint32 *dest, quint32 value, int count);
+static void qt_memfill16_setup(quint16 *dest, quint16 value, int count);
+
+qt_memfill32_func qt_memfill32 = qt_memfill32_setup;
+qt_memfill16_func qt_memfill16 = qt_memfill16_setup;
+
+enum CPUFeatures {
+    None        = 0,
+    MMX         = 0x1,
+    MMXEXT      = 0x2,
+    MMX3DNOW    = 0x4,
+    MMX3DNOWEXT = 0x8,
+    SSE         = 0x10,
+    SSE2        = 0x20,
+    CMOV        = 0x40,
+    IWMMXT      = 0x80
+};
+
+static uint detectCPUFeatures()
+{
+#if defined (Q_OS_WINCE)
+#if defined (ARM)
+    if (IsProcessorFeaturePresent(PF_ARM_INTEL_WMMX))
+        return IWMMXT;
+#elif defined(_X86_)
+    uint features = 0;
+#if defined QT_HAVE_MMX
+    if (IsProcessorFeaturePresent(PF_MMX_INSTRUCTIONS_AVAILABLE))
+        features |= MMX;
+#endif
+#if defined QT_HAVE_3DNOW
+    if (IsProcessorFeaturePresent(PF_3DNOW_INSTRUCTIONS_AVAILABLE))
+        features |= MMX3DNOW;
+#endif
+    return features;
+#endif
+    return 0;
+#elif defined(QT_HAVE_IWMMXT)
+    // runtime detection only available when running as a previlegied process
+    static const bool doIWMMXT = !qgetenv("QT_NO_IWMMXT").toInt();
+    return doIWMMXT ? IWMMXT : 0;
+#else
+    uint features = 0;
+#if defined(__x86_64__) || defined(Q_OS_WIN64)
+    features = MMX|SSE|SSE2|CMOV;
+#elif defined(__ia64__)
+    features = MMX|SSE|SSE2;
+#elif defined(__i386__) || defined(_M_IX86)
+    unsigned int extended_result = 0;
+    uint result = 0;
+    /* see p. 118 of amd64 instruction set manual Vol3 */
+#if defined(Q_CC_GNU)
+    asm ("push %%ebx\n"
+         "pushf\n"
+         "pop %%eax\n"
+         "mov %%eax, %%ebx\n"
+         "xor $0x00200000, %%eax\n"
+         "push %%eax\n"
+         "popf\n"
+         "pushf\n"
+         "pop %%eax\n"
+         "xor %%edx, %%edx\n"
+         "xor %%ebx, %%eax\n"
+         "jz 1f\n"
+
+         "mov $0x00000001, %%eax\n"
+         "cpuid\n"
+         "1:\n"
+         "pop %%ebx\n"
+         "mov %%edx, %0\n"
+        : "=r" (result)
+        :
+        : "%eax", "%ecx", "%edx"
+        );
+
+    asm ("push %%ebx\n"
+         "pushf\n"
+         "pop %%eax\n"
+         "mov %%eax, %%ebx\n"
+         "xor $0x00200000, %%eax\n"
+         "push %%eax\n"
+         "popf\n"
+         "pushf\n"
+         "pop %%eax\n"
+         "xor %%edx, %%edx\n"
+         "xor %%ebx, %%eax\n"
+         "jz 2f\n"
+
+         "mov $0x80000000, %%eax\n"
+         "cpuid\n"
+         "cmp $0x80000000, %%eax\n"
+         "jbe 2f\n"
+         "mov $0x80000001, %%eax\n"
+         "cpuid\n"
+         "2:\n"
+         "pop %%ebx\n"
+         "mov %%edx, %0\n"
+        : "=r" (extended_result)
+        :
+        : "%eax", "%ecx", "%edx"
+        );
+#elif defined (Q_OS_WIN)
+    _asm {
+        push eax
+        push ebx
+        push ecx
+        push edx
+        pushfd
+        pop eax
+        mov ebx, eax
+        xor eax, 00200000h
+        push eax
+        popfd
+        pushfd
+        pop eax
+        mov edx, 0
+        xor eax, ebx
+        jz skip
+
+        mov eax, 1
+        cpuid
+        mov result, edx
+    skip:
+        pop edx
+        pop ecx
+        pop ebx
+        pop eax
+    }
+
+    _asm {
+        push eax
+        push ebx
+        push ecx
+        push edx
+        pushfd
+        pop eax
+        mov ebx, eax
+        xor eax, 00200000h
+        push eax
+        popfd
+        pushfd
+        pop eax
+        mov edx, 0
+        xor eax, ebx
+        jz skip2
+
+        mov eax, 80000000h
+        cpuid
+        cmp eax, 80000000h
+        jbe skip2
+        mov eax, 80000001h
+        cpuid
+        mov extended_result, edx
+    skip2:
+        pop edx
+        pop ecx
+        pop ebx
+        pop eax
+    }
+#endif
+
+    // result now contains the standard feature bits
+    if (result & (1u << 15))
+        features |= CMOV;
+    if (result & (1u << 23))
+        features |= MMX;
+    if (extended_result & (1u << 22))
+        features |= MMXEXT;
+    if (extended_result & (1u << 31))
+        features |= MMX3DNOW;
+    if (extended_result & (1u << 30))
+        features |= MMX3DNOWEXT;
+    if (result & (1u << 25))
+        features |= SSE;
+    if (result & (1u << 26))
+        features |= SSE2;
+#endif // i386
+
+    if (qgetenv("QT_NO_MMX").toInt())
+        features ^= MMX;
+    if (qgetenv("QT_NO_MMXEXT").toInt())
+        features ^= MMXEXT;
+    if (qgetenv("QT_NO_3DNOW").toInt())
+        features ^= MMX3DNOW;
+    if (qgetenv("QT_NO_3DNOWEXT").toInt())
+        features ^= MMX3DNOWEXT;
+    if (qgetenv("QT_NO_SSE").toInt())
+        features ^= SSE;
+    if (qgetenv("QT_NO_SSE2").toInt())
+        features ^= SSE2;
+
+    return features;
+#endif
+}
+
+void qInitDrawhelperAsm()
+{
+    static uint features = 0xffffffff;
+    if (features != 0xffffffff)
+        return;
+    features = detectCPUFeatures();
+
+    qt_memfill32 = qt_memfill_template<quint32, quint32>;
+    qt_memfill16 = qt_memfill_quint16; //qt_memfill_template<quint16, quint16>;
+
+    CompositionFunction *functionForModeAsm = 0;
+    CompositionFunctionSolid *functionForModeSolidAsm = 0;
+
+#ifdef QT_NO_DEBUG
+    if (false) {
+#ifdef QT_HAVE_SSE2
+    } else if (features & SSE2) {
+        qt_memfill32 = qt_memfill32_sse2;
+        qt_memfill16 = qt_memfill16_sse2;
+        qDrawHelper[QImage::Format_RGB32].bitmapBlit = qt_bitmapblit32_sse2;
+        qDrawHelper[QImage::Format_ARGB32].bitmapBlit = qt_bitmapblit32_sse2;
+        qDrawHelper[QImage::Format_ARGB32_Premultiplied].bitmapBlit = qt_bitmapblit32_sse2;
+        qDrawHelper[QImage::Format_RGB16].bitmapBlit = qt_bitmapblit16_sse2;
+#endif
+#ifdef QT_HAVE_SSE
+    } else if (features & SSE) {
+//        qt_memfill32 = qt_memfill32_sse;
+        qDrawHelper[QImage::Format_RGB16].bitmapBlit = qt_bitmapblit16_sse;
+#ifdef QT_HAVE_3DNOW
+        if (features & MMX3DNOW) {
+            qt_memfill32 = qt_memfill32_sse3dnow;
+            qDrawHelper[QImage::Format_RGB16].bitmapBlit = qt_bitmapblit16_sse3dnow;
+        }
+#endif
+#endif // SSE
+#if defined(QT_HAVE_MMXEXT) && defined(QT_HAVE_SSE)
+    } else if (features & MMXEXT) {
+        qt_memfill32 = qt_memfill32_sse;
+        qDrawHelper[QImage::Format_RGB16].bitmapBlit = qt_bitmapblit16_sse;
+# ifdef QT_HAVE_3DNOW
+        if (features & MMX3DNOW) {
+            qt_memfill32 = qt_memfill32_sse3dnow;
+            qDrawHelper[QImage::Format_RGB16].bitmapBlit = qt_bitmapblit16_sse3dnow;
+        }
+# endif // 3DNOW
+#endif // MMXEXT
+    }
+#ifdef QT_HAVE_MMX
+    if (features & MMX) {
+        functionForModeAsm = qt_functionForMode_MMX;
+        functionForModeSolidAsm = qt_functionForModeSolid_MMX;
+        qDrawHelper[QImage::Format_ARGB32_Premultiplied].blendColor = qt_blend_color_argb_mmx;
+#ifdef QT_HAVE_3DNOW
+        if (features & MMX3DNOW) {
+            functionForModeAsm = qt_functionForMode_MMX3DNOW;
+            functionForModeSolidAsm = qt_functionForModeSolid_MMX3DNOW;
+            qDrawHelper[QImage::Format_ARGB32_Premultiplied].blendColor = qt_blend_color_argb_mmx3dnow;
+        }
+#endif // 3DNOW
+
+        extern void qt_blend_rgb32_on_rgb32_mmx(uchar *destPixels, int dbpl,
+                                                const uchar *srcPixels, int sbpl,
+                                                int w, int h,
+                                                int const_alpha);
+        extern void qt_blend_argb32_on_argb32_mmx(uchar *destPixels, int dbpl,
+                                                  const uchar *srcPixels, int sbpl,
+                                                  int w, int h,
+                                                  int const_alpha);
+
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_mmx;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_mmx;
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_mmx;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_mmx;
+
+    }
+#endif // MMX
+
+#ifdef QT_HAVE_SSE
+    if (features & SSE) {
+        functionForModeAsm = qt_functionForMode_SSE;
+        functionForModeSolidAsm = qt_functionForModeSolid_SSE;
+        qDrawHelper[QImage::Format_ARGB32_Premultiplied].blendColor = qt_blend_color_argb_sse;
+#ifdef QT_HAVE_3DNOW
+        if (features & MMX3DNOW) {
+            functionForModeAsm = qt_functionForMode_SSE3DNOW;
+            functionForModeSolidAsm = qt_functionForModeSolid_SSE3DNOW;
+            qDrawHelper[QImage::Format_ARGB32_Premultiplied].blendColor = qt_blend_color_argb_sse3dnow;
+        }
+#endif // 3DNOW
+        extern void qt_blend_rgb32_on_rgb32_sse(uchar *destPixels, int dbpl,
+                                                const uchar *srcPixels, int sbpl,
+                                                int w, int h,
+                                                int const_alpha);
+        extern void qt_blend_argb32_on_argb32_sse(uchar *destPixels, int dbpl,
+                                                  const uchar *srcPixels, int sbpl,
+                                                  int w, int h,
+                                                  int const_alpha);
+
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_sse;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_RGB32] = qt_blend_rgb32_on_rgb32_sse;
+        qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_sse;
+        qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_sse;
+    }
+#endif // SSE
+
+#ifdef QT_HAVE_IWMMXT
+    if (features & IWMMXT) {
+        functionForModeAsm = qt_functionForMode_IWMMXT;
+        functionForModeSolidAsm = qt_functionForModeSolid_IWMMXT;
+        qDrawHelper[QImage::Format_ARGB32_Premultiplied].blendColor = qt_blend_color_argb_iwmmxt;
+    }
+#endif // IWMMXT
+
+#endif // QT_NO_DEBUG
+
+    if (functionForModeSolidAsm) {
+        const int destinationMode = QPainter::CompositionMode_Destination;
+        functionForModeSolidAsm[destinationMode] = functionForModeSolid_C[destinationMode];
+
+        // use the default qdrawhelper implementation for the
+        // extended composition modes
+        for (int mode = 12; mode < 24; ++mode)
+            functionForModeSolidAsm[mode] = functionForModeSolid_C[mode];
+
+        functionForModeSolid = functionForModeSolidAsm;
+    }
+    if (functionForModeAsm) {
+        const int destinationMode = QPainter::CompositionMode_Destination;
+        functionForModeAsm[destinationMode] = functionForMode_C[destinationMode];
+
+        // use the default qdrawhelper implementation for the
+        // extended composition modes
+        for (int mode = 12; mode < numCompositionFunctions; ++mode)
+            functionForModeAsm[mode] = functionForMode_C[mode];
+
+        functionForMode = functionForModeAsm;
+    }
+
+    qt_build_pow_tables();
+}
+
+static void qt_memfill32_setup(quint32 *dest, quint32 value, int count)
+{
+    qInitDrawhelperAsm();
+    qt_memfill32(dest, value, count);
+}
+
+static void qt_memfill16_setup(quint16 *dest, quint16 value, int count)
+{
+    qInitDrawhelperAsm();
+    qt_memfill16(dest, value, count);
+}
+
+#ifdef QT_QWS_DEPTH_GENERIC
+
+int qrgb::bpp = 0;
+int qrgb::len_red = 0;
+int qrgb::len_green = 0;
+int qrgb::len_blue = 0;
+int qrgb::len_alpha = 0;
+int qrgb::off_red = 0;
+int qrgb::off_green = 0;
+int qrgb::off_blue = 0;
+int qrgb::off_alpha = 0;
+
+template <typename SRC>
+Q_STATIC_TEMPLATE_FUNCTION inline void qt_rectconvert_rgb(qrgb *dest, const SRC *src,
+                                      int x, int y, int width, int height,
+                                      int dstStride, int srcStride)
+{
+    quint8 *dest8 = reinterpret_cast<quint8*>(dest)
+                    + y * dstStride + x * qrgb::bpp;
+
+    srcStride = srcStride / sizeof(SRC) - width;
+    dstStride -= (width * qrgb::bpp);
+
+    for (int j = 0;  j < height; ++j) {
+        for (int i = 0; i < width; ++i) {
+            const quint32 v = qt_convertToRgb<SRC>(*src++);
+#if Q_BYTE_ORDER == Q_BIG_ENDIAN
+            for (int j = qrgb::bpp - 1; j >= 0; --j)
+                *dest8++ = (v >> (8 * j)) & 0xff;
+#else
+            for (int j = 0; j < qrgb::bpp; ++j)
+                *dest8++ = (v >> (8 * j)) & 0xff;
+#endif
+        }
+
+        dest8 += dstStride;
+        src += srcStride;
+    }
+}
+
+template <>
+void qt_rectconvert(qrgb *dest, const quint32 *src,
+                    int x, int y, int width, int height,
+                    int dstStride, int srcStride)
+{
+    qt_rectconvert_rgb<quint32>(dest, src, x, y, width, height,
+                                dstStride, srcStride);
+}
+
+template <>
+void qt_rectconvert(qrgb *dest, const quint16 *src,
+                    int x, int y, int width, int height,
+                    int dstStride, int srcStride)
+{
+    qt_rectconvert_rgb<quint16>(dest, src, x, y, width, height,
+                                dstStride, srcStride);
+}
+
+#endif // QT_QWS_DEPTH_GENERIC
+
+QT_END_NAMESPACE