Cleanup of qcompositionfunctions

Remove long unused preload defines, make sign of alpha more consistent
and use the RGB64 define structure more.

This is preparing for trying to unify the declarations in case we need
a third form with floating points for HDR.

Change-Id: I47fc283aff1fe31a1eaba17e0413bc1e722f6a06
Reviewed-by: Eirik Aavitsland <eirik.aavitsland@qt.io>

2 files changed, 60 insertions, 177 deletions

diff --git a/src/gui/painting/qcompositionfunctions.cpp b/src/gui/painting/qcompositionfunctions.cpp
index ee05f810f1..339a9749b8 100644
--- a/src/gui/painting/qcompositionfunctions.cpp
+++ b/src/gui/painting/qcompositionfunctions.cpp
@@ -38,16 +38,11 @@
 ****************************************************************************/
 
 #include <qglobal.h>
-#include <private/qdrawhelper_p.h>
-#include <private/qrgba64_p.h>
+#include "qdrawhelper_p.h"
+#include "qrgba64_p.h"
 
 QT_BEGIN_NAMESPACE
 
-#    define PRELOAD_INIT(x)
-#    define PRELOAD_INIT2(x,y)
-#    define PRELOAD_COND(x)
-#    define PRELOAD_COND2(x,y)
-
 /* The constant alpha factor describes an alpha factor that gets applied
    to the result of the composition operation combining it with the destination.
 
@@ -69,24 +64,6 @@ QT_BEGIN_NAMESPACE
    where the source is an array of pixels.
 */
 
-/*
-  result = 0
-  d = d * cia
-*/
-#define comp_func_Clear_impl(dest, length, const_alpha)\
-{\
-    if (const_alpha == 255) {\
-        QT_MEMFILL_UINT(dest, length, 0);\
-    } else {\
-        int ialpha = 255 - const_alpha;\
-        PRELOAD_INIT(dest)\
-        for (int i = 0; i < length; ++i) {\
-            PRELOAD_COND(dest)\
-            dest[i] = BYTE_MUL(dest[i], ialpha);\
-        }\
-    }\
-}
-
 #if defined __SSE2__
 #  define LOAD(ptr) _mm_loadl_epi64(reinterpret_cast<const __m128i *>(ptr))
 #ifdef Q_PROCESSOR_X86_64
@@ -117,38 +94,41 @@ QT_BEGIN_NAMESPACE
 #  define INVALPHA(c) (65535 - ALPHA(c))
 #endif
 
