mirror of
https://bitbucket.org/smil3y/katie.git
synced 2025-02-24 10:52:56 +00:00
the specialized image transformation functions do not pay off
Signed-off-by: Ivailo Monev <xakepa10@laimg.moc>
This commit is contained in:
Ivailo Monev
parent
ea27ea003d
commit
c7fb03d462
7 changed files with 0 additions and 2329 deletions
|
|
@ -43,7 +43,6 @@ set(GUI_HEADERS
|
|||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qwindowsurface_p.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qpaintengine_raster_p.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qdrawhelper_p.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qblendfunctions_p.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qrasterdefs_p.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qgrayraster_p.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qbackingstore_p.h
|
||||
|
|
@ -61,7 +60,6 @@ set(GUI_HEADERS
|
|||
set(GUI_SOURCES
|
||||
${GUI_SOURCES}
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qbezier.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qblendfunctions.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qbrush.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qcolor.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/painting/qcolor_p.cpp
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,515 +0,0 @@
|
|||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2015 The Qt Company Ltd.
|
||||
** Contact: http://www.qt.io/licensing/
|
||||
**
|
||||
** This file is part of the QtGui module of the Qt Toolkit.
|
||||
**
|
||||
** $QT_BEGIN_LICENSE:LGPL$
|
||||
** Commercial License Usage
|
||||
** Licensees holding valid commercial Qt licenses may use this file in
|
||||
** accordance with the commercial license agreement provided with the
|
||||
** Software or, alternatively, in accordance with the terms contained in
|
||||
** a written agreement between you and The Qt Company. For licensing terms
|
||||
** and conditions see http://www.qt.io/terms-conditions. For further
|
||||
** information use the contact form at http://www.qt.io/contact-us.
|
||||
**
|
||||
** GNU Lesser General Public License Usage
|
||||
** Alternatively, this file may be used under the terms of the GNU Lesser
|
||||
** General Public License version 2.1 or version 3 as published by the Free
|
||||
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
|
||||
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
|
||||
** following information to ensure the GNU Lesser General Public License
|
||||
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
|
||||
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
||||
**
|
||||
** As a special exception, The Qt Company gives you certain additional
|
||||
** rights. These rights are described in The Qt Company LGPL Exception
|
||||
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
||||
**
|
||||
** GNU General Public License Usage
|
||||
** Alternatively, this file may be used under the terms of the GNU
|
||||
** General Public License version 3.0 as published by the Free Software
|
||||
** Foundation and appearing in the file LICENSE.GPL included in the
|
||||
** packaging of this file. Please review the following information to
|
||||
** ensure the GNU General Public License version 3.0 requirements will be
|
||||
** met: http://www.gnu.org/copyleft/gpl.html.
|
||||
**
|
||||
** $QT_END_LICENSE$
|
||||
**
|
||||
****************************************************************************/
|
||||
|
||||
#ifndef QBLENDFUNCTIONS_P_H
|
||||
#define QBLENDFUNCTIONS_P_H
|
||||
|
||||
#include <qmath.h>
|
||||
#include "qdrawhelper_p.h"
|
||||
|
||||
QT_BEGIN_NAMESPACE
|
||||
|
||||
//
|
||||
// W A R N I N G
|
||||
// -------------
|
||||
//
|
||||
// This file is not part of the Qt API. It exists purely as an
|
||||
// implementation detail. This header file may change from version to
|
||||
// version without notice, or even be removed.
|
||||
//
|
||||
// We mean it.
|
||||
//
|
||||
|
||||
template <typename SRC, typename T>
|
||||
void qt_scale_image_16bit(uchar *destPixels, int dbpl,
|
||||
const uchar *srcPixels, int sbpl, int sh,
|
||||
const QRectF &targetRect,
|
||||
const QRectF &srcRect,
|
||||
const QRect &clip,
|
||||
T blender)
|
||||
{
|
||||
qreal sx = targetRect.width() / (qreal) srcRect.width();
|
||||
qreal sy = targetRect.height() / (qreal) srcRect.height();
|
||||
|
||||
int ix = 0x00010000 / sx;
|
||||
int iy = 0x00010000 / sy;
|
||||
|
||||
// qDebug() << "scale:" << endl
|
||||
// << " - target" << targetRect << endl
|
||||
// << " - source" << srcRect << endl
|
||||
// << " - clip" << clip << endl
|
||||
// << " - sx=" << sx << " sy=" << sy << " ix=" << ix << " iy=" << iy;
|
||||
|
||||
int cx1 = clip.x();
|
||||
int cx2 = clip.x() + clip.width();
|
||||
int cy1 = clip.top();
|
||||
int cy2 = clip.y() + clip.height();
|
||||
|
||||
int tx1 = qRound(targetRect.left());
|
||||
int tx2 = qRound(targetRect.right());
|
||||
int ty1 = qRound(targetRect.top());
|
||||
int ty2 = qRound(targetRect.bottom());
|
||||
|
||||
if (tx2 < tx1)
|
||||
qSwap(tx2, tx1);
|
||||
|
||||
if (ty2 < ty1)
|
||||
qSwap(ty2, ty1);
|
||||
|
||||
if (tx1 < cx1)
|
||||
tx1 = cx1;
|
||||
|
||||
if (tx2 >= cx2)
|
||||
tx2 = cx2;
|
||||
|
||||
if (tx1 >= tx2)
|
||||
return;
|
||||
|
||||
if (ty1 < cy1)
|
||||
ty1 = cy1;
|
||||
|
||||
if (ty2 >= cy2)
|
||||
ty2 = cy2;
|
||||
|
||||
if (ty1 >= ty2)
|
||||
return;
|
||||
|
||||
int h = ty2 - ty1;
|
||||
int w = tx2 - tx1;
|
||||
|
||||
|
||||
quint32 basex;
|
||||
quint32 srcy;
|
||||
|
||||
if (sx < 0) {
|
||||
int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1;
|
||||
basex = quint32(srcRect.right() * 65536) + dstx;
|
||||
} else {
|
||||
int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * ix) - 1;
|
||||
basex = quint32(srcRect.left() * 65536) + dstx;
|
||||
}
|
||||
if (sy < 0) {
|
||||
int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * iy) + 1;
|
||||
srcy = quint32(srcRect.bottom() * 65536) + dsty;
|
||||
} else {
|
||||
int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * iy) - 1;
|
||||
srcy = quint32(srcRect.top() * 65536) + dsty;
|
||||
}
|
||||
|
||||
quint16 *dst = ((quint16 *) (destPixels + ty1 * dbpl)) + tx1;
|
||||
|
||||
// this bounds check here is required as floating point rounding above might in some cases lead to
|
||||
// w/h values that are one pixel too large, falling outside of the valid image area.
|
||||
int yend = (srcy + iy * (h - 1)) >> 16;
|
||||
if (yend < 0 || yend >= sh)
|
||||
--h;
|
||||
int xend = (basex + ix * (w - 1)) >> 16;
|
||||
if (xend < 0 || xend >= (int)(sbpl/sizeof(quint32)))
|
||||
--w;
|
||||
|
||||
while (h--) {
|
||||
const SRC *src = (const SRC *) (srcPixels + (srcy >> 16) * sbpl);
|
||||
quint32 srcx = basex;
|
||||
int x = 0;
|
||||
for (; x<w-7; x+=8) {
|
||||
blender.write(&dst[x], src[srcx >> 16]); srcx += ix;
|
||||
blender.write(&dst[x+1], src[srcx >> 16]); srcx += ix;
|
||||
blender.write(&dst[x+2], src[srcx >> 16]); srcx += ix;
|
||||
blender.write(&dst[x+3], src[srcx >> 16]); srcx += ix;
|
||||
blender.write(&dst[x+4], src[srcx >> 16]); srcx += ix;
|
||||
blender.write(&dst[x+5], src[srcx >> 16]); srcx += ix;
|
||||
blender.write(&dst[x+6], src[srcx >> 16]); srcx += ix;
|
||||
blender.write(&dst[x+7], src[srcx >> 16]); srcx += ix;
|
||||
}
|
||||
for (; x<w; ++x) {
|
||||
blender.write(&dst[x], src[srcx >> 16]);
|
||||
srcx += ix;
|
||||
}
|
||||
blender.flush(&dst[x]);
|
||||
dst = (quint16 *)(((uchar *) dst) + dbpl);
|
||||
srcy += iy;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T> void qt_scale_image_32bit(uchar *destPixels, int dbpl,
|
||||
const uchar *srcPixels, int sbpl, int sh,
|
||||
const QRectF &targetRect,
|
||||
const QRectF &srcRect,
|
||||
const QRect &clip,
|
||||
T blender)
|
||||
{
|
||||
qreal sx = targetRect.width() / (qreal) srcRect.width();
|
||||
qreal sy = targetRect.height() / (qreal) srcRect.height();
|
||||
|
||||
int ix = 0x00010000 / sx;
|
||||
int iy = 0x00010000 / sy;
|
||||
|
||||
// qDebug() << "scale:" << endl
|
||||
// << " - target" << targetRect << endl
|
||||
// << " - source" << srcRect << endl
|
||||
// << " - clip" << clip << endl
|
||||
// << " - sx=" << sx << " sy=" << sy << " ix=" << ix << " iy=" << iy;
|
||||
|
||||
int cx1 = clip.x();
|
||||
int cx2 = clip.x() + clip.width();
|
||||
int cy1 = clip.top();
|
||||
int cy2 = clip.y() + clip.height();
|
||||
|
||||
int tx1 = qRound(targetRect.left());
|
||||
int tx2 = qRound(targetRect.right());
|
||||
int ty1 = qRound(targetRect.top());
|
||||
int ty2 = qRound(targetRect.bottom());
|
||||
|
||||
if (tx2 < tx1)
|
||||
qSwap(tx2, tx1);
|
||||
|
||||
if (ty2 < ty1)
|
||||
qSwap(ty2, ty1);
|
||||
|
||||
if (tx1 < cx1)
|
||||
tx1 = cx1;
|
||||
|
||||
if (tx2 >= cx2)
|
||||
tx2 = cx2;
|
||||
|
||||
if (tx1 >= tx2)
|
||||
return;
|
||||
|
||||
if (ty1 < cy1)
|
||||
ty1 = cy1;
|
||||
|
||||
if (ty2 >= cy2)
|
||||
ty2 = cy2;
|
||||
|
||||
if (ty1 >= ty2)
|
||||
return;
|
||||
|
||||
int h = ty2 - ty1;
|
||||
int w = tx2 - tx1;
|
||||
|
||||
quint32 basex;
|
||||
quint32 srcy;
|
||||
|
||||
if (sx < 0) {
|
||||
int dstx = qFloor((tx1 + qreal(0.5) - targetRect.right()) * ix) + 1;
|
||||
basex = quint32(srcRect.right() * 65536) + dstx;
|
||||
} else {
|
||||
int dstx = qCeil((tx1 + qreal(0.5) - targetRect.left()) * ix) - 1;
|
||||
basex = quint32(srcRect.left() * 65536) + dstx;
|
||||
}
|
||||
if (sy < 0) {
|
||||
int dsty = qFloor((ty1 + qreal(0.5) - targetRect.bottom()) * iy) + 1;
|
||||
srcy = quint32(srcRect.bottom() * 65536) + dsty;
|
||||
} else {
|
||||
int dsty = qCeil((ty1 + qreal(0.5) - targetRect.top()) * iy) - 1;
|
||||
srcy = quint32(srcRect.top() * 65536) + dsty;
|
||||
}
|
||||
|
||||
quint32 *dst = ((quint32 *) (destPixels + ty1 * dbpl)) + tx1;
|
||||
|
||||
// this bounds check here is required as floating point rounding above might in some cases lead to
|
||||
// w/h values that are one pixel too large, falling outside of the valid image area.
|
||||
int yend = (srcy + iy * (h - 1)) >> 16;
|
||||
if (yend < 0 || yend >= sh)
|
||||
--h;
|
||||
int xend = (basex + ix * (w - 1)) >> 16;
|
||||
if (xend < 0 || xend >= (int)(sbpl/sizeof(quint32)))
|
||||
--w;
|
||||
|
||||
while (h--) {
|
||||
const uint *src = (const quint32 *) (srcPixels + (srcy >> 16) * sbpl);
|
||||
quint32 srcx = basex;
|
||||
int x = 0;
|
||||
for (; x<w; ++x) {
|
||||
blender.write(&dst[x], src[srcx >> 16]);
|
||||
srcx += ix;
|
||||
}
|
||||
blender.flush(&dst[x]);
|
||||
dst = (quint32 *)(((uchar *) dst) + dbpl);
|
||||
srcy += iy;
|
||||
}
|
||||
}
|
||||
|
||||
struct QTransformImageVertex
|
||||
{
|
||||
qreal x, y, u, v; // destination coordinates (x, y) and source coordinates (u, v)
|
||||
};
|
||||
|
||||
template <class SrcT, class DestT, class Blender>
|
||||
void qt_transform_image_rasterize(DestT *destPixels, int dbpl,
|
||||
const SrcT *srcPixels, int sbpl,
|
||||
const QTransformImageVertex &topLeft, const QTransformImageVertex &bottomLeft,
|
||||
const QTransformImageVertex &topRight, const QTransformImageVertex &bottomRight,
|
||||
const QRect &sourceRect,
|
||||
const QRect &clip,
|
||||
qreal topY, qreal bottomY,
|
||||
int dudx, int dvdx, int dudy, int dvdy, int u0, int v0,
|
||||
Blender blender)
|
||||
{
|
||||
int fromY = qMax(qRound(topY), clip.top());
|
||||
int toY = qMin(qRound(bottomY), clip.top() + clip.height());
|
||||
if (fromY >= toY)
|
||||
return;
|
||||
|
||||
qreal leftSlope = (bottomLeft.x - topLeft.x) / (bottomLeft.y - topLeft.y);
|
||||
qreal rightSlope = (bottomRight.x - topRight.x) / (bottomRight.y - topRight.y);
|
||||
int dx_l = int(leftSlope * 0x10000);
|
||||
int dx_r = int(rightSlope * 0x10000);
|
||||
int x_l = int((topLeft.x + (qreal(0.5) + fromY - topLeft.y) * leftSlope + qreal(0.5)) * 0x10000);
|
||||
int x_r = int((topRight.x + (qreal(0.5) + fromY - topRight.y) * rightSlope + qreal(0.5)) * 0x10000);
|
||||
|
||||
int fromX, toX, x1, x2, u, v, i, ii;
|
||||
DestT *line;
|
||||
for (int y = fromY; y < toY; ++y) {
|
||||
line = reinterpret_cast<DestT *>(reinterpret_cast<uchar *>(destPixels) + y * dbpl);
|
||||
|
||||
fromX = qMax(x_l >> 16, clip.left());
|
||||
toX = qMin(x_r >> 16, clip.left() + clip.width());
|
||||
if (fromX < toX) {
|
||||
// Because of rounding, we can get source coordinates outside the source image.
|
||||
// Clamp these coordinates to the source rect to avoid segmentation fault and
|
||||
// garbage on the screen.
|
||||
|
||||
// Find the first pixel on the current scan line where the source coordinates are within the source rect.
|
||||
x1 = fromX;
|
||||
u = x1 * dudx + y * dudy + u0;
|
||||
v = x1 * dvdx + y * dvdy + v0;
|
||||
for (; x1 < toX; ++x1) {
|
||||
int uu = u >> 16;
|
||||
int vv = v >> 16;
|
||||
if (uu >= sourceRect.left() && uu < sourceRect.left() + sourceRect.width()
|
||||
&& vv >= sourceRect.top() && vv < sourceRect.top() + sourceRect.height()) {
|
||||
break;
|
||||
}
|
||||
u += dudx;
|
||||
v += dvdx;
|
||||
}
|
||||
|
||||
// Find the last pixel on the current scan line where the source coordinates are within the source rect.
|
||||
x2 = toX;
|
||||
u = (x2 - 1) * dudx + y * dudy + u0;
|
||||
v = (x2 - 1) * dvdx + y * dvdy + v0;
|
||||
for (; x2 > x1; --x2) {
|
||||
int uu = u >> 16;
|
||||
int vv = v >> 16;
|
||||
if (uu >= sourceRect.left() && uu < sourceRect.left() + sourceRect.width()
|
||||
&& vv >= sourceRect.top() && vv < sourceRect.top() + sourceRect.height()) {
|
||||
break;
|
||||
}
|
||||
u -= dudx;
|
||||
v -= dvdx;
|
||||
}
|
||||
|
||||
// Set up values at the beginning of the scan line.
|
||||
u = fromX * dudx + y * dudy + u0;
|
||||
v = fromX * dvdx + y * dvdy + v0;
|
||||
line += fromX;
|
||||
|
||||
// Beginning of the scan line, with per-pixel checks.
|
||||
i = x1 - fromX;
|
||||
while (i) {
|
||||
int uu = qBound(sourceRect.left(), u >> 16, sourceRect.left() + sourceRect.width() - 1);
|
||||
int vv = qBound(sourceRect.top(), v >> 16, sourceRect.top() + sourceRect.height() - 1);
|
||||
blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + vv * sbpl)[uu]);
|
||||
u += dudx;
|
||||
v += dvdx;
|
||||
++line;
|
||||
--i;
|
||||
}
|
||||
|
||||
// Middle of the scan line, without checks.
|
||||
// Manual loop unrolling.
|
||||
i = x2 - x1;
|
||||
ii = i >> 3;
|
||||
while (ii) {
|
||||
blender.write(&line[0], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
|
||||
blender.write(&line[1], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
|
||||
blender.write(&line[2], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
|
||||
blender.write(&line[3], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
|
||||
blender.write(&line[4], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
|
||||
blender.write(&line[5], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
|
||||
blender.write(&line[6], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
|
||||
blender.write(&line[7], reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx;
|
||||
|
||||
line += 8;
|
||||
|
||||
--ii;
|
||||
}
|
||||
switch (i & 7) {
|
||||
case 7: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
|
||||
case 6: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
|
||||
case 5: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
|
||||
case 4: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
|
||||
case 3: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
|
||||
case 2: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
|
||||
case 1: blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + (v >> 16) * sbpl)[u >> 16]); u += dudx; v += dvdx; ++line;
|
||||
}
|
||||
|
||||
// End of the scan line, with per-pixel checks.
|
||||
i = toX - x2;
|
||||
while (i) {
|
||||
int uu = qBound(sourceRect.left(), u >> 16, sourceRect.left() + sourceRect.width() - 1);
|
||||
int vv = qBound(sourceRect.top(), v >> 16, sourceRect.top() + sourceRect.height() - 1);
|
||||
blender.write(line, reinterpret_cast<const SrcT *>(reinterpret_cast<const uchar *>(srcPixels) + vv * sbpl)[uu]);
|
||||
u += dudx;
|
||||
v += dvdx;
|
||||
++line;
|
||||
--i;
|
||||
}
|
||||
|
||||
blender.flush(line);
|
||||
}
|
||||
x_l += dx_l;
|
||||
x_r += dx_r;
|
||||
}
|
||||
}
|
||||
|
||||
template <class SrcT, class DestT, class Blender>
|
||||
void qt_transform_image(DestT *destPixels, int dbpl,
|
||||
const SrcT *srcPixels, int sbpl,
|
||||
const QRectF &targetRect,
|
||||
const QRectF &sourceRect,
|
||||
const QRect &clip,
|
||||
const QTransform &targetRectTransform,
|
||||
Blender blender)
|
||||
{
|
||||
enum Corner
|
||||
{
|
||||
TopLeft,
|
||||
TopRight,
|
||||
BottomRight,
|
||||
BottomLeft
|
||||
};
|
||||
|
||||
// map source rectangle to destination.
|
||||
QTransformImageVertex v[4];
|
||||
v[TopLeft].u = v[BottomLeft].u = sourceRect.left();
|
||||
v[TopLeft].v = v[TopRight].v = sourceRect.top();
|
||||
v[TopRight].u = v[BottomRight].u = sourceRect.right();
|
||||
v[BottomLeft].v = v[BottomRight].v = sourceRect.bottom();
|
||||
targetRectTransform.map(targetRect.left(), targetRect.top(), &v[TopLeft].x, &v[TopLeft].y);
|
||||
targetRectTransform.map(targetRect.right(), targetRect.top(), &v[TopRight].x, &v[TopRight].y);
|
||||
targetRectTransform.map(targetRect.left(), targetRect.bottom(), &v[BottomLeft].x, &v[BottomLeft].y);
|
||||
targetRectTransform.map(targetRect.right(), targetRect.bottom(), &v[BottomRight].x, &v[BottomRight].y);
|
||||
|
||||
// find topmost vertex.
|
||||
int topmost = 0;
|
||||
for (int i = 1; i < 4; ++i) {
|
||||
if (v[i].y < v[topmost].y)
|
||||
topmost = i;
|
||||
}
|
||||
// rearrange array such that topmost vertex is at index 0.
|
||||
switch (topmost) {
|
||||
case 1:
|
||||
{
|
||||
QTransformImageVertex t = v[0];
|
||||
for (int i = 0; i < 3; ++i)
|
||||
v[i] = v[i+1];
|
||||
v[3] = t;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
qSwap(v[0], v[2]);
|
||||
qSwap(v[1], v[3]);
|
||||
break;
|
||||
case 3:
|
||||
{
|
||||
QTransformImageVertex t = v[3];
|
||||
for (int i = 3; i > 0; --i)
|
||||
v[i] = v[i-1];
|
||||
v[0] = t;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// if necessary, swap vertex 1 and 3 such that 1 is to the left of 3.
|
||||
qreal dx1 = v[1].x - v[0].x;
|
||||
qreal dy1 = v[1].y - v[0].y;
|
||||
qreal dx2 = v[3].x - v[0].x;
|
||||
qreal dy2 = v[3].y - v[0].y;
|
||||
if (dx1 * dy2 - dx2 * dy1 > 0)
|
||||
qSwap(v[1], v[3]);
|
||||
|
||||
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};
|
||||
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};
|
||||
|
||||
qreal det = u.x * w.y - u.y * w.x;
|
||||
if (det == 0)
|
||||
return;
|
||||
|
||||
qreal invDet = 1.0 / det;
|
||||
qreal m11, m12, m21, m22, mdx, mdy;
|
||||
|
||||
m11 = (u.u * w.y - u.y * w.u) * invDet;
|
||||
m12 = (u.x * w.u - u.u * w.x) * invDet;
|
||||
m21 = (u.v * w.y - u.y * w.v) * invDet;
|
||||
m22 = (u.x * w.v - u.v * w.x) * invDet;
|
||||
mdx = v[0].u - m11 * v[0].x - m12 * v[0].y;
|
||||
mdy = v[0].v - m21 * v[0].x - m22 * v[0].y;
|
||||
|
||||
int dudx = int(m11 * 0x10000);
|
||||
int dvdx = int(m21 * 0x10000);
|
||||
int dudy = int(m12 * 0x10000);
|
||||
int dvdy = int(m22 * 0x10000);
|
||||
int u0 = qCeil((qreal(0.5) * m11 + qreal(0.5) * m12 + mdx) * 0x10000) - 1;
|
||||
int v0 = qCeil((qreal(0.5) * m21 + qreal(0.5) * m22 + mdy) * 0x10000) - 1;
|
||||
|
||||
int x1 = qFloor(sourceRect.left());
|
||||
int y1 = qFloor(sourceRect.top());
|
||||
int x2 = qCeil(sourceRect.right());
|
||||
int y2 = qCeil(sourceRect.bottom());
|
||||
QRect sourceRectI(x1, y1, x2 - x1, y2 - y1);
|
||||
|
||||
// rasterize trapezoids.
|
||||
if (v[1].y < v[3].y) {
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
} else {
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
#endif // QBLENDFUNCTIONS_P_H
|
||||
|
|
@ -158,11 +158,6 @@ struct DrawHelper {
|
|||
RectFillFunc fillRect;
|
||||
};
|
||||
|
||||
extern SrcOverBlendFunc qBlendFunctions[QImage::NImageFormats][QImage::NImageFormats];
|
||||
extern SrcOverScaleFunc qScaleFunctions[QImage::NImageFormats][QImage::NImageFormats];
|
||||
extern SrcOverTransformFunc qTransformFunctions[QImage::NImageFormats][QImage::NImageFormats];
|
||||
extern MemRotateFunc qMemRotateFunctions[QImage::NImageFormats][3];
|
||||
|
||||
extern DrawHelper qDrawHelper[QImage::NImageFormats];
|
||||
|
||||
void qBlendTexture(int count, const QSpan *spans, void *userData);
|
||||
|
|
|
|||
|
|
@ -610,27 +610,6 @@ void qt_memrotate270_32(const uchar *srcPixels, int w, int h, int sbpl, uchar *d
|
|||
qt_memrotate270((const uint *)srcPixels, w, h, sbpl, (uint *)destPixels, dbpl);
|
||||
}
|
||||
|
||||
MemRotateFunc qMemRotateFunctions[QImage::NImageFormats][3] =
|
||||
// 90, 180, 270
|
||||
{
|
||||
{ 0, 0, 0 }, // Format_Invalid,
|
||||
{ 0, 0, 0 }, // Format_Mono,
|
||||
{ 0, 0, 0 }, // Format_MonoLSB,
|
||||
{ 0, 0, 0 }, // Format_Indexed8,
|
||||
{ qt_memrotate90_32, qt_memrotate180_32, qt_memrotate270_32 }, // Format_RGB32,
|
||||
{ qt_memrotate90_32, qt_memrotate180_32, qt_memrotate270_32 }, // Format_ARGB32,
|
||||
{ qt_memrotate90_32, qt_memrotate180_32, qt_memrotate270_32 }, // Format_ARGB32_Premultiplied,
|
||||
{ qt_memrotate90_16, qt_memrotate180_16, qt_memrotate270_16 }, // Format_RGB16,
|
||||
{ 0, 0, 0 }, // Format_ARGB8565_Premultiplied,
|
||||
{ 0, 0, 0 }, // Format_RGB666,
|
||||
{ 0, 0, 0 }, // Format_ARGB6666_Premultiplied,
|
||||
{ 0, 0, 0 }, // Format_RGB555,
|
||||
{ 0, 0, 0 }, // Format_ARGB8555_Premultiplied,
|
||||
{ 0, 0, 0 }, // Format_RGB888,
|
||||
{ 0, 0, 0 }, // Format_RGB444,
|
||||
{ 0, 0, 0 } // Format_ARGB4444_Premultiplied,
|
||||
};
|
||||
|
||||
QT_END_NAMESPACE
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -561,7 +561,6 @@ QRasterPaintEngineState::QRasterPaintEngineState()
|
|||
flags.fast_text = true;
|
||||
flags.int_xform = true;
|
||||
flags.tx_noshear = true;
|
||||
flags.fast_images = true;
|
||||
|
||||
clip = 0;
|
||||
flags.has_clip_ownership = false;
|
||||
|
|
@ -817,8 +816,6 @@ void QRasterPaintEngine::compositionModeChanged()
|
|||
|
||||
s->strokeFlags |= DirtyCompositionMode;
|
||||
d->rasterBuffer->compositionMode = s->composition_mode;
|
||||
|
||||
d->recalculateFastImages();
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
@ -845,9 +842,6 @@ void QRasterPaintEngine::renderHintsChanged()
|
|||
s->strokeFlags |= DirtyPen;
|
||||
s->fillFlags |= DirtyBrush;
|
||||
}
|
||||
|
||||
Q_D(QRasterPaintEngine);
|
||||
d->recalculateFastImages();
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
@ -865,9 +859,6 @@ void QRasterPaintEngine::transformChanged()
|
|||
s->strokeFlags |= DirtyTransform;
|
||||
|
||||
s->dirty |= DirtyTransform;
|
||||
|
||||
Q_D(QRasterPaintEngine);
|
||||
d->recalculateFastImages();
|
||||
}
|
||||
|
||||
/*!
|
||||
|
|
@ -1969,21 +1960,6 @@ void QRasterPaintEngine::drawImage(const QPointF &p, const QImage &img)
|
|||
const QClipData *clip = d->clip();
|
||||
QPointF pt(p.x() + s->matrix.dx(), p.y() + s->matrix.dy());
|
||||
|
||||
if (d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) {
|
||||
SrcOverBlendFunc func = qBlendFunctions[d->rasterBuffer->format][img.format()];
|
||||
if (func) {
|
||||
if (!clip) {
|
||||
d->drawImage(pt, img, func, d->deviceRect, s->intOpacity);
|
||||
return;
|
||||
} else if (clip->hasRectClip) {
|
||||
d->drawImage(pt, img, func, clip->clipRect, s->intOpacity);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
d->image_filler.clip = clip;
|
||||
d->image_filler.initTexture(&img, s->intOpacity, QTextureData::Plain, img.rect());
|
||||
if (!d->image_filler.blend)
|
||||
|
|
@ -2098,83 +2074,7 @@ void QRasterPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRe
|
|||
|
||||
const QClipData *clip = d->clip();
|
||||
|
||||
if (s->matrix.type() > QTransform::TxTranslate
|
||||
&& !stretch_sr
|
||||
&& (!clip || clip->hasRectClip)
|
||||
&& s->intOpacity == 256
|
||||
&& (d->rasterBuffer->compositionMode == QPainter::CompositionMode_SourceOver
|
||||
|| d->rasterBuffer->compositionMode == QPainter::CompositionMode_Source)
|
||||
&& d->rasterBuffer->format == img.format()
|
||||
&& (d->rasterBuffer->format == QImage::Format_RGB16
|
||||
|| d->rasterBuffer->format == QImage::Format_RGB32
|
||||
|| (d->rasterBuffer->format == QImage::Format_ARGB32_Premultiplied
|
||||
&& d->rasterBuffer->compositionMode == QPainter::CompositionMode_Source)))
|
||||
{
|
||||
RotationType rotationType = qRotationType(s->matrix);
|
||||
|
||||
if (rotationType != NoRotation && qMemRotateFunctions[d->rasterBuffer->format][rotationType] && img.rect().contains(sr.toAlignedRect())) {
|
||||
QRectF transformedTargetRect = s->matrix.mapRect(r);
|
||||
|
||||
if ((!(s->renderHints & QPainter::SmoothPixmapTransform) && !(s->renderHints & QPainter::Antialiasing))
|
||||
|| (isPixelAligned(transformedTargetRect) && isPixelAligned(sr)))
|
||||
{
|
||||
QRect clippedTransformedTargetRect = transformedTargetRect.toRect().intersected(clip ? clip->clipRect : d->deviceRect);
|
||||
if (clippedTransformedTargetRect.isNull())
|
||||
return;
|
||||
|
||||
QRectF clippedTargetRect = s->matrix.inverted().mapRect(QRectF(clippedTransformedTargetRect));
|
||||
|
||||
QRect clippedSourceRect
|
||||
= QRectF(sr.x() + clippedTargetRect.x() - r.x(), sr.y() + clippedTargetRect.y() - r.y(),
|
||||
clippedTargetRect.width(), clippedTargetRect.height()).toRect();
|
||||
|
||||
uint dbpl = d->rasterBuffer->bytesPerLine();
|
||||
uint sbpl = img.bytesPerLine();
|
||||
|
||||
uchar *dst = d->rasterBuffer->buffer();
|
||||
uint bpp = img.depth() >> 3;
|
||||
|
||||
const uchar *srcBase = img.bits() + clippedSourceRect.y() * sbpl + clippedSourceRect.x() * bpp;
|
||||
uchar *dstBase = dst + clippedTransformedTargetRect.y() * dbpl + clippedTransformedTargetRect.x() * bpp;
|
||||
|
||||
uint cw = clippedSourceRect.width();
|
||||
uint ch = clippedSourceRect.height();
|
||||
|
||||
qMemRotateFunctions[d->rasterBuffer->format][rotationType](srcBase, cw, ch, sbpl, dstBase, dbpl);
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (s->matrix.type() > QTransform::TxTranslate || stretch_sr) {
|
||||
|
||||
QRectF targetBounds = s->matrix.mapRect(r);
|
||||
bool exceedsPrecision = targetBounds.width() > 0xffff
|
||||
|| targetBounds.height() > 0xffff;
|
||||
|
||||
if (!exceedsPrecision && d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) {
|
||||
if (s->matrix.type() > QTransform::TxScale) {
|
||||
SrcOverTransformFunc func = qTransformFunctions[d->rasterBuffer->format][img.format()];
|
||||
if (func && (!clip || clip->hasRectClip)) {
|
||||
func(d->rasterBuffer->buffer(), d->rasterBuffer->bytesPerLine(), img.bits(),
|
||||
img.bytesPerLine(), r, sr, !clip ? d->deviceRect : clip->clipRect,
|
||||
s->matrix, s->intOpacity);
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
SrcOverScaleFunc func = qScaleFunctions[d->rasterBuffer->format][img.format()];
|
||||
if (func && (!clip || clip->hasRectClip)) {
|
||||
func(d->rasterBuffer->buffer(), d->rasterBuffer->bytesPerLine(),
|
||||
img.bits(), img.bytesPerLine(), img.height(),
|
||||
qt_mapRect_non_normalizing(r, s->matrix), sr,
|
||||
!clip ? d->deviceRect : clip->clipRect,
|
||||
s->intOpacity);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
QTransform copy = s->matrix;
|
||||
copy.translate(r.x(), r.y());
|
||||
if (stretch_sr)
|
||||
|
|
@ -2234,20 +2134,6 @@ void QRasterPaintEngine::drawImage(const QRectF &r, const QImage &img, const QRe
|
|||
fillPath(path, &d->image_filler_xform);
|
||||
s->matrix = m;
|
||||
} else {
|
||||
if (d->canUseFastImageBlending(d->rasterBuffer->compositionMode, img)) {
|
||||
SrcOverBlendFunc func = qBlendFunctions[d->rasterBuffer->format][img.format()];
|
||||
if (func) {
|
||||
QPointF pt(r.x() + s->matrix.dx(), r.y() + s->matrix.dy());
|
||||
if (!clip) {
|
||||
d->drawImage(pt, img, func, d->deviceRect, s->intOpacity, sr.toRect());
|
||||
return;
|
||||
} else if (clip->hasRectClip) {
|
||||
d->drawImage(pt, img, func, clip->clipRect, s->intOpacity, sr.toRect());
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
d->image_filler.clip = clip;
|
||||
d->image_filler.initTexture(&img, s->intOpacity, QTextureData::Plain, toAlignedRect_positive(sr));
|
||||
if (!d->image_filler.blend)
|
||||
|
|
@ -3393,26 +3279,6 @@ void QRasterPaintEnginePrivate::rasterize(QT_FT_Outline *outline,
|
|||
qt_ft_grays_raster.raster_render(*grayRaster, &rasterParams);
|
||||
}
|
||||
|
||||
void QRasterPaintEnginePrivate::recalculateFastImages()
|
||||
{
|
||||
Q_Q(QRasterPaintEngine);
|
||||
QRasterPaintEngineState *s = q->state();
|
||||
|
||||
s->flags.fast_images = !(s->renderHints & QPainter::SmoothPixmapTransform)
|
||||
&& s->matrix.type() <= QTransform::TxShear;
|
||||
}
|
||||
|
||||
bool QRasterPaintEnginePrivate::canUseFastImageBlending(QPainter::CompositionMode mode, const QImage &image) const
|
||||
{
|
||||
Q_Q(const QRasterPaintEngine);
|
||||
const QRasterPaintEngineState *s = q->state();
|
||||
|
||||
return s->flags.fast_images
|
||||
&& (mode == QPainter::CompositionMode_SourceOver
|
||||
|| (mode == QPainter::CompositionMode_Source
|
||||
&& !image.hasAlphaChannel()));
|
||||
}
|
||||
|
||||
QImage QRasterBuffer::colorizeBitmap(const QImage &image, const QColor &color)
|
||||
{
|
||||
Q_ASSERT(image.depth() == 1);
|
||||
|
|
|
|||
|
|
@ -112,7 +112,6 @@ public:
|
|||
uint fast_text : 1;
|
||||
uint int_xform : 1;
|
||||
uint tx_noshear : 1;
|
||||
uint fast_images : 1;
|
||||
};
|
||||
|
||||
union {
|
||||
|
|
@ -315,9 +314,6 @@ public:
|
|||
|
||||
void initializeRasterizer(QSpanData *data);
|
||||
|
||||
void recalculateFastImages();
|
||||
bool canUseFastImageBlending(QPainter::CompositionMode mode, const QImage &image) const;
|
||||
|
||||
QPaintDevice *device;
|
||||
QScopedPointer<QOutlineMapper> outlineMapper;
|
||||
QScopedPointer<QRasterBuffer> rasterBuffer;
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue