1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <qmath.h>

    43 #include "qdrawhelper_p.h"

    44 

    45 QT_BEGIN_NAMESPACE

    46 

    47 struct SourceOnlyAlpha

    48 {

    49     inline uchar alpha(uchar src) const { return src; }

    50     inline quint16 bytemul(quint16 spix) const { return spix; }

    51 };

    52 

    53 

    54 struct SourceAndConstAlpha

    55 {

    56     SourceAndConstAlpha(int a) : m_alpha256(a) {

    57         m_alpha255 = (m_alpha256 * 255) >> 8;

    58     };

    59     inline uchar alpha(uchar src) const { return (src * m_alpha256) >> 8; }

    60     inline quint16 bytemul(quint16 x) const {

    61         uint t = (((x & 0x07e0)*m_alpha255) >> 8) & 0x07e0;

    62         t |= (((x & 0xf81f)*(m_alpha255>>2)) >> 6) & 0xf81f;

    63         return t;

    64     }

    65     int m_alpha255;

    66     int m_alpha256;

    67 };

    68 

    69 

    70 /************************************************************************

    71                        RGB16 (565) format target format

    72  ************************************************************************/

    73 

    74 static inline quint16 convert_argb32_to_rgb16(quint32 spix)

    75 {

    76     quint32 b = spix;

    77     quint32 g = spix;

    78     b >>= 8;

    79     g >>= 5;

    80     b &= 0x0000f800;

    81     g &= 0x000007e0;

    82     spix >>= 3;

    83     b |= g;

    84     spix &= 0x0000001f;

    85     b |= spix;

    86     return b;

    87 }

    88 

    89 struct Blend_RGB16_on_RGB16_NoAlpha {

    90     inline void write(quint16 *dst, quint16 src) { *dst = src; }

    91 };

    92 

    93 struct Blend_RGB16_on_RGB16_ConstAlpha {

    94     inline Blend_RGB16_on_RGB16_ConstAlpha(quint32 alpha) {

    95         m_alpha = (alpha * 255) >> 8;

    96         m_ialpha = 255 - m_alpha;

    97     }

    98 

    99     inline void write(quint16 *dst, quint16 src) {

   100         *dst = BYTE_MUL_RGB16(src, m_alpha) + BYTE_MUL_RGB16(*dst, m_ialpha);

   101     }

   102 

   103     quint32 m_alpha;

   104     quint32 m_ialpha;

   105 };

   106 

   107 struct Blend_ARGB24_on_RGB16_SourceAlpha {

   108     inline void write(quint16 *dst, const qargb8565 &src) {

   109         const uint alpha = src.alpha();

   110         if (alpha) {

   111             quint16 s = src.rawValue16();

   112             if (alpha < 255)

   113                 s += BYTE_MUL_RGB16(*dst, 255 - alpha);

   114             *dst = s;

   115         }

   116     }

   117 };

   118 

   119 struct Blend_ARGB24_on_RGB16_SourceAndConstAlpha {

   120     inline Blend_ARGB24_on_RGB16_SourceAndConstAlpha(quint32 alpha) {

   121         m_alpha = (alpha * 255) >> 8;

   122     }

   123 

   124     inline void write(quint16 *dst, qargb8565 src) {

   125         src = src.byte_mul(src.alpha(m_alpha));

   126         const uint alpha = src.alpha();

   127         if (alpha) {

   128             quint16 s = src.rawValue16();

   129             if (alpha < 255)

   130                 s += BYTE_MUL_RGB16(*dst, 255 - alpha);

   131             *dst = s;

   132         }

   133     }

   134 

   135     quint32 m_alpha;

   136 };

   137 

   138 struct Blend_ARGB32_on_RGB16_SourceAlpha {

   139     inline void write(quint16 *dst, quint32 src) {

   140         const quint8 alpha = qAlpha(src);

   141         if(alpha) {

   142             quint16 s = convert_argb32_to_rgb16(src);

   143             if(alpha < 255)

   144                 s += BYTE_MUL_RGB16(*dst, 255 - alpha);

   145             *dst = s;

   146         }

   147     }

   148 };

   149 

   150 struct Blend_ARGB32_on_RGB16_SourceAndConstAlpha {

   151     inline Blend_ARGB32_on_RGB16_SourceAndConstAlpha(quint32 alpha) {

   152         m_alpha = (alpha * 255) >> 8;

   153     }

   154 

   155     inline void write(quint16 *dst, quint32 src) {

   156         src = BYTE_MUL(src, m_alpha);

   157         const quint8 alpha = qAlpha(src);

   158         if(alpha) {

   159             quint16 s = convert_argb32_to_rgb16(src);

   160             if(alpha < 255)

   161                 s += BYTE_MUL_RGB16(*dst, 255 - alpha);

   162             *dst = s;

   163         }

   164     }

   165 

   166     quint32 m_alpha;

   167 };

   168 

   169 template <typename SRC, typename T>

   170 void qt_scale_image_16bit(uchar *destPixels, int dbpl,

   171                           const uchar *srcPixels, int sbpl,

   172                           const QRectF &targetRect,

   173                           const QRectF &srcRect,

   174                           const QRect &clip,

   175                           T blender)

   176 {

   177     qreal sx = targetRect.width() / (qreal) srcRect.width();

   178     qreal sy = targetRect.height() / (qreal) srcRect.height();

   179 

   180     int ix = 0x00010000 / sx;

   181     int iy = 0x00010000 / sy;

   182 

   183 //     qDebug() << "scale:" << endl

   184 //              << " - target" << targetRect << endl

   185 //              << " - source" << srcRect << endl

   186 //              << " - clip" << clip << endl

   187 //              << " - sx=" << sx << " sy=" << sy << " ix=" << ix << " iy=" << iy;

   188 

   189     int cx1 = clip.x();

   190     int cx2 = clip.x() + clip.width();

   191     int cy1 = clip.top();

   192     int cy2 = clip.y() + clip.height();

   193 

   194     int tx1 = qRound(targetRect.left());

   195     int tx2 = qRound(targetRect.right());

   196     int ty1 = qRound(targetRect.top());

   197     int ty2 = qRound(targetRect.bottom());

   198 

   199     if (tx2 < tx1)

   200         qSwap(tx2, tx1);

   201 

   202     if (ty2 < ty1)

   203         qSwap(ty2, ty1);

   204 

   205     if (tx1 < cx1)

   206         tx1 = cx1;

   207 

   208     if (tx2 >= cx2)

   209         tx2 = cx2;

   210 

   211     if (tx1 >= tx2)

   212         return;

   213 

   214     if (ty1 < cy1)

   215         ty1 = cy1;

   216 

   217     if (ty2 >= cy2)

   218        ty2 = cy2;

   219 

   220     if (ty1 >= ty2)

   221         return;

   222 

   223     int h = ty2 - ty1;

   224     int w = tx2 - tx1;

   225 

   226     const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1;

   227     const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;

   228 

   229     quint32 basex = quint32((sx < 0 ? srcRect.right() : srcRect.left()) * 65536) + dstx;

   230     quint32 srcy = quint32((sy < 0 ? srcRect.bottom() : srcRect.top()) * 65536) + dsty;

   231 

   232     quint16 *dst = ((quint16 *) (destPixels + ty1 * dbpl)) + tx1;

   233 

   234     while (h--) {

   235         const SRC *src = (const SRC *) (srcPixels + (srcy >> 16) * sbpl);

   236         int srcx = basex;

   237         for (int x=0; x<w; ++x) {

   238             blender.write(&dst[x], src[srcx >> 16]);

   239             srcx += ix;

   240         }

   241         dst = (quint16 *)(((uchar *) dst) + dbpl);

   242         srcy += iy;

   243     }

   244 }

   245 

   246 void qt_scale_image_rgb16_on_rgb16(uchar *destPixels, int dbpl,

   247                                    const uchar *srcPixels, int sbpl,

   248                                    const QRectF &targetRect,

   249                                    const QRectF &sourceRect,

   250                                    const QRect &clip,

   251                                    int const_alpha)

   252 {

   253 #ifdef QT_DEBUG_DRAW

   254     printf("qt_scale_rgb16_on_rgb16: dst=(%p, %d), src=(%p, %d), target=(%d, %d), [%d x %d], src=(%d, %d) [%d x %d] alpha=%d\n",

   255            destPixels, dbpl, srcPixels, sbpl,

   256            targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(),

   257            sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height(),

   258            const_alpha);

   259 #endif

   260     if (const_alpha == 256) {

   261         Blend_RGB16_on_RGB16_NoAlpha noAlpha;

   262         qt_scale_image_16bit<quint16>(destPixels, dbpl, srcPixels, sbpl,

   263                                       targetRect, sourceRect, clip, noAlpha);

   264     } else {

   265         Blend_RGB16_on_RGB16_ConstAlpha constAlpha(const_alpha);

   266         qt_scale_image_16bit<quint16>(destPixels, dbpl, srcPixels, sbpl,

   267                                      targetRect, sourceRect, clip, constAlpha);

   268     }

   269 }

   270 

   271 void qt_scale_image_argb24_on_rgb16(uchar *destPixels, int dbpl,

   272                                    const uchar *srcPixels, int sbpl,

   273                                    const QRectF &targetRect,

   274                                    const QRectF &sourceRect,

   275                                    const QRect &clip,

   276                                    int const_alpha)

   277 {

   278 #ifdef QT_DEBUG_DRAW

   279     printf("qt_scale_argb24_on_rgb16: dst=(%p, %d), src=(%p, %d), target=(%d, %d), [%d x %d], src=(%d, %d) [%d x %d] alpha=%d\n",

   280            destPixels, dbpl, srcPixels, sbpl,

   281            targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(),

   282            sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height(),

   283            const_alpha);

   284 #endif

   285     if (const_alpha == 256) {

   286         Blend_ARGB24_on_RGB16_SourceAlpha noAlpha;

   287         qt_scale_image_16bit<qargb8565>(destPixels, dbpl, srcPixels, sbpl,

   288                                         targetRect, sourceRect, clip, noAlpha);

   289     } else {

   290         Blend_ARGB24_on_RGB16_SourceAndConstAlpha constAlpha(const_alpha);

   291         qt_scale_image_16bit<qargb8565>(destPixels, dbpl, srcPixels, sbpl,

   292                                         targetRect, sourceRect, clip, constAlpha);

   293     }

   294 }

   295 

   296 

   297 void qt_scale_image_argb32_on_rgb16(uchar *destPixels, int dbpl,

   298                                     const uchar *srcPixels, int sbpl,

   299                                     const QRectF &targetRect,

   300                                     const QRectF &sourceRect,

   301                                     const QRect &clip,

   302                                     int const_alpha)

   303 {

   304 #ifdef QT_DEBUG_DRAW

   305     printf("qt_scale_argb32_on_rgb16: dst=(%p, %d), src=(%p, %d), target=(%d, %d), [%d x %d], src=(%d, %d) [%d x %d] alpha=%d\n",

   306            destPixels, dbpl, srcPixels, sbpl,

   307            targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(),

   308            sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height(),

   309            const_alpha);

   310 #endif

   311     if (const_alpha == 256) {

   312         Blend_ARGB32_on_RGB16_SourceAlpha noAlpha;

   313         qt_scale_image_16bit<quint32>(destPixels, dbpl, srcPixels, sbpl,

   314                                       targetRect, sourceRect, clip, noAlpha);

   315     } else {

   316         Blend_ARGB32_on_RGB16_SourceAndConstAlpha constAlpha(const_alpha);

   317         qt_scale_image_16bit<quint32>(destPixels, dbpl, srcPixels, sbpl,

   318                                      targetRect, sourceRect, clip, constAlpha);

   319     }

   320 }

   321 

   322 static void qt_blend_rgb16_on_rgb16(uchar *dst, int dbpl,

   323                                     const uchar *src, int sbpl,

   324                                     int w, int h,

   325                                     int const_alpha)

   326 {

   327 #ifdef QT_DEBUG_DRAW

   328     printf("qt_blend_rgb16_on_rgb16: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",

   329            dst, dbpl, src, sbpl, w, h, const_alpha);

   330 #endif

   331 

   332     if (const_alpha == 256) {

   333         if (w <= 64) {

   334             while (h--) {

   335                 QT_MEMCPY_USHORT(dst, src, w);

   336                 dst += dbpl;

   337                 src += sbpl;

   338             }

   339         } else {

   340             int length = w << 1;

   341             while (h--) {

   342                 memcpy(dst, src, length);

   343                 dst += dbpl;

   344                 src += sbpl;

   345             }

   346         }

   347     } else if (const_alpha != 0) {

   348         SourceAndConstAlpha alpha(const_alpha); // expects the 0-256 range

   349         quint16 *d = (quint16 *) dst;

   350         const quint16 *s = (const quint16 *) src;

   351         quint8 a = (255 * const_alpha) >> 8;

   352         quint8 ia = 255 - a;

   353         while (h--) {

   354             for (int x=0; x<w; ++x) {

   355                 d[x] = BYTE_MUL_RGB16(s[x], a) + BYTE_MUL_RGB16(d[x], ia);

   356             }

   357             d = (quint16 *)(((uchar *) d) + dbpl);

   358             s = (const quint16 *)(((const uchar *) s) + sbpl);

   359         }

   360     }

   361 }

   362 

   363 

   364 template <typename T> void qt_blend_argb24_on_rgb16(uchar *destPixels, int dbpl,

   365                                                     const uchar *srcPixels, int sbpl,

   366                                                     int w, int h, const T &alphaFunc)

   367 {

   368     int srcOffset = w*3;

   369     int dstJPL = dbpl / 2;

   370     quint16 *dst = (quint16 *) destPixels;

   371     int dstExtraStride = dstJPL - w;

   372 

   373     for (int y=0; y<h; ++y) {

   374         const uchar *src = srcPixels + y * sbpl;

   375         const uchar *srcEnd = src + srcOffset;

   376         while (src < srcEnd) {

   377 #if defined(QT_ARCH_ARM) || defined(QT_ARCH_POWERPC) || defined(QT_ARCH_SH) || defined(QT_ARCH_AVR32) || (defined(QT_ARCH_WINDOWSCE) && !defined(_X86_)) || (defined(QT_ARCH_SPARC) && defined(Q_CC_GNU))

   378             // non-16-bit aligned memory access is not possible on PowerPC,

   379             // ARM <v6 (QT_ARCH_ARMV6) & SH & AVR32 & SPARC w/GCC

   380             quint16 spix = (quint16(src[2])<<8) + src[1];

   381 #else

   382             quint16 spix = *(quint16 *) (src + 1);

   383 #endif

   384             uchar alpha = alphaFunc.alpha(*src);

   385 

   386             if (alpha == 255) {

   387                 *dst = spix;

   388             } else if (alpha != 0) {

   389                 quint16 dpix = *dst;

   390                 quint32 sia = 255 - alpha;

   391 

   392                 quint16 dr = (dpix & 0x0000f800);

   393                 quint16 dg = (dpix & 0x000007e0);

   394                 quint16 db = (dpix & 0x0000001f);

   395 

   396                 quint32 siar = dr * sia;

   397                 quint32 siag = dg * sia;

   398                 quint32 siab = db * sia;

   399 

   400                 quint32 rr = ((siar + (siar>>8) + (0x80 <<  8)) >> 8) & 0xf800;

   401                 quint32 rg = ((siag + (siag>>8) + (0x80 <<  3)) >> 8) & 0x07e0;

   402                 quint32 rb = ((siab + (siab>>8) + (0x80 >>  3)) >> 8) & 0x001f;

   403 

   404                 *dst = alphaFunc.bytemul(spix) + rr + rg + rb;

   405             }

   406 

   407             ++dst;

   408             src += 3;

   409         }

   410         dst += dstExtraStride;

   411     }

   412 

   413 }

   414 

   415 static void qt_blend_argb24_on_rgb16(uchar *destPixels, int dbpl,

   416                                      const uchar *srcPixels, int sbpl,

   417                                      int w, int h,

   418                                      int const_alpha)

   419 {

   420 #ifdef QT_DEBUG_DRAW

   421     printf("qt_blend_argb24_on_rgb16: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",

   422            destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);

   423 #endif

   424 

   425     if (const_alpha != 256) {

   426         SourceAndConstAlpha alphaFunc(const_alpha);

   427         qt_blend_argb24_on_rgb16(destPixels, dbpl, srcPixels, sbpl, w, h, alphaFunc);

   428     } else {

   429         SourceOnlyAlpha alphaFunc;

   430         qt_blend_argb24_on_rgb16(destPixels, dbpl, srcPixels, sbpl, w, h, alphaFunc);

   431     }

   432 }

   433 

   434 

   435 

   436 

   437 static void qt_blend_argb32_on_rgb16_const_alpha(uchar *destPixels, int dbpl,

   438                                                  const uchar *srcPixels, int sbpl,

   439                                                  int w, int h,

   440                                                  int const_alpha)

   441 {

   442     quint16 *dst = (quint16 *) destPixels;

   443     const quint32 *src = (const quint32 *) srcPixels;

   444 

   445     const_alpha = (const_alpha * 255) >> 8;

   446     for (int y=0; y<h; ++y) {

   447         for (int i = 0; i < w; ++i) {

   448             uint s = src[i];

   449             s = BYTE_MUL(s, const_alpha);

   450             int alpha = qAlpha(s);

   451             s = convert_argb32_to_rgb16(s);

   452             s += BYTE_MUL_RGB16(dst[i], 255 - alpha);

   453             dst[i] = s;

   454         }

   455         dst = (quint16 *)(((uchar *) dst) + dbpl);

   456         src = (const quint32 *)(((const uchar *) src) + sbpl);

   457     }

   458 }

   459 

   460 static void qt_blend_argb32_on_rgb16(uchar *destPixels, int dbpl,

   461                                      const uchar *srcPixels, int sbpl,

   462                                      int w, int h,

   463                                      int const_alpha)

   464 {

   465     if (const_alpha != 256) {

   466         qt_blend_argb32_on_rgb16_const_alpha(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);

   467         return;

   468     }

   469 

   470     quint16 *dst = (quint16 *) destPixels;

   471     quint32 *src = (quint32 *) srcPixels;

   472 

   473     for (int y=0; y<h; ++y) {

   474         for (int x=0; x<w; ++x) {

   475 

   476             quint32 spix = src[x];

   477             quint32 alpha = spix >> 24;

   478 

   479             if (alpha == 255) {

   480                 dst[x] = convert_argb32_to_rgb16(spix);

   481             } else if (alpha != 0) {

   482                 quint32 dpix = dst[x];

   483 

   484                 quint32 sia = 255 - alpha;

   485 

   486                 quint32 sr = (spix >> 8) & 0xf800;

   487                 quint32 sg = (spix >> 5) & 0x07e0;

   488                 quint32 sb = (spix >> 3) & 0x001f;

   489 

   490                 quint32 dr = (dpix & 0x0000f800);

   491                 quint32 dg = (dpix & 0x000007e0);

   492                 quint32 db = (dpix & 0x0000001f);

   493 

   494                 quint32 siar = dr * sia;

   495                 quint32 siag = dg * sia;

   496                 quint32 siab = db * sia;

   497 

   498                 quint32 rr = sr + ((siar + (siar>>8) + (0x80 << 8)) >> 8);

   499                 quint32 rg = sg + ((siag + (siag>>8) + (0x80 << 3)) >> 8);

   500                 quint32 rb = sb + ((siab + (siab>>8) + (0x80 >> 3)) >> 8);

   501 

   502                 dst[x] = (rr & 0xf800)

   503                          | (rg & 0x07e0)

   504                          | (rb);

   505             }

   506         }

   507         dst = (quint16 *) (((uchar *) dst) + dbpl);

   508         src = (quint32 *) (((uchar *) src) + sbpl);

   509     }

   510 }

   511 

   512 

   513 static void qt_blend_rgb32_on_rgb16(uchar *destPixels, int dbpl,

   514                                     const uchar *srcPixels, int sbpl,

   515                                     int w, int h,

   516                                     int const_alpha)

   517 {

   518 #ifdef QT_DEBUG_DRAW

   519     printf("qt_blend_rgb32_on_rgb16: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",

   520            destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);

   521 #endif

   522 

   523     if (const_alpha != 256) {

   524         qt_blend_argb32_on_rgb16(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);

   525         return;

   526     }

   527 

   528     const quint32 *src = (const quint32 *) srcPixels;

   529     int srcExtraStride = (sbpl >> 2) - w;

   530 

   531     int dstJPL = dbpl / 2;

   532 

   533     quint16 *dst = (quint16 *) destPixels;

   534     quint16 *dstEnd = dst + dstJPL * h;

   535 

   536     int dstExtraStride = dstJPL - w;

   537 

   538     while (dst < dstEnd) {

   539         const quint32 *srcEnd = src + w;

   540         while (src < srcEnd) {

   541             *dst = convert_argb32_to_rgb16(*src);

   542             ++dst;

   543             ++src;

   544         }

   545         dst += dstExtraStride;

   546         src += srcExtraStride;

   547     }

   548 }

   549 

   550 

   551 

   552 /************************************************************************

   553                        RGB32 (-888) format target format

   554  ************************************************************************/

   555 

   556 static void qt_blend_argb32_on_argb32(uchar *destPixels, int dbpl,

   557                                       const uchar *srcPixels, int sbpl,

   558                                       int w, int h,

   559                                       int const_alpha)

   560 {

   561 #ifdef QT_DEBUG_DRAW

   562     fprintf(stdout, "qt_blend_argb32_on_argb32: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",

   563             destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);

   564     fflush(stdout);

   565 #endif

   566 

   567     const uint *src = (const uint *) srcPixels;

   568     uint *dst = (uint *) destPixels;

   569     if (const_alpha == 256) {

   570         for (int y=0; y<h; ++y) {

   571             for (int x=0; x<w; ++x) {

   572                 uint s = src[x];

   573                 if (s >= 0xff000000)

   574                     dst[x] = s;

   575                 else if (s != 0)

   576                     dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s));

   577             }

   578             dst = (quint32 *)(((uchar *) dst) + dbpl);

   579             src = (const quint32 *)(((const uchar *) src) + sbpl);

   580         }

   581     } else if (const_alpha != 0) {

   582         const_alpha = (const_alpha * 255) >> 8;

   583         for (int y=0; y<h; ++y) {

   584             for (int x=0; x<w; ++x) {

   585                 uint s = BYTE_MUL(src[x], const_alpha);

   586                 dst[x] = s + BYTE_MUL(dst[x], qAlpha(~s));

   587             }

   588             dst = (quint32 *)(((uchar *) dst) + dbpl);

   589             src = (const quint32 *)(((const uchar *) src) + sbpl);

   590         }

   591     }

   592 }

   593 

   594 

   595 static void qt_blend_rgb32_on_rgb32(uchar *destPixels, int dbpl,

   596                              const uchar *srcPixels, int sbpl,

   597                              int w, int h,

   598                              int const_alpha)

   599 {

   600 #ifdef QT_DEBUG_DRAW

   601     fprintf(stdout, "qt_blend_rgb32_on_rgb32: dst=(%p, %d), src=(%p, %d), dim=(%d, %d) alpha=%d\n",

   602             destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);

   603     fflush(stdout);

   604 #endif

   605 

   606     if (const_alpha != 256) {

   607         qt_blend_argb32_on_argb32(destPixels, dbpl, srcPixels, sbpl, w, h, const_alpha);

   608         return;

   609     }

   610 

   611     const uint *src = (const uint *) srcPixels;

   612     uint *dst = (uint *) destPixels;

   613     if (w <= 64) {

   614         for (int y=0; y<h; ++y) {

   615             qt_memconvert(dst, src, w);

   616             dst = (quint32 *)(((uchar *) dst) + dbpl);

   617             src = (const quint32 *)(((const uchar *) src) + sbpl);

   618         }

   619     } else {

   620         int len = w * 4;

   621         for (int y=0; y<h; ++y) {

   622             memcpy(dst, src, len);

   623             dst = (quint32 *)(((uchar *) dst) + dbpl);

   624             src = (const quint32 *)(((const uchar *) src) + sbpl);

   625         }

   626     }

   627 }

   628 

   629 

   630 

   631 struct Blend_RGB32_on_RGB32_NoAlpha {

   632     inline void write(quint32 *dst, quint32 src) { *dst = src; }

   633 };

   634 

   635 struct Blend_RGB32_on_RGB32_ConstAlpha {

   636     inline Blend_RGB32_on_RGB32_ConstAlpha(quint32 alpha) {

   637         m_alpha = (alpha * 255) >> 8;

   638         m_ialpha = 255 - m_alpha;

   639     }

   640 

   641     inline void write(quint32 *dst, quint32 src) {

   642         *dst = BYTE_MUL(src, m_alpha) + BYTE_MUL(*dst, m_ialpha);

   643     }

   644 

   645     quint32 m_alpha;

   646     quint32 m_ialpha;

   647 };

   648 

   649 struct Blend_ARGB32_on_ARGB32_SourceAlpha {

   650     inline void write(quint32 *dst, quint32 src) {

   651         *dst = src + BYTE_MUL(*dst, qAlpha(~src));

   652     }

   653 };

   654 

   655 struct Blend_ARGB32_on_ARGB32_SourceAndConstAlpha {

   656     inline Blend_ARGB32_on_ARGB32_SourceAndConstAlpha(quint32 alpha) {

   657         m_alpha = (alpha * 255) >> 8;

   658         m_ialpha = 255 - m_alpha;

   659     }

   660 

   661     inline void write(quint32 *dst, quint32 src) {

   662         src = BYTE_MUL(src, m_alpha);

   663         *dst = src + BYTE_MUL(*dst, qAlpha(~src));

   664     }

   665 

   666     quint32 m_alpha;

   667     quint32 m_ialpha;

   668 };

   669 

   670 template <typename T> void qt_scale_image_32bit(uchar *destPixels, int dbpl,

   671                                                 const uchar *srcPixels, int sbpl,

   672                                                 const QRectF &targetRect,

   673                                                 const QRectF &srcRect,

   674                                                 const QRect &clip,

   675                                                 T blender)

   676 {

   677     qreal sx = targetRect.width() / (qreal) srcRect.width();

   678     qreal sy = targetRect.height() / (qreal) srcRect.height();

   679 

   680     int ix = 0x00010000 / sx;

   681     int iy = 0x00010000 / sy;

   682 

   683 //     qDebug() << "scale:" << endl

   684 //              << " - target" << targetRect << endl

   685 //              << " - source" << srcRect << endl

   686 //              << " - clip" << clip << endl

   687 //              << " - sx=" << sx << " sy=" << sy << " ix=" << ix << " iy=" << iy;

   688 

   689     int cx1 = clip.x();

   690     int cx2 = clip.x() + clip.width();

   691     int cy1 = clip.top();

   692     int cy2 = clip.y() + clip.height();

   693 

   694     int tx1 = qRound(targetRect.left());

   695     int tx2 = qRound(targetRect.right());

   696     int ty1 = qRound(targetRect.top());

   697     int ty2 = qRound(targetRect.bottom());

   698 

   699     if (tx2 < tx1)

   700         qSwap(tx2, tx1);

   701 

   702     if (ty2 < ty1)

   703         qSwap(ty2, ty1);

   704 

   705     if (tx1 < cx1)

   706         tx1 = cx1;

   707 

   708     if (tx2 >= cx2)

   709         tx2 = cx2;

   710 

   711     if (tx1 >= tx2)

   712         return;

   713 

   714     if (ty1 < cy1)

   715         ty1 = cy1;

   716 

   717     if (ty2 >= cy2)

   718        ty2 = cy2;

   719 

   720     if (ty1 >= ty2)

   721         return;

   722 

   723     int h = ty2 - ty1;

   724     int w = tx2 - tx1;

   725 

   726     const int dstx = qCeil((tx1 + 0.5 - qMin(targetRect.left(), targetRect.right())) * ix) - 1;

   727     const int dsty = qCeil((ty1 + 0.5 - qMin(targetRect.top(), targetRect.bottom())) * iy) - 1;

   728 

   729     quint32 basex = quint32((sx < 0 ? srcRect.right() : srcRect.left()) * 65536) + dstx;

   730     quint32 srcy = quint32((sy < 0 ? srcRect.bottom() : srcRect.top()) * 65536) + dsty;

   731 

   732     quint32 *dst = ((quint32 *) (destPixels + ty1 * dbpl)) + tx1;

   733 

   734     while (h--) {

   735         const uint *src = (const quint32 *) (srcPixels + (srcy >> 16) * sbpl);

   736         int srcx = basex;

   737         for (int x=0; x<w; ++x) {

   738             blender.write(&dst[x], src[srcx >> 16]);

   739             srcx += ix;

   740         }

   741         dst = (quint32 *)(((uchar *) dst) + dbpl);

   742         srcy += iy;

   743     }

   744 }

   745 

   746 void qt_scale_image_rgb32_on_rgb32(uchar *destPixels, int dbpl,

   747                                    const uchar *srcPixels, int sbpl,

   748                                    const QRectF &targetRect,

   749                                    const QRectF &sourceRect,

   750                                    const QRect &clip,

   751                                    int const_alpha)

   752 {

   753 #ifdef QT_DEBUG_DRAW

   754     printf("qt_scale_rgb32_on_rgb32: dst=(%p, %d), src=(%p, %d), target=(%d, %d), [%d x %d], src=(%d, %d) [%d x %d] alpha=%d\n",

   755            destPixels, dbpl, srcPixels, sbpl,

   756            targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(),

   757            sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height(),

   758            const_alpha);

   759 #endif

   760     if (const_alpha == 256) {

   761         Blend_RGB32_on_RGB32_NoAlpha noAlpha;

   762         qt_scale_image_32bit(destPixels, dbpl, srcPixels, sbpl,

   763                              targetRect, sourceRect, clip, noAlpha);

   764     } else {

   765         Blend_RGB32_on_RGB32_ConstAlpha constAlpha(const_alpha);

   766         qt_scale_image_32bit(destPixels, dbpl, srcPixels, sbpl,

   767                              targetRect, sourceRect, clip, constAlpha);

   768     }

   769 }

   770 

   771 void qt_scale_image_argb32_on_argb32(uchar *destPixels, int dbpl,

   772                                      const uchar *srcPixels, int sbpl,

   773                                      const QRectF &targetRect,

   774                                      const QRectF &sourceRect,

   775                                      const QRect &clip,

   776                                      int const_alpha)

   777 {

   778 #ifdef QT_DEBUG_DRAW

   779     printf("qt_scale_argb32_on_argb32: dst=(%p, %d), src=(%p, %d), target=(%d, %d), [%d x %d], src=(%d, %d) [%d x %d] alpha=%d\n",

   780            destPixels, dbpl, srcPixels, sbpl,

   781            targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height(),

   782            sourceRect.x(), sourceRect.y(), sourceRect.width(), sourceRect.height(),

   783            const_alpha);

   784 #endif

   785     if (const_alpha == 256) {

   786         Blend_ARGB32_on_ARGB32_SourceAlpha sourceAlpha;

   787         qt_scale_image_32bit(destPixels, dbpl, srcPixels, sbpl,

   788                              targetRect, sourceRect, clip, sourceAlpha);

   789     } else {

   790         Blend_ARGB32_on_ARGB32_SourceAndConstAlpha constAlpha(const_alpha);

   791         qt_scale_image_32bit(destPixels, dbpl, srcPixels, sbpl,

   792                              targetRect, sourceRect, clip, constAlpha);

   793     }

   794 }

   795 

   796 struct QTransformImageVertex

   797 {

   798     qreal x, y, u, v; // destination coordinates (x, y) and source coordinates (u, v)

   799 };

   800 

   801 template <class SrcT, class DestT, class Blender>

   802 void qt_transform_image_rasterize(DestT *destPixels, int dbpl,

   803                                   const SrcT *srcPixels, int sbpl,

   804                                   const QTransformImageVertex &topLeft, const QTransformImageVertex &bottomLeft,

   805                                   const QTransformImageVertex &topRight, const QTransformImageVertex &bottomRight,

   806                                   const QRect &sourceRect,

   807                                   const QRect &clip,

   808                                   qreal topY, qreal bottomY,

   809                                   int dudx, int dvdx, int dudy, int dvdy, int u0, int v0,

   810                                   Blender blender)

   811 {

   812     int fromY = qMax(qRound(topY), clip.top());

   813     int toY = qMin(qRound(bottomY), clip.top() + clip.height());

   814     if (fromY >= toY)

   815         return;

   816 

   817     qreal leftSlope = (bottomLeft.x - topLeft.x) / (bottomLeft.y - topLeft.y);

   818     qreal rightSlope = (bottomRight.x - topRight.x) / (bottomRight.y - topRight.y);

   819     int dx_l = int(leftSlope * 0x10000);

   820     int dx_r = int(rightSlope * 0x10000);

   821     int x_l = int((topLeft.x + (0.5 + fromY - topLeft.y) * leftSlope + 0.5) * 0x10000);

   822     int x_r = int((topRight.x + (0.5 + fromY - topRight.y) * rightSlope + 0.5) * 0x10000);

   823 

   824     int fromX, toX, x1, x2, u, v, i, ii;

   825     DestT *line;

   826     for (int y = fromY; y < toY; ++y) {

   827         line = reinterpret_cast<DestT *>(reinterpret_cast<uchar *>(destPixels) + y * dbpl);

   828 

   829         fromX = qMax(x_l >> 16, clip.left());

   830         toX = qMin(x_r >> 16, clip.left() + clip.width());

   831         if (fromX < toX) {

   832             // Because of rounding, we can get source coordinates outside the source image.

   833             // Clamp these coordinates to the source rect to avoid segmentation fault and

   834             // garbage on the screen.

   835 

   836             // Find the first pixel on the current scan line where the source coordinates are within the source rect.

   837             x1 = fromX;

   838             u = x1 * dudx + y * dudy + u0;

   839             v = x1 * dvdx + y * dvdy + v0;

   840             for (; x1 < toX; ++x1) {

   841                 int uu = u >> 16;

   842                 int vv = v >> 16;

   843                 if (uu >= sourceRect.left() && uu < sourceRect.left() + sourceRect.width()

   844                     && vv >= sourceRect.top() && vv < sourceRect.top() + sourceRect.height()) {

   845                     break;

   846                 }

   847                 u += dudx;

   848                 v += dvdx;

   849             }

   850 

   851             // Find the last pixel on the current scan line where the source coordinates are within the source rect.

   852             x2 = toX;

   853             u = (x2 - 1) * dudx + y * dudy + u0;

   854             v = (x2 - 1) * dvdx + y * dvdy + v0;

   855             for (; x2 > x1; --x2) {

   856                 int uu = u >> 16;

   857                 int vv = v >> 16;

   858                 if (uu >= sourceRect.left() && uu < sourceRect.left() + sourceRect.width()

   859                     && vv >= sourceRect.top() && vv < sourceRect.top() + sourceRect.height()) {

   860                     break;

   861                 }

   862                 u -= dudx;

   863                 v -= dvdx;

   864             }

   865 

   866             // Set up values at the beginning of the scan line.

   867             u = fromX * dudx + y * dudy + u0;

   868             v = fromX * dvdx + y * dvdy + v0;

   869             line += fromX;

   870 

   871             // Beginning of the scan line, with per-pixel checks.

   872             i = x1 - fromX;

   873             while (i) {

   874                 int uu = qBound(sourceRect.left(), u >> 16, sourceRect.left() + sourceRect.width() - 1);

   875                 int vv = qBound(sourceRect.top(), v >> 16, sourceRect.top() + sourceRect.height() - 1);

   876                 blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + vv * sbpl)[uu]);

   877                 u += dudx;

   878                 v += dvdx;

   879                 ++line;

   880                 --i;

   881             }

   882 

   883             // Middle of the scan line, without checks.

   884             // Manual loop unrolling.

   885             i = x2 - x1;

   886             ii = i >> 3;

   887             while (ii) {

   888                 blender.write(&line[0], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;

   889                 blender.write(&line[1], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;

   890                 blender.write(&line[2], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;

   891                 blender.write(&line[3], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;

   892                 blender.write(&line[4], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;

   893                 blender.write(&line[5], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;

   894                 blender.write(&line[6], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;

   895                 blender.write(&line[7], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;

   896                 line += 8;

   897                 --ii;

   898             }

   899             switch (i & 7) {

   900                 case 7: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;

   901                 case 6: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;

   902                 case 5: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;

   903                 case 4: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;

   904                 case 3: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;

   905                 case 2: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;

   906                 case 1: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;

   907             }

   908 

   909             // End of the scan line, with per-pixel checks.

   910             i = toX - x2;

   911             while (i) {

   912                 int uu = qBound(sourceRect.left(), u >> 16, sourceRect.left() + sourceRect.width() - 1);

   913                 int vv = qBound(sourceRect.top(), v >> 16, sourceRect.top() + sourceRect.height() - 1);

   914                 blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + vv * sbpl)[uu]);

   915                 u += dudx;

   916                 v += dvdx;

   917                 ++line;

   918                 --i;

   919             }

   920         }

   921         x_l += dx_l;

   922         x_r += dx_r;

   923     }

   924 }

   925 

   926 template <class SrcT, class DestT, class Blender>

   927 void qt_transform_image(DestT *destPixels, int dbpl,

   928                         const SrcT *srcPixels, int sbpl,

   929                         const QRectF &targetRect,

   930                         const QRectF &sourceRect,

   931                         const QRect &clip,

   932                         const QTransform &targetRectTransform,

   933                         Blender blender)

   934 {

   935     enum Corner

   936     {

   937         TopLeft,

   938         TopRight,

   939         BottomRight,

   940         BottomLeft

   941     };

   942 

   943     // map source rectangle to destination.

   944     QTransformImageVertex v[4];

   945     v[TopLeft].u = v[BottomLeft].u = sourceRect.left();

   946     v[TopLeft].v = v[TopRight].v = sourceRect.top();

   947     v[TopRight].u = v[BottomRight].u = sourceRect.right();

   948     v[BottomLeft].v = v[BottomRight].v = sourceRect.bottom();

   949     targetRectTransform.map(targetRect.left(), targetRect.top(), &v[TopLeft].x, &v[TopLeft].y);

   950     targetRectTransform.map(targetRect.right(), targetRect.top(), &v[TopRight].x, &v[TopRight].y);

   951     targetRectTransform.map(targetRect.left(), targetRect.bottom(), &v[BottomLeft].x, &v[BottomLeft].y);

   952     targetRectTransform.map(targetRect.right(), targetRect.bottom(), &v[BottomRight].x, &v[BottomRight].y);

   953 

   954     // find topmost vertex.

   955     int topmost = 0;

   956     for (int i = 1; i < 4; ++i) {

   957         if (v[i].y < v[topmost].y)

   958             topmost = i;

   959     }

   960     // rearrange array such that topmost vertex is at index 0.

   961     switch (topmost) {

   962     case 1:

   963         {

   964             QTransformImageVertex t = v[0];

   965             for (int i = 0; i < 3; ++i)

   966                 v[i] = v[i+1];

   967             v[3] = t;

   968         }

   969         break;

   970     case 2:

   971         qSwap(v[0], v[2]);

   972         qSwap(v[1], v[3]);

   973         break;

   974     case 3:

   975         {

   976             QTransformImageVertex t = v[3];

   977             for (int i = 3; i > 0; --i)

   978                 v[i] = v[i-1];

   979             v[0] = t;

   980         }

   981         break;

   982     }

   983 

   984     // if necessary, swap vertex 1 and 3 such that 1 is to the left of 3.

   985     qreal dx1 = v[1].x - v[0].x;

   986     qreal dy1 = v[1].y - v[0].y;

   987     qreal dx2 = v[3].x - v[0].x;

   988     qreal dy2 = v[3].y - v[0].y;

   989     if (dx1 * dy2 - dx2 * dy1 > 0)

   990         qSwap(v[1], v[3]);

   991 

   992     QTransformImageVertex u = {v[1].x - v[0].x, v[1].y - v[0].y, v[1].u - v[0].u, v[1].v - v[0].v};

   993     QTransformImageVertex w = {v[2].x - v[0].x, v[2].y - v[0].y, v[2].u - v[0].u, v[2].v - v[0].v};

   994 

   995     qreal det = u.x * w.y - u.y * w.x;

   996     if (det == 0)

   997         return;

   998 

   999     qreal invDet = 1.0 / det;

  1000     qreal m11, m12, m21, m22, mdx, mdy;

  1001 

  1002     m11 = (u.u * w.y - u.y * w.u) * invDet;

  1003     m12 = (u.x * w.u - u.u * w.x) * invDet;

  1004     m21 = (u.v * w.y - u.y * w.v) * invDet;

  1005     m22 = (u.x * w.v - u.v * w.x) * invDet;

  1006     mdx = v[0].u - m11 * v[0].x - m12 * v[0].y;

  1007     mdy = v[0].v - m21 * v[0].x - m22 * v[0].y;

  1008 

  1009     int dudx = int(m11 * 0x10000);

  1010     int dvdx = int(m21 * 0x10000);

  1011     int dudy = int(m12 * 0x10000);

  1012     int dvdy = int(m22 * 0x10000);

  1013     int u0 = qCeil((0.5 * m11 + 0.5 * m12 + mdx) * 0x10000) - 1;

  1014     int v0 = qCeil((0.5 * m21 + 0.5 * m22 + mdy) * 0x10000) - 1;

  1015 

  1016     int x1 = qFloor(sourceRect.left());

  1017     int y1 = qFloor(sourceRect.top());

  1018     int x2 = qCeil(sourceRect.right());

  1019     int y2 = qCeil(sourceRect.bottom());

  1020     QRect sourceRectI(x1, y1, x2 - x1, y2 - y1);

  1021 

  1022     // rasterize trapezoids.

  1023     if (v[1].y < v[3].y) {

  1024         qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[0], v[1], v[0], v[3], sourceRectI, clip, v[0].y, v[1].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);

  1025         qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[1], v[2], v[0], v[3], sourceRectI, clip, v[1].y, v[3].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);

  1026         qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[1], v[2], v[3], v[2], sourceRectI, clip, v[3].y, v[2].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);

  1027     } else {

  1028         qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[0], v[1], v[0], v[3], sourceRectI, clip, v[0].y, v[3].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);

  1029         qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[0], v[1], v[3], v[2], sourceRectI, clip, v[3].y, v[1].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);

  1030         qt_transform_image_rasterize(destPixels, dbpl, srcPixels, sbpl, v[1], v[2], v[3], v[2], sourceRectI, clip, v[1].y, v[2].y, dudx, dvdx, dudy, dvdy, u0, v0, blender);

  1031     }

  1032 }

  1033 

  1034 void qt_transform_image_rgb16_on_rgb16(uchar *destPixels, int dbpl,

  1035                                        const uchar *srcPixels, int sbpl,

  1036                                        const QRectF &targetRect,

  1037                                        const QRectF &sourceRect,

  1038                                        const QRect &clip,

  1039                                        const QTransform &targetRectTransform,

  1040                                        int const_alpha)

  1041 {

  1042     if (const_alpha == 256) {

  1043         Blend_RGB16_on_RGB16_NoAlpha noAlpha;

  1044         qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,

  1045                            reinterpret_cast<const quint16 *>(srcPixels), sbpl,

  1046                            targetRect, sourceRect, clip, targetRectTransform, noAlpha);

  1047     } else {

  1048         Blend_RGB16_on_RGB16_ConstAlpha constAlpha(const_alpha);

  1049         qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,

  1050                            reinterpret_cast<const quint16 *>(srcPixels), sbpl,

  1051                            targetRect, sourceRect, clip, targetRectTransform, constAlpha);

  1052     }

  1053 }

  1054 

  1055 void qt_transform_image_argb24_on_rgb16(uchar *destPixels, int dbpl,

  1056                                         const uchar *srcPixels, int sbpl,

  1057                                         const QRectF &targetRect,

  1058                                         const QRectF &sourceRect,

  1059                                         const QRect &clip,

  1060                                         const QTransform &targetRectTransform,

  1061                                         int const_alpha)

  1062 {

  1063     if (const_alpha == 256) {

  1064         Blend_ARGB24_on_RGB16_SourceAlpha noAlpha;

  1065         qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,

  1066                            reinterpret_cast<const qargb8565 *>(srcPixels), sbpl,

  1067                            targetRect, sourceRect, clip, targetRectTransform, noAlpha);

  1068     } else {

  1069         Blend_ARGB24_on_RGB16_SourceAndConstAlpha constAlpha(const_alpha);

  1070         qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,

  1071                            reinterpret_cast<const qargb8565 *>(srcPixels), sbpl,

  1072                            targetRect, sourceRect, clip, targetRectTransform, constAlpha);

  1073     }

  1074 }

  1075 

  1076 

  1077 void qt_transform_image_argb32_on_rgb16(uchar *destPixels, int dbpl,

  1078                                         const uchar *srcPixels, int sbpl,

  1079                                         const QRectF &targetRect,

  1080                                         const QRectF &sourceRect,

  1081                                         const QRect &clip,

  1082                                         const QTransform &targetRectTransform,

  1083                                         int const_alpha)

  1084 {

  1085     if (const_alpha == 256) {

  1086         Blend_ARGB32_on_RGB16_SourceAlpha noAlpha;

  1087         qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,

  1088                            reinterpret_cast<const quint32 *>(srcPixels), sbpl,

  1089                            targetRect, sourceRect, clip, targetRectTransform, noAlpha);

  1090     } else {

  1091         Blend_ARGB32_on_RGB16_SourceAndConstAlpha constAlpha(const_alpha);

  1092         qt_transform_image(reinterpret_cast<quint16 *>(destPixels), dbpl,

  1093                            reinterpret_cast<const quint32 *>(srcPixels), sbpl,

  1094                            targetRect, sourceRect, clip, targetRectTransform, constAlpha);

  1095     }

  1096 }

  1097 

  1098 

  1099 void qt_transform_image_rgb32_on_rgb32(uchar *destPixels, int dbpl,

  1100                                        const uchar *srcPixels, int sbpl,

  1101                                        const QRectF &targetRect,

  1102                                        const QRectF &sourceRect,

  1103                                        const QRect &clip,

  1104                                        const QTransform &targetRectTransform,

  1105                                        int const_alpha)

  1106 {

  1107     if (const_alpha == 256) {

  1108         Blend_RGB32_on_RGB32_NoAlpha noAlpha;

  1109         qt_transform_image(reinterpret_cast<quint32 *>(destPixels), dbpl,

  1110                            reinterpret_cast<const quint32 *>(srcPixels), sbpl,

  1111                            targetRect, sourceRect, clip, targetRectTransform, noAlpha);

  1112     } else {

  1113         Blend_RGB32_on_RGB32_ConstAlpha constAlpha(const_alpha);

  1114         qt_transform_image(reinterpret_cast<quint32 *>(destPixels), dbpl,

  1115                            reinterpret_cast<const quint32 *>(srcPixels), sbpl,

  1116                            targetRect, sourceRect, clip, targetRectTransform, constAlpha);

  1117     }

  1118 }

  1119 

  1120 void qt_transform_image_argb32_on_argb32(uchar *destPixels, int dbpl,

  1121                                          const uchar *srcPixels, int sbpl,

  1122                                          const QRectF &targetRect,

  1123                                          const QRectF &sourceRect,

  1124                                          const QRect &clip,

  1125                                          const QTransform &targetRectTransform,

  1126                                          int const_alpha)

  1127 {

  1128     if (const_alpha == 256) {

  1129         Blend_ARGB32_on_ARGB32_SourceAlpha sourceAlpha;

  1130         qt_transform_image(reinterpret_cast<quint32 *>(destPixels), dbpl,

  1131                            reinterpret_cast<const quint32 *>(srcPixels), sbpl,

  1132                            targetRect, sourceRect, clip, targetRectTransform, sourceAlpha);

  1133     } else {

  1134         Blend_ARGB32_on_ARGB32_SourceAndConstAlpha constAlpha(const_alpha);