+
+/*
+  result = 0
+  d = d * cia
+*/
 void QT_FASTCALL comp_func_solid_Clear(uint *dest, int length, uint, uint const_alpha)
 {
-    comp_func_Clear_impl(dest, length, const_alpha);
+    if (const_alpha == 255) {
+        qt_memfill32(dest, 0, length);
+    } else {
+        uint ialpha = 255 - const_alpha;
+        for (int i = 0; i < length; ++i)
+            dest[i] = BYTE_MUL(dest[i], ialpha);
+    }
 }
 
 void QT_FASTCALL comp_func_solid_Clear_rgb64(QRgba64 *dest, int length, QRgba64, uint const_alpha)
 {
-    if (const_alpha == 255)
+    if (const_alpha == 255) {
         qt_memfill64((quint64*)dest, 0, length);
-    else {
-        int ialpha = 255 - const_alpha;
-        for (int i = 0; i < length; ++i) {
+    } else {
+        uint ialpha = 255 - const_alpha;
+        for (int i = 0; i < length; ++i)
             STORE(&dest[i], multiplyAlpha255(LOAD(&dest[i]), ialpha));
-        }
     }
 }
 
 void QT_FASTCALL comp_func_Clear(uint *dest, const uint *, int length, uint const_alpha)
 {
-    comp_func_Clear_impl(dest, length, const_alpha);
+    comp_func_solid_Clear(dest, length, 0, const_alpha);
 }
 
 void QT_FASTCALL comp_func_Clear_rgb64(QRgba64 *dest, const QRgba64 *, int length, uint const_alpha)
 {
-    if (const_alpha == 255)
-        qt_memfill64((quint64*)dest, 0, length);
-    else {
-        int ialpha = 255 - const_alpha;
-        for (int i = 0; i < length; ++i) {
-            STORE(&dest[i], multiplyAlpha255(LOAD(&dest[i]), ialpha));
-        }
-    }
+    comp_func_solid_Clear_rgb64(dest, length, QRgba64(), const_alpha);
 }
 
 /*
@@ -158,13 +138,11 @@ void QT_FASTCALL comp_func_Clear_rgb64(QRgba64 *dest, const QRgba64 *, int lengt
 void QT_FASTCALL comp_func_solid_Source(uint *dest, int length, uint color, uint const_alpha)
 {
     if (const_alpha == 255) {
-        QT_MEMFILL_UINT(dest, length, color);
+        qt_memfill32(dest, color, length);
     } else {
-        int ialpha = 255 - const_alpha;
+        uint ialpha = 255 - const_alpha;
         color = BYTE_MUL(color, const_alpha);
-        PRELOAD_INIT(dest)
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND(dest)
             dest[i] = color + BYTE_MUL(dest[i], ialpha);
         }
     }
@@ -175,7 +153,7 @@ void QT_FASTCALL comp_func_solid_Source_rgb64(QRgba64 *dest, int length, QRgba64
     if (const_alpha == 255)
         qt_memfill64((quint64*)dest, color, length);
     else {
-        int ialpha = 255 - const_alpha;
+        uint ialpha = 255 - const_alpha;
         auto c = multiplyAlpha255(CONVERT(color), const_alpha);
         for (int i = 0; i < length; ++i) {
             STORE(&dest[i], ADD(c, multiplyAlpha255(LOAD(&dest[i]), ialpha)));
@@ -186,12 +164,10 @@ void QT_FASTCALL comp_func_solid_Source_rgb64(QRgba64 *dest, int length, QRgba64
 void QT_FASTCALL comp_func_Source(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255) {
-        ::memcpy(dest, src, length * sizeof(uint));
+        ::memcpy(dest, src, size_t(length) * sizeof(uint));
     } else {
-        int ialpha = 255 - const_alpha;
-        PRELOAD_INIT2(dest, src)
+        uint ialpha = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             dest[i] = INTERPOLATE_PIXEL_255(src[i], const_alpha, dest[i], ialpha);
         }
     }
@@ -200,9 +176,9 @@ void QT_FASTCALL comp_func_Source(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL
 void QT_FASTCALL comp_func_Source_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
     if (const_alpha == 255)
-        ::memcpy(dest, src, length * sizeof(quint64));
+        ::memcpy(dest, src, size_t(length) * sizeof(quint64));
     else {
-        int ialpha = 255 - const_alpha;
+        uint ialpha = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
             STORE(&dest[i], interpolate255(LOAD(&src[i]), const_alpha, LOAD(&dest[i]), ialpha));
         }
@@ -234,13 +210,11 @@ void QT_FASTCALL comp_func_Destination_rgb64(QRgba64 *, const QRgba64 *, int, ui
 void QT_FASTCALL comp_func_solid_SourceOver(uint *dest, int length, uint color, uint const_alpha)
 {
     if ((const_alpha & qAlpha(color)) == 255) {
-        QT_MEMFILL_UINT(dest, length, color);
+        qt_memfill32(dest, color, length);
     } else {
         if (const_alpha != 255)
             color = BYTE_MUL(color, const_alpha);
-        PRELOAD_INIT(dest)
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND(dest)
             dest[i] = color + BYTE_MUL(dest[i], qAlpha(~color));
         }
     }
@@ -263,10 +237,8 @@ void QT_FASTCALL comp_func_solid_SourceOver_rgb64(QRgba64 *dest, int length, QRg
 
 void QT_FASTCALL comp_func_SourceOver(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint s = src[i];
             if (s >= 0xff000000)
                 dest[i] = s;
@@ -275,7 +247,6 @@ void QT_FASTCALL comp_func_SourceOver(uint *Q_DECL_RESTRICT dest, const uint *Q_
         }
     } else {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint s = BYTE_MUL(src[i], const_alpha);
             dest[i] = s + BYTE_MUL(dest[i], qAlpha(~s));
         }
@@ -309,9 +280,7 @@ void QT_FASTCALL comp_func_solid_DestinationOver(uint *dest, int length, uint co
 {
     if (const_alpha != 255)
         color = BYTE_MUL(color, const_alpha);
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         dest[i] = d + BYTE_MUL(color, qAlpha(~d));
     }
@@ -330,16 +299,13 @@ void QT_FASTCALL comp_func_solid_DestinationOver_rgb64(QRgba64 *dest, int length
 
 void QT_FASTCALL comp_func_DestinationOver(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint d = dest[i];
             dest[i] = d + BYTE_MUL(src[i], qAlpha(~d));
         }
     } else {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint d = dest[i];
             uint s = BYTE_MUL(src[i], const_alpha);
             dest[i] = d + BYTE_MUL(s, qAlpha(~d));
@@ -369,17 +335,14 @@ void QT_FASTCALL comp_func_DestinationOver_rgb64(QRgba64 *Q_DECL_RESTRICT dest,
 */
 void QT_FASTCALL comp_func_solid_SourceIn(uint *dest, int length, uint color, uint const_alpha)
 {
-    PRELOAD_INIT(dest)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND(dest)
             dest[i] = BYTE_MUL(color, qAlpha(dest[i]));
         }
     } else {
         color = BYTE_MUL(color, const_alpha);
         uint cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND(dest)
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(d), d, cia);
         }
