src/gui/painting/qblendfunctions_p.h
changeset 30 5dc02b23752f
equal deleted inserted replaced
29:b72c6db6890b 30:5dc02b23752f
       
     1 /****************************************************************************
       
     2 **
       
     3 ** Copyright (C) 2010 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 #ifndef QBLENDFUNCTIONS_P_H
       
    43 #define QBLENDFUNCTIONS_P_H
       
    44 
       
    45 #include <qmath.h>
       
    46 #include "qdrawhelper_p.h"
       
    47 
       
    48 QT_BEGIN_NAMESPACE
       
    49 
       
    50 //
       
    51 //  W A R N I N G
       
    52 //  -------------
       
    53 //
       
    54 // This file is not part of the Qt API.  It exists purely as an
       
    55 // implementation detail.  This header file may change from version to
       
    56 // version without notice, or even be removed.
       
    57 //
       
    58 // We mean it.
       
    59 //
       
    60 
       
    61 template <typename SRC, typename T>
       
    62 void qt_scale_image_16bit(uchar *destPixels, int dbpl,
       
    63                           const uchar *srcPixels, int sbpl,
       
    64                           const QRectF &targetRect,
       
    65                           const QRectF &srcRect,
       
    66                           const QRect &clip,
       
    67                           T blender)
       
    68 {
       
    69     qreal sx = targetRect.width() / (qreal) srcRect.width();
       
    70     qreal sy = targetRect.height() / (qreal) srcRect.height();
       
    71 
       
    72     int ix = 0x00010000 / sx;
       
    73     int iy = 0x00010000 / sy;
       
    74 
       
    75 //     qDebug() << "scale:" << endl
       
    76 //              << " - target" << targetRect << endl
       
    77 //              << " - source" << srcRect << endl
       
    78 //              << " - clip" << clip << endl
       
    79 //              << " - sx=" << sx << " sy=" << sy << " ix=" << ix << " iy=" << iy;
       
    80 
       
    81     int cx1 = clip.x();
       
    82     int cx2 = clip.x() + clip.width();
       
    83     int cy1 = clip.top();
       
    84     int cy2 = clip.y() + clip.height();
       
    85 
       
    86     int tx1 = qRound(targetRect.left());
       
    87     int tx2 = qRound(targetRect.right());
       
    88     int ty1 = qRound(targetRect.top());
       
    89     int ty2 = qRound(targetRect.bottom());
       
    90 
       
    91     if (tx2 < tx1)
       
    92         qSwap(tx2, tx1);
       
    93 
       
    94     if (ty2 < ty1)
       
    95         qSwap(ty2, ty1);
       
    96 
       
    97     if (tx1 < cx1)
       
    98         tx1 = cx1;
       
    99 
       
   100     if (tx2 >= cx2)
       
   101         tx2 = cx2;
       
   102 
       
   103     if (tx1 >= tx2)
       
   104         return;
       
   105 
       
   106     if (ty1 < cy1)
       
   107         ty1 = cy1;
       
   108 
       
   109     if (ty2 >= cy2)
       
   110        ty2 = cy2;
       
   111 
       
   112     if (ty1 >= ty2)
       
   113         return;
       
   114 
       
   115     int h = ty2 - ty1;
       
   116     int w = tx2 - tx1;
       
   117 
       
   118 
       
   119     quint32 basex;
       
   120     quint32 srcy;
       
   121 
       
   122     if (sx < 0) {
       
   123         int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1;
       
   124         basex = quint32(srcRect.right() * 65536) + dstx;
       
   125     } else {
       
   126         int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * ix) - 1;
       
   127         basex = quint32(srcRect.left() * 65536) + dstx;
       
   128     }
       
   129     if (sy < 0) {
       
   130         int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * iy) + 1;
       
   131         srcy = quint32(srcRect.bottom() * 65536) + dsty;
       
   132     } else {
       
   133         int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * iy) - 1;
       
   134         srcy = quint32(srcRect.top() * 65536) + dsty;
       
   135     }
       
   136 
       
   137     quint16 *dst = ((quint16 *) (destPixels + ty1 * dbpl)) + tx1;
       
   138 
       
   139     while (h--) {
       
   140         const SRC *src = (const SRC *) (srcPixels + (srcy >> 16) * sbpl);
       
   141         int srcx = basex;
       
   142         int x = 0;
       
   143         for (; x<w-7; x+=8) {
       
   144             blender.write(&dst[x], src[srcx >> 16]); srcx += ix;
       
   145             blender.write(&dst[x+1], src[srcx >> 16]); srcx += ix;
       
   146             blender.write(&dst[x+2], src[srcx >> 16]); srcx += ix;
       
   147             blender.write(&dst[x+3], src[srcx >> 16]); srcx += ix;
       
   148             blender.write(&dst[x+4], src[srcx >> 16]); srcx += ix;
       
   149             blender.write(&dst[x+5], src[srcx >> 16]); srcx += ix;
       
   150             blender.write(&dst[x+6], src[srcx >> 16]); srcx += ix;
       
   151             blender.write(&dst[x+7], src[srcx >> 16]); srcx += ix;
       
   152         }
       
   153         for (; x<w; ++x) {
       
   154             blender.write(&dst[x], src[srcx >> 16]);
       
   155             srcx += ix;
       
   156         }
       
   157         blender.flush(&dst[x]);
       
   158         dst = (quint16 *)(((uchar *) dst) + dbpl);
       
   159         srcy += iy;
       
   160     }
       
   161 }
       
   162 
       
   163 template <typename T> void qt_scale_image_32bit(uchar *destPixels, int dbpl,
       
   164                                                 const uchar *srcPixels, int sbpl,
       
   165                                                 const QRectF &targetRect,
       
   166                                                 const QRectF &srcRect,
       
   167                                                 const QRect &clip,
       
   168                                                 T blender)
       
   169 {
       
   170     qreal sx = targetRect.width() / (qreal) srcRect.width();
       
   171     qreal sy = targetRect.height() / (qreal) srcRect.height();
       
   172 
       
   173     int ix = 0x00010000 / sx;
       
   174     int iy = 0x00010000 / sy;
       
   175 
       
   176 //     qDebug() << "scale:" << endl
       
   177 //              << " - target" << targetRect << endl
       
   178 //              << " - source" << srcRect << endl
       
   179 //              << " - clip" << clip << endl
       
   180 //              << " - sx=" << sx << " sy=" << sy << " ix=" << ix << " iy=" << iy;
       
   181 
       
   182     int cx1 = clip.x();
       
   183     int cx2 = clip.x() + clip.width();
       
   184     int cy1 = clip.top();
       
   185     int cy2 = clip.y() + clip.height();
       
   186 
       
   187     int tx1 = qRound(targetRect.left());
       
   188     int tx2 = qRound(targetRect.right());
       
   189     int ty1 = qRound(targetRect.top());
       
   190     int ty2 = qRound(targetRect.bottom());
       
   191 
       
   192     if (tx2 < tx1)
       
   193         qSwap(tx2, tx1);
       
   194 
       
   195     if (ty2 < ty1)
       
   196         qSwap(ty2, ty1);
       
   197 
       
   198     if (tx1 < cx1)
       
   199         tx1 = cx1;
       
   200 
       
   201     if (tx2 >= cx2)
       
   202         tx2 = cx2;
       
   203 
       
   204     if (tx1 >= tx2)
       
   205         return;
       
   206 
       
   207     if (ty1 < cy1)
       
   208         ty1 = cy1;
       
   209 
       
   210     if (ty2 >= cy2)
       
   211        ty2 = cy2;
       
   212 
       
   213     if (ty1 >= ty2)
       
   214         return;
       
   215 
       
   216     int h = ty2 - ty1;
       
   217     int w = tx2 - tx1;
       
   218 
       
   219     quint32 basex;
       
   220     quint32 srcy;
       
   221 
       
   222     if (sx < 0) {
       
   223         int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1;
       
   224         basex = quint32(srcRect.right() * 65536) + dstx;
       
   225     } else {
       
   226         int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * ix) - 1;
       
   227         basex = quint32(srcRect.left() * 65536) + dstx;
       
   228     }
       
   229     if (sy < 0) {
       
   230         int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * iy) + 1;
       
   231         srcy = quint32(srcRect.bottom() * 65536) + dsty;
       
   232     } else {
       
   233         int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * iy) - 1;
       
   234         srcy = quint32(srcRect.top() * 65536) + dsty;
       
   235     }
       
   236 
       
   237     quint32 *dst = ((quint32 *) (destPixels + ty1 * dbpl)) + tx1;
       
   238 
       
   239     while (h--) {
       
   240         const uint *src = (const quint32 *) (srcPixels + (srcy >> 16) * sbpl);
       
   241         int srcx = basex;
       
   242         int x = 0;
       
   243         for (; x<w; ++x) {
       
   244             blender.write(&dst[x], src[srcx >> 16]);
       
   245             srcx += ix;
       
   246         }
       
   247         blender.flush(&dst[x]);
       
   248         dst = (quint32 *)(((uchar *) dst) + dbpl);
       
   249         srcy += iy;
       
   250     }
       
   251 }
       
   252 
       
   253 struct QTransformImageVertex
       
   254 {
       
   255     qreal x, y, u, v; // destination coordinates (x, y) and source coordinates (u, v)
       
   256 };
       
   257 
       
   258 template <class SrcT, class DestT, class Blender>
       
   259 void qt_transform_image_rasterize(DestT *destPixels, int dbpl,
       
   260                                   const SrcT *srcPixels, int sbpl,
       
   261                                   const QTransformImageVertex &topLeft, const QTransformImageVertex &bottomLeft,
       
   262                                   const QTransformImageVertex &topRight, const QTransformImageVertex &bottomRight,
       
   263                                   const QRect &sourceRect,
       
   264                                   const QRect &clip,
       
   265                                   qreal topY, qreal bottomY,
       
   266                                   int dudx, int dvdx, int dudy, int dvdy, int u0, int v0,
       
   267                                   Blender blender)
       
   268 {
       
   269     int fromY = qMax(qRound(topY), clip.top());
       
   270     int toY = qMin(qRound(bottomY), clip.top() + clip.height());
       
   271     if (fromY >= toY)
       
   272         return;
       
   273 
       
   274     qreal leftSlope = (bottomLeft.x - topLeft.x) / (bottomLeft.y - topLeft.y);
       
   275     qreal rightSlope = (bottomRight.x - topRight.x) / (bottomRight.y - topRight.y);
       
   276     int dx_l = int(leftSlope * 0x10000);
       
   277     int dx_r = int(rightSlope * 0x10000);
       
   278     int x_l = int((topLeft.x + (0.5 + fromY - topLeft.y) * leftSlope + 0.5) * 0x10000);
       
   279     int x_r = int((topRight.x + (0.5 + fromY - topRight.y) * rightSlope + 0.5) * 0x10000);
       
   280 
       
   281     int fromX, toX, x1, x2, u, v, i, ii;
       
   282     DestT *line;
       
   283     for (int y = fromY; y < toY; ++y) {
       
   284         line = reinterpret_cast<DestT *>(reinterpret_cast<uchar *>(destPixels) + y * dbpl);
       
   285 
       
   286         fromX = qMax(x_l >> 16, clip.left());
       
   287         toX = qMin(x_r >> 16, clip.left() + clip.width());
       
   288         if (fromX < toX) {
       
   289             // Because of rounding, we can get source coordinates outside the source image.
       
   290             // Clamp these coordinates to the source rect to avoid segmentation fault and
       
   291             // garbage on the screen.
       
   292 
       
   293             // Find the first pixel on the current scan line where the source coordinates are within the source rect.
       
   294             x1 = fromX;
       
   295             u = x1 * dudx + y * dudy + u0;
       
   296             v = x1 * dvdx + y * dvdy + v0;
       
   297             for (; x1 < toX; ++x1) {
       
   298                 int uu = u >> 16;
       
   299                 int vv = v >> 16;
       
   300                 if (uu >= sourceRect.left() && uu < sourceRect.left() + sourceRect.width()
       
   301                     && vv >= sourceRect.top() && vv < sourceRect.top() + sourceRect.height()) {
       
   302                     break;
       
   303                 }
       
   304                 u += dudx;
       
   305                 v += dvdx;
       
   306             }
       
   307 
       
   308             // Find the last pixel on the current scan line where the source coordinates are within the source rect.
       
   309             x2 = toX;
       
   310             u = (x2 - 1) * dudx + y * dudy + u0;
       
   311             v = (x2 - 1) * dvdx + y * dvdy + v0;
       
   312             for (; x2 > x1; --x2) {
       
   313                 int uu = u >> 16;
       
   314                 int vv = v >> 16;
       
   315                 if (uu >= sourceRect.left() && uu < sourceRect.left() + sourceRect.width()
       
   316                     && vv >= sourceRect.top() && vv < sourceRect.top() + sourceRect.height()) {
       
   317                     break;
       
   318                 }
       
   319                 u -= dudx;
       
   320                 v -= dvdx;
       
   321             }
       
   322 
       
   323             // Set up values at the beginning of the scan line.
       
   324             u = fromX * dudx + y * dudy + u0;
       
   325             v = fromX * dvdx + y * dvdy + v0;
       
   326             line += fromX;
       
   327 
       
   328             // Beginning of the scan line, with per-pixel checks.
       
   329             i = x1 - fromX;
       
   330             while (i) {
       
   331                 int uu = qBound(sourceRect.left(), u >> 16, sourceRect.left() + sourceRect.width() - 1);
       
   332                 int vv = qBound(sourceRect.top(), v >> 16, sourceRect.top() + sourceRect.height() - 1);
       
   333                 blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + vv * sbpl)[uu]);
       
   334                 u += dudx;
       
   335                 v += dvdx;
       
   336                 ++line;
       
   337                 --i;
       
   338             }
       
   339 
       
   340             // Middle of the scan line, without checks.
       
   341             // Manual loop unrolling.
       
   342             i = x2 - x1;
       
   343             ii = i >> 3;
       
   344             while (ii) {
       
   345                 blender.write(&line[0], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
       
   346                 blender.write(&line[1], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
       
   347                 blender.write(&line[2], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
       
   348                 blender.write(&line[3], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
       
   349                 blender.write(&line[4], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
       
   350                 blender.write(&line[5], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
       
   351                 blender.write(&line[6], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
       
   352                 blender.write(&line[7], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
       
   353 
       
   354                 line += 8;
       
   355 
       
   356                 --ii;
       
   357             }
       
   358             switch (i & 7) {
       
   359                 case 7: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
       
   360                 case 6: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
       
   361                 case 5: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
       
   362                 case 4: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
       
   363                 case 3: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
       
   364                 case 2: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
       
   365                 case 1: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
       
   366             }
       
   367 
       
   368             // End of the scan line, with per-pixel checks.
       
   369             i = toX - x2;
       
   370             while (i) {
       
   371                 int uu = qBound(sourceRect.left(), u >> 16, sourceRect.left() + sourceRect.width() - 1);
       
   372                 int vv = qBound(sourceRect.top(), v >> 16, sourceRect.top() + sourceRect.height() - 1);
       
   373                 blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + vv * sbpl)[uu]);
       
   374                 u += dudx;
       
   375                 v += dvdx;
       
   376                 ++line;
       
   377                 --i;
       
   378             }
       
   379 
       
   380             blender.flush(line);
       
   381         }
       
   382         x_l += dx_l;
       
   383         x_r += dx_r;
       
   384     }
       
   385 }
       
   386 
       
   387 template <class SrcT, class DestT, class Blender>
       
   388 void qt_transform_image(DestT *destPixels, int dbpl,
       
   389                         const SrcT *srcPixels, int sbpl,
       
   390                         const QRectF &targetRect,
       
   391                         const QRectF &sourceRect,
       
   392                         const QRect &clip,
       
   393                         const QTransform &targetRectTransform,
       
   394                         Blender blender)
       
   395 {
       
   396     enum Corner
       
   397     {
       
   398         TopLeft,
       
   399         TopRight,
       
   400         BottomRight,
       
   401         BottomLeft
       
   402     };
       
   403 
       
   404     // map source rectangle to destination.
       
   405     QTransformImageVertex v[4];
       
   406     v[TopLeft].u = v[BottomLeft].u = sourceRect.left();
       
   407     v[TopLeft].v = v[TopRight].v = sourceRect.top();
       
   408     v[TopRight].u = v[BottomRight].u = sourceRect.right();
       
   409     v[BottomLeft].v = v[BottomRight].v = sourceRect.bottom();
       
   410     targetRectTransform.map(targetRect.left(), targetRect.top(), &v[TopLeft].x, &v[TopLeft].y);
       
   411     targetRectTransform.map(targetRect.right(), targetRect.top(), &v[TopRight].x, &v[TopRight].y);
       
   412     targetRectTransform.map(targetRect.left(), targetRect.bottom(), &v[BottomLeft].x, &v[BottomLeft].y);
       
   413     targetRectTransform.map(targetRect.right(), targetRect.bottom(), &v[BottomRight].x, &v[BottomRight].y);
       
   414 
       
   415     // find topmost vertex.
       
   416     int topmost = 0;
       
   417     for (int i = 1; i < 4; ++i) {
       
   418         if (v[i].y < v[topmost].y)
       
   419             topmost = i;
       
   420     }
       
   421     // rearrange array such that topmost vertex is at index 0.
       
   422     switch (topmost) {
       
   423     case 1:
       
   424         {
       
   425             QTransformImageVertex t = v[0];
       
   426             for (int i = 0; i < 3; ++i)
       
   427                 v[i] = v[i+1];
       
   428             v[3] = t;
       
   429         }
       
   430         break;
       
   431     case 2:
       
   432         qSwap(v[0], v[2]);
       
   433         qSwap(v[1], v[3]);
       
   434         break;
       
   435     case 3:
       
   436         {
       
   437             QTransformImageVertex t = v[3];
       
   438             for (int i = 3; i > 0; --i)
       
   439                 v[i] = v[i-1];
       
   440             v[0] = t;
       
   441         }
       
   442         break;
       
   443     }
       
   444 
       
   445     // if necessary, swap vertex 1 and 3 such that 1 is to the left of 3.
       
   446     qreal dx1 = v[1].x - v[0].x;
       
   447     qreal dy1 = v[1].y - v[0].y;
       
   448     qreal dx2 = v[3].x - v[0].x;
       
   449     qreal dy2 = v[3].y - v[0].y;
       
   450     if (dx1 * dy2 - dx2 * dy1 > 0)
       
   451         qSwap(v[1], v[3]);
       
   452 
       
   453     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};
       
   454     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};
       
   455 
       
   456     qreal det = u.x * w.y - u.y * w.x;
       
   457     if (det == 0)
       
   458         return;
       
   459 
       
   460     qreal invDet = 1.0 / det;
       
   461     qreal m11, m12, m21, m22, mdx, mdy;
       
   462 
       
   463     m11 = (u.u * w.y - u.y * w.u) * invDet;
       
   464     m12 = (u.x * w.u - u.u * w.x) * invDet;
       
   465     m21 = (u.v * w.y - u.y * w.v) * invDet;
       
   466     m22 = (u.x * w.v - u.v * w.x) * invDet;
       
   467     mdx = v[0].u - m11 * v[0].x - m12 * v[0].y;
       
   468     mdy = v[0].v - m21 * v[0].x - m22 * v[0].y;
       
   469 
       
   470     int dudx = int(m11 * 0x10000);
       
   471     int dvdx = int(m21 * 0x10000);
       
   472     int dudy = int(m12 * 0x10000);
       
   473     int dvdy = int(m22 * 0x10000);
       
   474     int u0 = qCeil((0.5 * m11 + 0.5 * m12 + mdx) * 0x10000) - 1;
       
   475     int v0 = qCeil((0.5 * m21 + 0.5 * m22 + mdy) * 0x10000) - 1;
       
   476 
       
   477     int x1 = qFloor(sourceRect.left());
       
   478     int y1 = qFloor(sourceRect.top());
       
   479     int x2 = qCeil(sourceRect.right());
       
   480     int y2 = qCeil(sourceRect.bottom());
       
   481     QRect sourceRectI(x1, y1, x2 - x1, y2 - y1);
       
   482 
       
   483     // rasterize trapezoids.
       
   484     if (v[1].y < v[3].y) {
       
   485         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);
       
   486         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);
       
   487         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);
       
   488     } else {
       
   489         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);
       
   490         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);
       
   491         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);
       
   492     }
       
   493 }
       
   494 
       
   495 QT_END_NAMESPACE
       
   496 
       
   497 #endif // QBLENDFUNCTIONS_P_H