From dc82a0f4f3a380edfe910a78f3bdd32210975b85 Mon Sep 17 00:00:00 2001 From: Allan Sandfeld Jensen Date: Thu, 21 Jun 2018 13:18:30 +0200 Subject: Smooth image scaling for 64bit images Adds support for smooth scaling 64bit images. Task-number: QTBUG-45858 Change-Id: If46030fb8e7d684159f852a3b8266a74e5e6700c Reviewed-by: Eirik Aavitsland --- src/gui/painting/qimagescale.cpp | 235 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 218 insertions(+), 17 deletions(-) (limited to 'src/gui/painting/qimagescale.cpp') diff --git a/src/gui/painting/qimagescale.cpp b/src/gui/painting/qimagescale.cpp index 22787b91fe..ca7930500e 100644 --- a/src/gui/painting/qimagescale.cpp +++ b/src/gui/painting/qimagescale.cpp @@ -41,6 +41,7 @@ #include "qimage.h" #include "qcolor.h" +#include "qrgba64_p.h" QT_BEGIN_NAMESPACE @@ -85,7 +86,7 @@ QT_BEGIN_NAMESPACE * #ifdef'ed code, and removal of unneeded border calculation code. * Later the code has been refactored, an SSE4.1 optimizated path have been * added instead of the removed MMX assembler, and scaling of clipped area - * removed. + * removed, and an RGBA64 version written * * Imlib2 is (C) Carsten Haitzler and various contributors. The MMX code * is by Willem Monsuwe . All other modifications are @@ -94,12 +95,11 @@ QT_BEGIN_NAMESPACE namespace QImageScale { - const unsigned int** qimageCalcYPoints(const unsigned int *src, int sw, int sh, int dh); - int* qimageCalcXPoints(int sw, int dw); - int* qimageCalcApoints(int s, int d, int up); - QImageScaleInfo* qimageFreeScaleInfo(QImageScaleInfo *isi); - QImageScaleInfo *qimageCalcScaleInfo(const QImage &img, int sw, int sh, - int dw, int dh, char aa); + static const unsigned int** qimageCalcYPoints(const unsigned int *src, int sw, int sh, int dh); + static int* qimageCalcXPoints(int sw, int dw); + static int* qimageCalcApoints(int s, int d, int up); + static QImageScaleInfo* qimageFreeScaleInfo(QImageScaleInfo *isi); + static QImageScaleInfo *qimageCalcScaleInfo(const QImage &img, int sw, int sh, int dw, int dh, char aa); } using namespace QImageScale; @@ -108,8 +108,8 @@ using namespace QImageScale; // Code ported from Imlib... // -const unsigned int** QImageScale::qimageCalcYPoints(const unsigned int *src, - int sw, int sh, int dh) +static const unsigned int** QImageScale::qimageCalcYPoints(const unsigned int *src, + int sw, int sh, int dh) { const unsigned int **p; int j = 0, rv = 0; @@ -138,7 +138,7 @@ const unsigned int** QImageScale::qimageCalcYPoints(const unsigned int *src, return(p); } -int* QImageScale::qimageCalcXPoints(int sw, int dw) +static int* QImageScale::qimageCalcXPoints(int sw, int dw) { int *p, j = 0, rv = 0; qint64 val, inc; @@ -167,7 +167,7 @@ int* QImageScale::qimageCalcXPoints(int sw, int dw) return p; } -int* QImageScale::qimageCalcApoints(int s, int d, int up) +static int* QImageScale::qimageCalcApoints(int s, int d, int up) { int *p, j = 0, rv = 0; @@ -214,7 +214,7 @@ int* QImageScale::qimageCalcApoints(int s, int d, int up) return p; } -QImageScaleInfo* QImageScale::qimageFreeScaleInfo(QImageScaleInfo *isi) +static QImageScaleInfo* QImageScale::qimageFreeScaleInfo(QImageScaleInfo *isi) { if (isi) { delete[] isi->xpoints; @@ -226,9 +226,9 @@ QImageScaleInfo* QImageScale::qimageFreeScaleInfo(QImageScaleInfo *isi) return 0; } -QImageScaleInfo* QImageScale::qimageCalcScaleInfo(const QImage &img, - int sw, int sh, - int dw, int dh, char aa) +static QImageScaleInfo* QImageScale::qimageCalcScaleInfo(const QImage &img, + int sw, int sh, + int dw, int dh, char aa) { QImageScaleInfo *isi; int scw, sch; @@ -333,7 +333,7 @@ static void qt_qimageScaleAARGBA_up_xy(QImageScaleInfo *isi, unsigned int *dest, } } -/* scale by area sampling */ +/* scale by area sampling - with alpha */ static void qt_qimageScaleAARGBA(QImageScaleInfo *isi, unsigned int *dest, int dw, int dh, int dow, int sow) { @@ -529,6 +529,204 @@ static void qt_qimageScaleAARGBA_down_xy(QImageScaleInfo *isi, unsigned int *des } } +static void qt_qimageScaleRgba64_up_x_down_y(QImageScaleInfo *isi, QRgba64 *dest, + int dw, int dh, int dow, int sow); + +static void qt_qimageScaleRgba64_down_x_up_y(QImageScaleInfo *isi, QRgba64 *dest, + int dw, int dh, int dow, int sow); + +static void qt_qimageScaleRgba64_down_xy(QImageScaleInfo *isi, QRgba64 *dest, + int dw, int dh, int dow, int sow); + +static void qt_qimageScaleRgba64_up_xy(QImageScaleInfo *isi, QRgba64 *dest, + int dw, int dh, int dow, int sow) +{ + const QRgba64 **ypoints = (const QRgba64 **)isi->ypoints; + int *xpoints = isi->xpoints; + int *xapoints = isi->xapoints; + int *yapoints = isi->yapoints; + + for (int y = 0; y < dh; y++) { + const QRgba64 *sptr = ypoints[y]; + QRgba64 *dptr = dest + (y * dow); + const int yap = yapoints[y]; + if (yap > 0) { + for (int x = 0; x < dw; x++) { + const QRgba64 *pix = sptr + xpoints[x]; + const int xap = xapoints[x]; + if (xap > 0) + *dptr = interpolate_4_pixels_rgb64(pix, pix + sow, xap * 256, yap * 256); + else + *dptr = interpolate256(pix[0], 256 - yap, pix[sow], yap); + dptr++; + } + } else { + for (int x = 0; x < dw; x++) { + const QRgba64 *pix = sptr + xpoints[x]; + const int xap = xapoints[x]; + *dptr = interpolate256(pix[0], 256 - xap, pix[1], xap); + dptr++; + } + } + } +} + +void qt_qimageScaleRgba64(QImageScaleInfo *isi, QRgba64 *dest, + int dw, int dh, int dow, int sow) +{ + if (isi->xup_yup == 3) + qt_qimageScaleRgba64_up_xy(isi, dest, dw, dh, dow, sow); + else if (isi->xup_yup == 1) + qt_qimageScaleRgba64_up_x_down_y(isi, dest, dw, dh, dow, sow); + else if (isi->xup_yup == 2) + qt_qimageScaleRgba64_down_x_up_y(isi, dest, dw, dh, dow, sow); + else + qt_qimageScaleRgba64_down_xy(isi, dest, dw, dh, dow, sow); +} + +inline static void qt_qimageScaleRgba64_helper(const QRgba64 *pix, int xyap, int Cxy, int step, qint64 &r, qint64 &g, qint64 &b, qint64 &a) +{ + r = pix->red() * xyap; + g = pix->green() * xyap; + b = pix->blue() * xyap; + a = pix->alpha() * xyap; + int j; + for (j = (1 << 14) - xyap; j > Cxy; j -= Cxy ){ + pix += step; + r += pix->red() * Cxy; + g += pix->green() * Cxy; + b += pix->blue() * Cxy; + a += pix->alpha() * Cxy; + } + pix += step; + r += pix->red() * j; + g += pix->green() * j; + b += pix->blue() * j; + a += pix->alpha() * j; +} + +static void qt_qimageScaleRgba64_up_x_down_y(QImageScaleInfo *isi, QRgba64 *dest, + int dw, int dh, int dow, int sow) +{ + const QRgba64 **ypoints = (const QRgba64 **)isi->ypoints; + int *xpoints = isi->xpoints; + int *xapoints = isi->xapoints; + int *yapoints = isi->yapoints; + + for (int y = 0; y < dh; y++) { + int Cy = (yapoints[y]) >> 16; + int yap = (yapoints[y]) & 0xffff; + + QRgba64 *dptr = dest + (y * dow); + for (int x = 0; x < dw; x++) { + const QRgba64 *sptr = ypoints[y] + xpoints[x]; + qint64 r, g, b, a; + qt_qimageScaleRgba64_helper(sptr, yap, Cy, sow, r, g, b, a); + + int xap = xapoints[x]; + if (xap > 0) { + qint64 rr, gg, bb, aa; + qt_qimageScaleRgba64_helper(sptr + 1, yap, Cy, sow, rr, gg, bb, aa); + + r = r * (256 - xap); + g = g * (256 - xap); + b = b * (256 - xap); + a = a * (256 - xap); + r = (r + (rr * xap)) >> 8; + g = (g + (gg * xap)) >> 8; + b = (b + (bb * xap)) >> 8; + a = (a + (aa * xap)) >> 8; + } + *dptr++ = qRgba64(r >> 14, g >> 14, b >> 14, a >> 14); + } + } +} + +static void qt_qimageScaleRgba64_down_x_up_y(QImageScaleInfo *isi, QRgba64 *dest, + int dw, int dh, int dow, int sow) +{ + const QRgba64 **ypoints = (const QRgba64 **)isi->ypoints; + int *xpoints = isi->xpoints; + int *xapoints = isi->xapoints; + int *yapoints = isi->yapoints; + + for (int y = 0; y < dh; y++) { + QRgba64 *dptr = dest + (y * dow); + for (int x = 0; x < dw; x++) { + int Cx = xapoints[x] >> 16; + int xap = xapoints[x] & 0xffff; + + const QRgba64 *sptr = ypoints[y] + xpoints[x]; + qint64 r, g, b, a; + qt_qimageScaleRgba64_helper(sptr, xap, Cx, 1, r, g, b, a); + + int yap = yapoints[y]; + if (yap > 0) { + qint64 rr, gg, bb, aa; + qt_qimageScaleRgba64_helper(sptr + sow, xap, Cx, 1, rr, gg, bb, aa); + + r = r * (256 - yap); + g = g * (256 - yap); + b = b * (256 - yap); + a = a * (256 - yap); + r = (r + (rr * yap)) >> 8; + g = (g + (gg * yap)) >> 8; + b = (b + (bb * yap)) >> 8; + a = (a + (aa * yap)) >> 8; + } + *dptr = qRgba64(r >> 14, g >> 14, b >> 14, a >> 14); + dptr++; + } + } +} + +static void qt_qimageScaleRgba64_down_xy(QImageScaleInfo *isi, QRgba64 *dest, + int dw, int dh, int dow, int sow) +{ + const QRgba64 **ypoints = (const QRgba64 **)isi->ypoints; + int *xpoints = isi->xpoints; + int *xapoints = isi->xapoints; + int *yapoints = isi->yapoints; + + for (int y = 0; y < dh; y++) { + int Cy = (yapoints[y]) >> 16; + int yap = (yapoints[y]) & 0xffff; + + QRgba64 *dptr = dest + (y * dow); + for (int x = 0; x < dw; x++) { + int Cx = xapoints[x] >> 16; + int xap = xapoints[x] & 0xffff; + + const QRgba64 *sptr = ypoints[y] + xpoints[x]; + qint64 rx, gx, bx, ax; + qt_qimageScaleRgba64_helper(sptr, xap, Cx, 1, rx, gx, bx, ax); + + qint64 r = rx * yap; + qint64 g = gx * yap; + qint64 b = bx * yap; + qint64 a = ax * yap; + int j; + for (j = (1 << 14) - yap; j > Cy; j -= Cy) { + sptr += sow; + qt_qimageScaleRgba64_helper(sptr, xap, Cx, 1, rx, gx, bx, ax); + r += rx * Cy; + g += gx * Cy; + b += bx * Cy; + a += ax * Cy; + } + sptr += sow; + qt_qimageScaleRgba64_helper(sptr, xap, Cx, 1, rx, gx, bx, ax); + r += rx * j; + g += gx * j; + b += bx * j; + a += ax * j; + + *dptr = qRgba64(r >> 28, g >> 28, b >> 28, a >> 28); + dptr++; + } + } +} + static void qt_qimageScaleAARGB_up_x_down_y(QImageScaleInfo *isi, unsigned int *dest, int dw, int dh, int dow, int sow); @@ -745,7 +943,10 @@ QImage qSmoothScaleImage(const QImage &src, int dw, int dh) return QImage(); } - if (src.hasAlphaChannel()) + if (src.depth() > 32) + qt_qimageScaleRgba64(scaleinfo, (QRgba64 *)buffer.scanLine(0), + dw, dh, dw, src.bytesPerLine() / 8); + else if (src.hasAlphaChannel()) qt_qimageScaleAARGBA(scaleinfo, (unsigned int *)buffer.scanLine(0), dw, dh, dw, src.bytesPerLine() / 4); else -- cgit v1.2.3