@@ -389,32 +352,30 @@ void QT_FASTCALL comp_func_solid_SourceIn(uint *dest, int length, uint color, ui
 void QT_FASTCALL comp_func_solid_SourceIn_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
 {
     if (const_alpha == 255) {
+        auto c = CONVERT(color);
         for (int i = 0; i < length; ++i) {
-            dest[i] =  multiplyAlpha65535(color, dest[i].alpha());
+            STORE(&dest[i], multiplyAlpha65535(c, dest[i].alpha()));
         }
     } else {
         uint ca = const_alpha * 257;
-        uint cia = 65535 - ca;
-        color = multiplyAlpha65535(color, ca);
+        auto cia = CONST(65535 - ca);
+        auto c = multiplyAlpha65535(CONVERT(color), ca);
         for (int i = 0; i < length; ++i) {
-            QRgba64 d = dest[i];
-            dest[i] = interpolate65535(color, d.alpha(), d, cia);
+            auto d = LOAD(&dest[i]);
+            STORE(&dest[i], interpolate65535(c, ALPHA(d), d, cia));
         }
     }
 }
 
 void QT_FASTCALL comp_func_SourceIn(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             dest[i] = BYTE_MUL(src[i], qAlpha(dest[i]));
         }
     } else {
         uint cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint d = dest[i];
             uint s = BYTE_MUL(src[i], const_alpha);
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, cia);
@@ -450,9 +411,7 @@ void QT_FASTCALL comp_func_solid_DestinationIn(uint *dest, int length, uint colo
     if (const_alpha != 255) {
         a = BYTE_MUL(a, const_alpha) + 255 - const_alpha;
     }
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         dest[i] = BYTE_MUL(dest[i], a);
     }
 }
@@ -470,16 +429,13 @@ void QT_FASTCALL comp_func_solid_DestinationIn_rgb64(QRgba64 *dest, int length,
 
 void QT_FASTCALL comp_func_DestinationIn(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             dest[i] = BYTE_MUL(dest[i], qAlpha(src[i]));
         }
     } else {
-        int cia = 255 - const_alpha;
+        uint cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint a = BYTE_MUL(qAlpha(src[i]), const_alpha) + cia;
             dest[i] = BYTE_MUL(dest[i], a);
         }
@@ -490,14 +446,14 @@ void QT_FASTCALL comp_func_DestinationIn_rgb64(QRgba64 *Q_DECL_RESTRICT dest, co
 {
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            dest[i] = multiplyAlpha65535(dest[i], src[i].alpha());
+            STORE(&dest[i], multiplyAlpha65535(LOAD(&dest[i]), src[i].alpha()));
         }
     } else {
         uint ca = const_alpha * 257;
         uint cia = 65535 - ca;
         for (int i = 0; i < length; ++i) {
             uint a = qt_div_65535(src[i].alpha() * ca) + cia;
-            dest[i] = multiplyAlpha65535(dest[i], a);
+            STORE(&dest[i], multiplyAlpha65535(LOAD(&dest[i]), a));
         }
     }
 }
@@ -509,17 +465,14 @@ void QT_FASTCALL comp_func_DestinationIn_rgb64(QRgba64 *Q_DECL_RESTRICT dest, co
 
 void QT_FASTCALL comp_func_solid_SourceOut(uint *dest, int length, uint color, uint const_alpha)
 {
-    PRELOAD_INIT(dest)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND(dest)
             dest[i] = BYTE_MUL(color, qAlpha(~dest[i]));
         }
     } else {
         color = BYTE_MUL(color, const_alpha);
-        int cia = 255 - const_alpha;
+        uint cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND(dest)
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(~d), d, cia);
         }
