Remove unused and unneeded subimage scaling

Removes the feature of scaling only a clipped area of the input
which was unused and only made the code harder to read and
maintain.

Change-Id: I296a804a5bd083016fbc47543e00eb586b530d71
Reviewed-by: Gunnar Sletta <gunnar@sletta.org>

2 files changed, 75 insertions, 119 deletions

diff --git a/src/gui/painting/qimagescale.cpp b/src/gui/painting/qimagescale.cpp
index 867c64c5e0..7b6a71737d 100644
--- a/src/gui/painting/qimagescale.cpp
+++ b/src/gui/painting/qimagescale.cpp
@@ -77,8 +77,9 @@ QT_BEGIN_NAMESPACE
  *
  * Changes include formatting, namespaces and other C++'ings, removal of old
  * #ifdef'ed code, and removal of unneeded border calculation code.
- * Later the code has been refactored and an SSE4.1 optimizated path have been
- * added instead of the removed MMX assembler.
+ * 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.
  *
  * Imlib2 is (C) Carsten Haitzler and various contributors. The MMX code
  * is by Willem Monsuwe <willem@stack.nl>. All other modifications are
@@ -256,34 +257,27 @@ QImageScaleInfo* QImageScale::qimageCalcScaleInfo(const QImage &img,
 
 
 static void qt_qimageScaleAARGBA_up_x_down_y(QImageScaleInfo *isi, unsigned int *dest,
-                                             int dxx, int dyy, int dx, int dy,
                                              int dw, int dh, int dow, int sow);
 
 static void qt_qimageScaleAARGBA_down_x_up_y(QImageScaleInfo *isi, unsigned int *dest,
-                                             int dxx, int dyy, int dx, int dy,
                                              int dw, int dh, int dow, int sow);
 
 static void qt_qimageScaleAARGBA_down_xy(QImageScaleInfo *isi, unsigned int *dest,
-                                         int dxx, int dyy, int dx, int dy, int dw,
-                                         int dh, int dow, int sow);
+                                         int dw, int dh, int dow, int sow);
 
 #if defined(QT_COMPILER_SUPPORTS_SSE4_1)
 template<bool RGB>
 void qt_qimageScaleAARGBA_up_x_down_y_sse4(QImageScaleInfo *isi, unsigned int *dest,
-                                           int dxx, int dyy, int dx, int dy,
                                            int dw, int dh, int dow, int sow);
 template<bool RGB>
 void qt_qimageScaleAARGBA_down_x_up_y_sse4(QImageScaleInfo *isi, unsigned int *dest,
-                                           int dxx, int dyy, int dx, int dy,
                                            int dw, int dh, int dow, int sow);
 template<bool RGB>
 void qt_qimageScaleAARGBA_down_xy_sse4(QImageScaleInfo *isi, unsigned int *dest,
-                                       int dxx, int dyy, int dx, int dy,
                                        int dw, int dh, int dow, int sow);
 #endif
 
 static void qt_qimageScaleAARGBA_up_xy(QImageScaleInfo *isi, unsigned int *dest,
-                                       int dxx, int dyy, int dx, int dy,
                                        int dw, int dh, int dow, int sow)
 {
     const unsigned int **ypoints = isi->ypoints;
@@ -291,15 +285,14 @@ static void qt_qimageScaleAARGBA_up_xy(QImageScaleInfo *isi, unsigned int *dest,
     int *xapoints = isi->xapoints;
     int *yapoints = isi->yapoints;
 
-    int end = dxx + dw;
     /* go through every scanline in the output buffer */
     for (int y = 0; y < dh; y++) {
         /* calculate the source line we'll scan from */
-        const unsigned int *sptr = ypoints[dyy + y];
-        unsigned int *dptr = dest + dx + ((y + dy) * dow);
-        const int yap = yapoints[dyy + y];
+        const unsigned int *sptr = ypoints[y];
+        unsigned int *dptr = dest + (y * dow);
+        const int yap = yapoints[y];
         if (yap > 0) {
-            for (int x = dxx; x < end; x++) {
+            for (int x = 0; x < dw; x++) {
                 const unsigned int *pix = sptr + xpoints[x];
                 const int xap = xapoints[x];
                 if (xap > 0)
@@ -309,7 +302,7 @@ static void qt_qimageScaleAARGBA_up_xy(QImageScaleInfo *isi, unsigned int *dest,
                 dptr++;
             }
         } else {
-            for (int x = dxx; x < end; x++) {
+            for (int x = 0; x < dw; x++) {
                 const unsigned int *pix = sptr + xpoints[x];
                 const int xap = xapoints[x];
                 *dptr = INTERPOLATE_PIXEL_256(pix[0], 256 - xap, pix[1], xap);
@@ -321,39 +314,38 @@ static void qt_qimageScaleAARGBA_up_xy(QImageScaleInfo *isi, unsigned int *dest,
 
 /* scale by area sampling */
 static void qt_qimageScaleAARGBA(QImageScaleInfo *isi, unsigned int *dest,
-                                 int dxx, int dyy, int dx, int dy, int dw,
-                                 int dh, int dow, int sow)
+                                 int dw, int dh, int dow, int sow)
 {
     /* scaling up both ways */
     if (isi->xup_yup == 3) {
-        qt_qimageScaleAARGBA_up_xy(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+        qt_qimageScaleAARGBA_up_xy(isi, dest, dw, dh, dow, sow);
     }
     /* if we're scaling down vertically */
     else if (isi->xup_yup == 1) {
 #ifdef QT_COMPILER_SUPPORTS_SSE4_1
         if (qCpuHasFeature(SSE4_1))
-            qt_qimageScaleAARGBA_up_x_down_y_sse4<false>(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+            qt_qimageScaleAARGBA_up_x_down_y_sse4<false>(isi, dest, dw, dh, dow, sow);
         else
 #endif
-        qt_qimageScaleAARGBA_up_x_down_y(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+        qt_qimageScaleAARGBA_up_x_down_y(isi, dest, dw, dh, dow, sow);
     }
     /* if we're scaling down horizontally */
     else if (isi->xup_yup == 2) {
 #ifdef QT_COMPILER_SUPPORTS_SSE4_1
         if (qCpuHasFeature(SSE4_1))
-            qt_qimageScaleAARGBA_down_x_up_y_sse4<false>(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+            qt_qimageScaleAARGBA_down_x_up_y_sse4<false>(isi, dest, dw, dh, dow, sow);
         else
 #endif
-        qt_qimageScaleAARGBA_down_x_up_y(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+        qt_qimageScaleAARGBA_down_x_up_y(isi, dest, dw, dh, dow, sow);
     }
     /* if we're scaling down horizontally & vertically */
     else {
 #ifdef QT_COMPILER_SUPPORTS_SSE4_1
         if (qCpuHasFeature(SSE4_1))
-            qt_qimageScaleAARGBA_down_xy_sse4<false>(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+            qt_qimageScaleAARGBA_down_xy_sse4<false>(isi, dest, dw, dh, dow, sow);
         else
 #endif
-        qt_qimageScaleAARGBA_down_xy(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+        qt_qimageScaleAARGBA_down_xy(isi, dest, dw, dh, dow, sow);
     }
 }
 
@@ -379,7 +371,6 @@ inline static void qt_qimageScaleAARGBA_helper(const unsigned int *pix, int xyap
 }
 
 static void qt_qimageScaleAARGBA_up_x_down_y(QImageScaleInfo *isi, unsigned int *dest,
-                                             int dxx, int dyy, int dx, int dy,
                                              int dw, int dh, int dow, int sow)
 {
     const unsigned int **ypoints = isi->ypoints;
@@ -387,16 +378,14 @@ static void qt_qimageScaleAARGBA_up_x_down_y(QImageScaleInfo *isi, unsigned int
     int *xapoints = isi->xapoints;
     int *yapoints = isi->yapoints;
 
-    int end = dxx + dw;
-
     /* go through every scanline in the output buffer */
     for (int y = 0; y < dh; y++) {
-        int Cy = (yapoints[dyy + y]) >> 16;
-        int yap = (yapoints[dyy + y]) & 0xffff;
+        int Cy = yapoints[y] >> 16;
+        int yap = yapoints[y] & 0xffff;
 
-        unsigned int *dptr = dest + dx + ((y + dy) * dow);
-        for (int x = dxx; x < end; x++) {
-            const unsigned int *sptr = ypoints[dyy + y] + xpoints[x];
+        unsigned int *dptr = dest + (y * dow);
+        for (int x = 0; x < dw; x++) {
+            const unsigned int *sptr = ypoints[y] + xpoints[x];
             int r, g, b, a;
             qt_qimageScaleAARGBA_helper(sptr, yap, Cy, sow, r, g, b, a);
 
@@ -420,7 +409,6 @@ static void qt_qimageScaleAARGBA_up_x_down_y(QImageScaleInfo *isi, unsigned int
 }
 
 static void qt_qimageScaleAARGBA_down_x_up_y(QImageScaleInfo *isi, unsigned int *dest,
-                                             int dxx, int dyy, int dx, int dy,
                                              int dw, int dh, int dow, int sow)
 {
     const unsigned int **ypoints = isi->ypoints;
@@ -428,20 +416,18 @@ static void qt_qimageScaleAARGBA_down_x_up_y(QImageScaleInfo *isi, unsigned int
     int *xapoints = isi->xapoints;
     int *yapoints = isi->yapoints;
 
-    int end = dxx + dw;
-
     /* go through every scanline in the output buffer */
     for (int y = 0; y < dh; y++) {
-        unsigned int *dptr = dest + dx + ((y + dy) * dow);
-        for (int x = dxx; x < end; x++) {
+        unsigned int *dptr = dest + (y * dow);
+        for (int x = 0; x < dw; x++) {
             int Cx = xapoints[x] >> 16;
             int xap = xapoints[x] & 0xffff;
 
-            const unsigned int *sptr = ypoints[dyy + y] + xpoints[x];
+            const unsigned int *sptr = ypoints[y] + xpoints[x];
             int r, g, b, a;
             qt_qimageScaleAARGBA_helper(sptr, xap, Cx, 1, r, g, b, a);
 
-            int yap = yapoints[dyy + y];
+            int yap = yapoints[y];
             if (yap > 0) {
                 int rr, gg, bb, aa;
                 qt_qimageScaleAARGBA_helper(sptr + sow, xap, Cx, 1, rr, gg, bb, aa);
@@ -462,26 +448,23 @@ static void qt_qimageScaleAARGBA_down_x_up_y(QImageScaleInfo *isi, unsigned int
 }
 
 static void qt_qimageScaleAARGBA_down_xy(QImageScaleInfo *isi, unsigned int *dest,
-                                         int dxx, int dyy, int dx, int dy, int dw,
-                                         int dh, int dow, int sow)
+                                         int dw, int dh, int dow, int sow)
 {
     const unsigned int **ypoints = isi->ypoints;
     int *xpoints = isi->xpoints;
     int *xapoints = isi->xapoints;
     int *yapoints = isi->yapoints;
 
-    int end = dxx + dw;
-
     for (int y = 0; y < dh; y++) {
-        int Cy = (yapoints[dyy + y]) >> 16;
-        int yap = (yapoints[dyy + y]) & 0xffff;
+        int Cy = (yapoints[y]) >> 16;
+        int yap = (yapoints[y]) & 0xffff;
 
-        unsigned int *dptr = dest + dx + ((y + dy) * dow);
-        for (int x = dxx; x < end; x++) {
+        unsigned int *dptr = dest + (y * dow);
+        for (int x = 0; x < dw; x++) {
             int Cx = xapoints[x] >> 16;
             int xap = xapoints[x] & 0xffff;
 
-            const unsigned int *sptr = ypoints[dyy + y] + xpoints[x];
+            const unsigned int *sptr = ypoints[y] + xpoints[x];
             int rx, gx, bx, ax;
             qt_qimageScaleAARGBA_helper(sptr, xap, Cx, 1, rx, gx, bx, ax);
 
@@ -514,52 +497,48 @@ static void qt_qimageScaleAARGBA_down_xy(QImageScaleInfo *isi, unsigned int *des
 }
 
 static void qt_qimageScaleAARGB_up_x_down_y(QImageScaleInfo *isi, unsigned int *dest,
-                                            int dxx, int dyy, int dx, int dy, int dw,
-                                            int dh, int dow, int sow);
+                                            int dw, int dh, int dow, int sow);
 
 static void qt_qimageScaleAARGB_down_x_up_y(QImageScaleInfo *isi, unsigned int *dest,
-                                            int dxx, int dyy, int dx, int dy, int dw,
-                                            int dh, int dow, int sow);
+                                            int dw, int dh, int dow, int sow);
 
 static void qt_qimageScaleAARGB_down_xy(QImageScaleInfo *isi, unsigned int *dest,
-                                        int dxx, int dyy, int dx, int dy, int dw,
-                                        int dh, int dow, int sow);
+                                        int dw, int dh, int dow, int sow);
 
 /* scale by area sampling - IGNORE the ALPHA byte*/
 static void qt_qimageScaleAARGB(QImageScaleInfo *isi, unsigned int *dest,
-                                int dxx, int dyy, int dx, int dy,
                                 int dw, int dh, int dow, int sow)
 {
     /* scaling up both ways */
     if (isi->xup_yup == 3) {
-        qt_qimageScaleAARGBA_up_xy(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+        qt_qimageScaleAARGBA_up_xy(isi, dest, dw, dh, dow, sow);
     }
     /* if we're scaling down vertically */
     else if (isi->xup_yup == 1) {
 #ifdef QT_COMPILER_SUPPORTS_SSE4_1
         if (qCpuHasFeature(SSE4_1))
-            qt_qimageScaleAARGBA_up_x_down_y_sse4<true>(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+            qt_qimageScaleAARGBA_up_x_down_y_sse4<true>(isi, dest, dw, dh, dow, sow);
         else
 #endif
-        qt_qimageScaleAARGB_up_x_down_y(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+        qt_qimageScaleAARGB_up_x_down_y(isi, dest, dw, dh, dow, sow);
     }
     /* if we're scaling down horizontally */
     else if (isi->xup_yup == 2) {
 #ifdef QT_COMPILER_SUPPORTS_SSE4_1
         if (qCpuHasFeature(SSE4_1))
-            qt_qimageScaleAARGBA_down_x_up_y_sse4<true>(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+            qt_qimageScaleAARGBA_down_x_up_y_sse4<true>(isi, dest, dw, dh, dow, sow);
         else
 #endif
-        qt_qimageScaleAARGB_down_x_up_y(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+        qt_qimageScaleAARGB_down_x_up_y(isi, dest, dw, dh, dow, sow);
     }
     /* if we're scaling down horizontally & vertically */
     else {
 #ifdef QT_COMPILER_SUPPORTS_SSE4_1
         if (qCpuHasFeature(SSE4_1))
-            qt_qimageScaleAARGBA_down_xy_sse4<true>(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+            qt_qimageScaleAARGBA_down_xy_sse4<true>(isi, dest, dw, dh, dow, sow);
         else
 #endif
-        qt_qimageScaleAARGB_down_xy(isi, dest, dxx, dyy, dx, dy, dw, dh, dow, sow);
+        qt_qimageScaleAARGB_down_xy(isi, dest, dw, dh, dow, sow);
     }
 }
 
@@ -583,24 +562,21 @@ inline static void qt_qimageScaleAARGB_helper(const unsigned int *pix, int xyap,
 }
 
 static void qt_qimageScaleAARGB_up_x_down_y(QImageScaleInfo *isi, unsigned int *dest,
-                                            int dxx, int dyy, int dx, int dy, int dw,
-                                            int dh, int dow, int sow)
+                                            int dw, int dh, int dow, int sow)
 {
     const unsigned int **ypoints = isi->ypoints;
     int *xpoints = isi->xpoints;
     int *xapoints = isi->xapoints;
     int *yapoints = isi->yapoints;
 
-    int end = dxx + dw;
-
     /* go through every scanline in the output buffer */
     for (int y = 0; y < dh; y++) {
-        int Cy = (yapoints[dyy + y]) >> 16;
-        int yap = (yapoints[dyy + y]) & 0xffff;
+        int Cy = yapoints[y] >> 16;
+        int yap = yapoints[y] & 0xffff;
 
-        unsigned int *dptr = dest + dx + ((y + dy) * dow);
-        for (int x = dxx; x < end; x++) {
-            const unsigned int *sptr = ypoints[dyy + y] + xpoints[x];
+        unsigned int *dptr = dest + (y * dow);
+        for (int x = 0; x < dw; x++) {
+            const unsigned int *sptr = ypoints[y] + xpoints[x];
             int r, g, b;
             qt_qimageScaleAARGB_helper(sptr, yap, Cy, sow, r, g, b);
 
@@ -622,28 +598,25 @@ static void qt_qimageScaleAARGB_up_x_down_y(QImageScaleInfo *isi, unsigned int *
 }
 
 static void qt_qimageScaleAARGB_down_x_up_y(QImageScaleInfo *isi, unsigned int *dest,
-                                            int dxx, int dyy, int dx, int dy, int dw,
-                                            int dh, int dow, int sow)
+                                            int dw, int dh, int dow, int sow)
 {
     const unsigned int **ypoints = isi->ypoints;
     int *xpoints = isi->xpoints;
     int *xapoints = isi->xapoints;
     int *yapoints = isi->yapoints;
 
-    int end = dxx + dw;
-
     /* go through every scanline in the output buffer */
     for (int y = 0; y < dh; y++) {
-        unsigned int *dptr = dest + dx + ((y + dy) * dow);
-        for (int x = dxx; x < end; x++) {
+        unsigned int *dptr = dest + (y * dow);
+        for (int x = 0; x < dw; x++) {
             int Cx = xapoints[x] >> 16;
             int xap = xapoints[x] & 0xffff;
 
-            const unsigned int *sptr = ypoints[dyy + y] + xpoints[x];
+            const unsigned int *sptr = ypoints[y] + xpoints[x];
             int r, g, b;
             qt_qimageScaleAARGB_helper(sptr, xap, Cx, 1, r, g, b);
 
-            int yap = yapoints[dyy + y];
+            int yap = yapoints[y];
             if (yap > 0) {
                 int rr, bb, gg;
                 qt_qimageScaleAARGB_helper(sptr + sow, xap, Cx, 1, rr, gg, bb);
@@ -661,26 +634,23 @@ static void qt_qimageScaleAARGB_down_x_up_y(QImageScaleInfo *isi, unsigned int *
 }
 
 static void qt_qimageScaleAARGB_down_xy(QImageScaleInfo *isi, unsigned int *dest,
-                                        int dxx, int dyy, int dx, int dy, int dw,
-                                        int dh, int dow, int sow)
+                                        int dw, int dh, int dow, int sow)
 {
     const unsigned int **ypoints = isi->ypoints;
     int *xpoints = isi->xpoints;
     int *xapoints = isi->xapoints;
     int *yapoints = isi->yapoints;
 
-    int end = dxx + dw;
-
     for (int y = 0; y < dh; y++) {
-        int Cy = (yapoints[dyy + y]) >> 16;
-        int yap = (yapoints[dyy + y]) & 0xffff;
+        int Cy = yapoints[y] >> 16;
+        int yap = yapoints[y] & 0xffff;
 
-        unsigned int *dptr = dest + dx + ((y + dy) * dow);
-        for (int x = dxx; x < end; x++) {
+        unsigned int *dptr = dest + (y * dow);
+        for (int x = 0; x < dw; x++) {
             int Cx = xapoints[x] >> 16;
             int xap = xapoints[x] & 0xffff;
 
-            const unsigned int *sptr = ypoints[dyy + y] + xpoints[x];
+            const unsigned int *sptr = ypoints[y] + xpoints[x];
             int rx, gx, bx;
             qt_qimageScaleAARGB_helper(sptr, xap, Cx, 1, rx, gx, bx);
 
@@ -732,10 +702,10 @@ QImage qSmoothScaleImage(const QImage &src, int dw, int dh)
 
     if (src.hasAlphaChannel())
         qt_qimageScaleAARGBA(scaleinfo, (unsigned int *)buffer.scanLine(0),
-                             0, 0, 0, 0, dw, dh, dw, src.bytesPerLine() / 4);
+                             dw, dh, dw, src.bytesPerLine() / 4);
     else
         qt_qimageScaleAARGB(scaleinfo, (unsigned int *)buffer.scanLine(0),
-                            0, 0, 0, 0, dw, dh, dw, src.bytesPerLine() / 4);
+                            dw, dh, dw, src.bytesPerLine() / 4);
 
     qimageFreeScaleInfo(scaleinfo);
     return buffer;
diff --git a/src/gui/painting/qimagescale_sse4.cpp b/src/gui/painting/qimagescale_sse4.cpp
index 303e0fd980..8712b5d324 100644
--- a/src/gui/painting/qimagescale_sse4.cpp
+++ b/src/gui/painting/qimagescale_sse4.cpp
@@ -59,7 +59,6 @@ inline static __m128i qt_qimageScaleAARGBA_helper(const unsigned int *pix, int x
 
 template<bool RGB>
 void qt_qimageScaleAARGBA_up_x_down_y_sse4(QImageScaleInfo *isi, unsigned int *dest,
-                                           int dxx, int dyy, int dx, int dy,
                                            int dw, int dh, int dow, int sow)
 {
     const unsigned int **ypoints = isi->ypoints;
@@ -67,20 +66,18 @@ void qt_qimageScaleAARGBA_up_x_down_y_sse4(QImageScaleInfo *isi, unsigned int *d
     int *xapoints = isi->xapoints;
     int *yapoints = isi->yapoints;
 
-    int end = dxx + dw;
-
     const __m128i v256 = _mm_set1_epi32(256);
 
     /* go through every scanline in the output buffer */
     for (int y = 0; y < dh; y++) {
-        int Cy = (yapoints[dyy + y]) >> 16;
-        int yap = (yapoints[dyy + y]) & 0xffff;
+        int Cy = yapoints[y] >> 16;
+        int yap = yapoints[y] & 0xffff;
         const __m128i vCy = _mm_set1_epi32(Cy);
         const __m128i vyap = _mm_set1_epi32(yap);
 
-        unsigned int *dptr = dest + dx + ((y + dy) * dow);
-        for (int x = dxx; x < end; x++) {
-            const unsigned int *sptr = ypoints[dyy + y] + xpoints[x];
+        unsigned int *dptr = dest + (y * dow);
+        for (int x = 0; x < dw; x++) {
+            const unsigned int *sptr = ypoints[y] + xpoints[x];
             __m128i vx = qt_qimageScaleAARGBA_helper(sptr, yap, Cy, sow, vyap, vCy);
 
             int xap = xapoints[x];
@@ -107,7 +104,6 @@ void qt_qimageScaleAARGBA_up_x_down_y_sse4(QImageScaleInfo *isi, unsigned int *d
 
 template<bool RGB>
 void qt_qimageScaleAARGBA_down_x_up_y_sse4(QImageScaleInfo *isi, unsigned int *dest,
-                                           int dxx, int dyy, int dx, int dy,
                                            int dw, int dh, int dow, int sow)
 {
     const unsigned int **ypoints = isi->ypoints;
@@ -115,23 +111,21 @@ void qt_qimageScaleAARGBA_down_x_up_y_sse4(QImageScaleInfo *isi, unsigned int *d
     int *xapoints = isi->xapoints;
     int *yapoints = isi->yapoints;
 
-    int end = dxx + dw;
-
     const __m128i v256 = _mm_set1_epi32(256);
 
     /* go through every scanline in the output buffer */
     for (int y = 0; y < dh; y++) {
-        unsigned int *dptr = dest + dx + ((y + dy) * dow);
-        for (int x = dxx; x < end; x++) {
+        unsigned int *dptr = dest + (y * dow);
+        for (int x = 0; x < dw; x++) {
             int Cx = xapoints[x] >> 16;
             int xap = xapoints[x] & 0xffff;
             const __m128i vCx = _mm_set1_epi32(Cx);
             const __m128i vxap = _mm_set1_epi32(xap);
 
-            const unsigned int *sptr = ypoints[dyy + y] + xpoints[x];
+            const unsigned int *sptr = ypoints[y] + xpoints[x];
             __m128i vx = qt_qimageScaleAARGBA_helper(sptr, xap, Cx, 1, vxap, vCx);
 
-            int yap = yapoints[dyy + y];
+            int yap = yapoints[y];
             if (yap > 0) {
                 const __m128i vyap = _mm_set1_epi32(yap);
                 const __m128i vinvyap = _mm_sub_epi32(v256, vyap);
@@ -155,7 +149,6 @@ void qt_qimageScaleAARGBA_down_x_up_y_sse4(QImageScaleInfo *isi, unsigned int *d
 
 template<bool RGB>
 void qt_qimageScaleAARGBA_down_xy_sse4(QImageScaleInfo *isi, unsigned int *dest,
-                                       int dxx, int dyy, int dx, int dy,
                                        int dw, int dh, int dow, int sow)
 {
     const unsigned int **ypoints = isi->ypoints;
@@ -164,20 +157,19 @@ void qt_qimageScaleAARGBA_down_xy_sse4(QImageScaleInfo *isi, unsigned int *dest,
     int *yapoints = isi->yapoints;
 
     for (int y = 0; y < dh; y++) {
-        int Cy = (yapoints[dyy + y]) >> 16;
-        int yap = (yapoints[dyy + y]) & 0xffff;
+        int Cy = yapoints[y] >> 16;
+        int yap = yapoints[y] & 0xffff;
         const __m128i vCy = _mm_set1_epi32(Cy);
         const __m128i vyap = _mm_set1_epi32(yap);
 
-        unsigned int *dptr = dest + dx + ((y + dy) * dow);
-        int end = dxx + dw;
-        for (int x = dxx; x < end; x++) {
+        unsigned int *dptr = dest + (y * dow);
+        for (int x = 0; x < dw; x++) {
             const int Cx = xapoints[x] >> 16;
             const int xap = xapoints[x] & 0xffff;
             const __m128i vCx = _mm_set1_epi32(Cx);
             const __m128i vxap = _mm_set1_epi32(xap);
 
-            const unsigned int *sptr = ypoints[dyy + y] + xpoints[x];
+            const unsigned int *sptr = ypoints[y] + xpoints[x];
             __m128i vx = qt_qimageScaleAARGBA_helper(sptr, xap, Cx, 1, vxap, vCx);
             __m128i vr = _mm_mullo_epi32(_mm_srli_epi32(vx, 4), vyap);
 
@@ -203,27 +195,21 @@ void qt_qimageScaleAARGBA_down_xy_sse4(QImageScaleInfo *isi, unsigned int *dest,
 }
 
 template void qt_qimageScaleAARGBA_up_x_down_y_sse4<false>(QImageScaleInfo *isi, unsigned int *dest,
-                                                           int dxx, int dyy, int dx, int dy,
                                                            int dw, int dh, int dow, int sow);
 
 template void qt_qimageScaleAARGBA_up_x_down_y_sse4<true>(QImageScaleInfo *isi, unsigned int *dest,
-                                                          int dxx, int dyy, int dx, int dy,
                                                           int dw, int dh, int dow, int sow);
 
 template void qt_qimageScaleAARGBA_down_x_up_y_sse4<false>(QImageScaleInfo *isi, unsigned int *dest,
-                                                           int dxx, int dyy, int dx, int dy,
                                                            int dw, int dh, int dow, int sow);
 
 template void qt_qimageScaleAARGBA_down_x_up_y_sse4<true>(QImageScaleInfo *isi, unsigned int *dest,
-                                                          int dxx, int dyy, int dx, int dy,
                                                           int dw, int dh, int dow, int sow);
 
 template void qt_qimageScaleAARGBA_down_xy_sse4<false>(QImageScaleInfo *isi, unsigned int *dest,
-                                                       int dxx, int dyy, int dx, int dy,
                                                        int dw, int dh, int dow, int sow);
 
 template void qt_qimageScaleAARGBA_down_xy_sse4<true>(QImageScaleInfo *isi, unsigned int *dest,
-                                                      int dxx, int dyy, int dx, int dy,
                                                       int dw, int dh, int dow, int sow);
 
 QT_END_NAMESPACE