source: trunk/src/gui/painting/qblendfunctions_p.h

Last change on this file was 846, checked in by Dmitry A. Kuminov, 14 years ago

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.
File size: 19.5 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2011 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** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
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** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at qt-info@nokia.com.
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
48QT_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
61template <typename SRC, typename T>
62void 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
163template <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
253struct QTransformImageVertex
254{
255 qreal x, y, u, v; // destination coordinates (x, y) and source coordinates (u, v)
256};
257
258template <class SrcT, class DestT, class Blender>
259void 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
387template <class SrcT, class DestT, class Blender>
388void 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
495QT_END_NAMESPACE
496
497#endif // QBLENDFUNCTIONS_P_H
Note: See TracBrowser for help on using the repository browser.