@@ -545,16 +498,13 @@ void QT_FASTCALL comp_func_solid_SourceOut_rgb64(QRgba64 *dest, int length, QRgb
 
 void QT_FASTCALL comp_func_SourceOut(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             dest[i] = BYTE_MUL(src[i], qAlpha(~dest[i]));
         }
     } else {
-        int cia = 255 - const_alpha;
+        uint cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint s = BYTE_MUL(src[i], const_alpha);
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, cia);
@@ -589,9 +539,7 @@ void QT_FASTCALL comp_func_solid_DestinationOut(uint *dest, int length, uint col
     uint a = qAlpha(~color);
     if (const_alpha != 255)
         a = BYTE_MUL(a, const_alpha) + 255 - const_alpha;
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         dest[i] = BYTE_MUL(dest[i], a);
     }
 }
@@ -609,16 +557,13 @@ void QT_FASTCALL comp_func_solid_DestinationOut_rgb64(QRgba64 *dest, int length,
 
 void QT_FASTCALL comp_func_DestinationOut(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             dest[i] = BYTE_MUL(dest[i], qAlpha(~src[i]));
         }
     } else {
-        int cia = 255 - const_alpha;
+        uint cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint sia = BYTE_MUL(qAlpha(~src[i]), const_alpha) + cia;
             dest[i] = BYTE_MUL(dest[i], sia);
         }
@@ -653,9 +598,7 @@ void QT_FASTCALL comp_func_solid_SourceAtop(uint *dest, int length, uint color,
         color = BYTE_MUL(color, const_alpha);
     }
     uint sia = qAlpha(~color);
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(dest[i]), dest[i], sia);
     }
 }
@@ -672,17 +615,14 @@ void QT_FASTCALL comp_func_solid_SourceAtop_rgb64(QRgba64 *dest, int length, QRg
 
 void QT_FASTCALL comp_func_SourceAtop(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint s = src[i];
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, qAlpha(~s));
         }
     } else {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint s = BYTE_MUL(src[i], const_alpha);
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(d), d, qAlpha(~s));
@@ -719,9 +659,7 @@ void QT_FASTCALL comp_func_solid_DestinationAtop(uint *dest, int length, uint co
         color = BYTE_MUL(color, const_alpha);
         a = qAlpha(color) + 255 - const_alpha;
     }
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         dest[i] = INTERPOLATE_PIXEL_255(d, a, color, qAlpha(~d));
     }
