Smooth image scaling for 64bit images

Adds support for smooth scaling 64bit images.

Task-number: QTBUG-45858
Change-Id: If46030fb8e7d684159f852a3b8266a74e5e6700c
Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>

1 files changed, 218 insertions, 17 deletions

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 <willem@stack.nl>. 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