@@ -742,18 +680,15 @@ void QT_FASTCALL comp_func_solid_DestinationAtop_rgb64(QRgba64 *dest, int length
 
 void QT_FASTCALL comp_func_DestinationAtop(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint s = src[i];
             uint d = dest[i];
             dest[i] = INTERPOLATE_PIXEL_255(d, qAlpha(s), s, qAlpha(~d));
         }
     } else {
-        int cia = 255 - const_alpha;
+        uint cia = 255 - const_alpha;
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint s = BYTE_MUL(src[i], const_alpha);
             uint d = dest[i];
             uint a = qAlpha(s) + cia;
@@ -771,8 +706,8 @@ void QT_FASTCALL comp_func_DestinationAtop_rgb64(QRgba64 *Q_DECL_RESTRICT dest,
             dest[i] = interpolate65535(d, s.alpha(), s, 65535 - d.alpha());
         }
     } else {
-        int ca = const_alpha * 257;
-        int cia = 65535 - ca;
+        uint ca = const_alpha * 257;
+        uint cia = 65535 - ca;
         for (int i = 0; i < length; ++i) {
             QRgba64 s = multiplyAlpha65535(src[i], ca);
             QRgba64 d = dest[i];
@@ -794,9 +729,7 @@ void QT_FASTCALL comp_func_solid_XOR(uint *dest, int length, uint color, uint co
         color = BYTE_MUL(color, const_alpha);
     uint sia = qAlpha(~color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         dest[i] = INTERPOLATE_PIXEL_255(color, qAlpha(~d), d, sia);
     }
@@ -806,26 +739,24 @@ void QT_FASTCALL comp_func_solid_XOR_rgb64(QRgba64 *dest, int length, QRgba64 co
 {
     if (const_alpha != 255)
         color = multiplyAlpha255(color, const_alpha);
-    uint sia = 65535 - color.alpha();
+    auto s = CONVERT(color);
+    auto sia = CONST(65535 - color.alpha());
     for (int i = 0; i < length; ++i) {
-        QRgba64 d = dest[i];
-        dest[i] = interpolate65535(color, 65535 - d.alpha(), d, sia);
+        auto d = LOAD(&dest[i]);
+        STORE(&dest[i], interpolate65535(s, INVALPHA(d), d, sia));
     }
 }
 
 void QT_FASTCALL comp_func_XOR(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
 {
-    PRELOAD_INIT2(dest, src)
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint d = dest[i];
             uint s = src[i];
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, qAlpha(~s));
         }
     } else {
         for (int i = 0; i < length; ++i) {
-            PRELOAD_COND2(dest, src)
             uint d = dest[i];
             uint s = BYTE_MUL(src[i], const_alpha);
             dest[i] = INTERPOLATE_PIXEL_255(s, qAlpha(~d), d, qAlpha(~s));
@@ -837,15 +768,15 @@ void QT_FASTCALL comp_func_XOR_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba6
 {
     if (const_alpha == 255) {
         for (int i = 0; i < length; ++i) {
-            QRgba64 d = dest[i];
-            QRgba64 s = src[i];
-            dest[i] = interpolate65535(s, 65535 - d.alpha(), d, 65535 - s.alpha());
+            auto d = LOAD(&dest[i]);
+            auto s = LOAD(&src[i]);
+            STORE(&dest[i], interpolate65535(s, INVALPHA(d), d, INVALPHA(s)));
         }
     } else {
         for (int i = 0; i < length; ++i) {
-            QRgba64 d = dest[i];
-            QRgba64 s = multiplyAlpha255(src[i], const_alpha);
-            dest[i] = interpolate65535(s, 65535 - d.alpha(), d, 65535 - s.alpha());
+            auto d = LOAD(&dest[i]);
+            auto s = multiplyAlpha255(LOAD(&src[i]), const_alpha);
+            STORE(&dest[i], interpolate65535(s, INVALPHA(d), d, INVALPHA(s)));
         }
     }
 }
@@ -901,9 +832,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Plus_impl(uint *dest, int
 {
     uint s = color;
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         d = comp_func_Plus_one_pixel(d, s);
         coverage.store(&dest[i], d);
@@ -940,9 +869,7 @@ void QT_FASTCALL comp_func_solid_Plus_rgb64(QRgba64 *dest, int length, QRgba64 c
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Plus_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -1001,9 +928,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Multiply_impl(uint *dest,
     int sg = qGreen(color);
     int sb = qBlue(color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -1060,9 +985,7 @@ void QT_FASTCALL comp_func_solid_Multiply_rgb64(QRgba64 *dest, int length, QRgba
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Multiply_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -1129,9 +1052,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Screen_impl(uint *dest, i
     int sg = qGreen(color);
     int sb = qBlue(color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -1188,9 +1109,7 @@ void QT_FASTCALL comp_func_solid_Screen_rgb64(QRgba64 *dest, int length, QRgba64
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Screen_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -1277,9 +1196,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Overlay_impl(uint *dest,
     int sg = qGreen(color);
     int sb = qBlue(color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -1336,9 +1253,7 @@ void QT_FASTCALL comp_func_solid_Overlay_rgb64(QRgba64 *dest, int length, QRgba6
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Overlay_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -1415,9 +1330,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Darken_impl(uint *dest, i
     int sg = qGreen(color);
     int sb = qBlue(color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -1474,9 +1387,7 @@ void QT_FASTCALL comp_func_solid_Darken_rgb64(QRgba64 *dest, int length, QRgba64
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Darken_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -1553,9 +1464,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Lighten_impl(uint *dest,
     int sg = qGreen(color);
     int sb = qBlue(color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -1612,9 +1521,7 @@ void QT_FASTCALL comp_func_solid_Lighten_rgb64(QRgba64 *dest, int length, QRgba6
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Lighten_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -1709,9 +1616,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_ColorDodge_impl(uint *des
     int sg = qGreen(color);
     int sb = qBlue(color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -1768,9 +1673,7 @@ void QT_FASTCALL comp_func_solid_ColorDodge_rgb64(QRgba64 *dest, int length, QRg
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_ColorDodge_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -1865,9 +1768,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_ColorBurn_impl(uint *dest
     int sg = qGreen(color);
     int sb = qBlue(color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -1924,9 +1825,7 @@ void QT_FASTCALL comp_func_solid_ColorBurn_rgb64(QRgba64 *dest, int length, QRgb
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_ColorBurn_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2015,9 +1914,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_HardLight_impl(uint *dest
     int sg = qGreen(color);
     int sb = qBlue(color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2074,9 +1971,7 @@ void QT_FASTCALL comp_func_solid_HardLight_rgb64(QRgba64 *dest, int length, QRgb
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_HardLight_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2178,9 +2073,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_SoftLight_impl(uint *dest
     int sg = qGreen(color);
     int sb = qBlue(color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2237,9 +2130,7 @@ void QT_FASTCALL comp_func_solid_SoftLight_rgb64(QRgba64 *dest, int length, QRgb
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_SoftLight_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2316,9 +2207,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_solid_Difference_impl(uint *des
     int sg = qGreen(color);
     int sb = qBlue(color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2375,9 +2264,7 @@ void QT_FASTCALL comp_func_solid_Difference_rgb64(QRgba64 *dest, int length, QRg
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Difference_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
@@ -2443,9 +2330,7 @@ Q_STATIC_TEMPLATE_FUNCTION inline void QT_FASTCALL comp_func_solid_Exclusion_imp
     int sg = qGreen(color);
     int sb = qBlue(color);
 
-    PRELOAD_INIT(dest)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND(dest)
         uint d = dest[i];
         int da = qAlpha(d);
 
@@ -2503,9 +2388,7 @@ void QT_FASTCALL comp_func_solid_Exclusion_rgb64(QRgba64 *dest, int length, QRgb
 template <typename T>
 Q_STATIC_TEMPLATE_FUNCTION inline void comp_func_Exclusion_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
 {
-    PRELOAD_INIT2(dest, src)
     for (int i = 0; i < length; ++i) {
-        PRELOAD_COND2(dest, src)
         uint d = dest[i];
         uint s = src[i];
 
diff --git a/src/gui/painting/qdrawhelper_p.h b/src/gui/painting/qdrawhelper_p.h
index 2be10d2cfb..2db139d794 100644
--- a/src/gui/painting/qdrawhelper_p.h
+++ b/src/gui/painting/qdrawhelper_p.h
@@ -1160,23 +1160,23 @@ const uint qt_bayer_matrix[16][16] = {
 
 
 #if Q_PROCESSOR_WORDSIZE == 8 // 64-bit versions
-#define AMIX(mask) (qMin(((qint64(s)&mask) + (qint64(d)&mask)), qint64(mask)))
-#define MIX(mask) (qMin(((qint64(s)&mask) + (qint64(d)&mask)), qint64(mask)))
+#define AMIX(mask) (qMin(((quint64(s)&mask) + (quint64(d)&mask)), quint64(mask)))
+#define MIX(mask) (qMin(((quint64(s)&mask) + (quint64(d)&mask)), quint64(mask)))
 #else // 32 bits
 // The mask for alpha can overflow over 32 bits
-#define AMIX(mask) quint32(qMin(((qint64(s)&mask) + (qint64(d)&mask)), qint64(mask)))
+#define AMIX(mask) quint32(qMin(((quint64(s)&mask) + (quint64(d)&mask)), quint64(mask)))
 #define MIX(mask) (qMin(((quint32(s)&mask) + (quint32(d)&mask)), quint32(mask)))
 #endif
 
-inline int comp_func_Plus_one_pixel_const_alpha(uint d, const uint s, const uint const_alpha, const uint one_minus_const_alpha)
+inline uint comp_func_Plus_one_pixel_const_alpha(uint d, const uint s, const uint const_alpha, const uint one_minus_const_alpha)
 {
-    const int result = (AMIX(AMASK) | MIX(RMASK) | MIX(GMASK) | MIX(BMASK));
+    const uint result = (AMIX(AMASK) | MIX(RMASK) | MIX(GMASK) | MIX(BMASK));
     return INTERPOLATE_PIXEL_255(result, const_alpha, d, one_minus_const_alpha);
 }
 
-inline int comp_func_Plus_one_pixel(uint d, const uint s)
+inline uint comp_func_Plus_one_pixel(uint d, const uint s)
 {
-    const int result = (AMIX(AMASK) | MIX(RMASK) | MIX(GMASK) | MIX(BMASK));
+    const uint result = (AMIX(AMASK) | MIX(RMASK) | MIX(GMASK) | MIX(BMASK));
     return result;
 }