Add color space model, making gray color spaces explicit

This also adds image conversion of both format and color space, which
will also  be required later for conversions to CMYK formats and color
spaces.

Change-Id: I578c0a010ffcdb4df4cf9080c0621fac8bc342bf
Reviewed-by: Giuseppe D'Angelo <giuseppe.dangelo@kdab.com>

1 files changed, 305 insertions, 145 deletions

diff --git a/src/gui/painting/qcolortransform.cpp b/src/gui/painting/qcolortransform.cpp
index 8d578d7af3..884e338304 100644
--- a/src/gui/painting/qcolortransform.cpp
+++ b/src/gui/painting/qcolortransform.cpp
@@ -346,6 +346,39 @@ static void applyMatrix(QColorVector *buffer, const qsizetype len, const QColorM
 #endif
 }
 
+template<ApplyMatrixForm doClamp = DoClamp>
+static void clampIfNeeded(QColorVector *buffer, const qsizetype len)
+{
+    if constexpr (doClamp != DoClamp)
+        return;
+#if defined(__SSE2__)
+    const __m128 minV = _mm_set1_ps(0.0f);
+    const __m128 maxV = _mm_set1_ps(1.0f);
+    for (qsizetype j = 0; j < len; ++j) {
+        __m128 c = _mm_loadu_ps(&buffer[j].x);
+        c = _mm_min_ps(c, maxV);
+        c = _mm_max_ps(c, minV);
+        _mm_storeu_ps(&buffer[j].x, c);
+    }
+#elif defined(__ARM_NEON__)
+    const float32x4_t minV = vdupq_n_f32(0.0f);
+    const float32x4_t maxV = vdupq_n_f32(1.0f);
+    for (qsizetype j = 0; j < len; ++j) {
+        float32x4_t c = vld1q_f32(&buffer[j].x);
+        c = vminq_f32(c, maxV);
+        c = vmaxq_f32(c, minV);
+        vst1q_f32(&buffer[j].x, c);
+    }
+#else
+    for (qsizetype j = 0; j < len; ++j) {
+        const QColorVector cv = buffer[j];
+        buffer[j].x = std::clamp(cv.x, 0.f, 1.f);
+        buffer[j].y = std::clamp(cv.y, 0.f, 1.f);
+        buffer[j].z = std::clamp(cv.z, 0.f, 1.f);
+    }
+#endif
+}
+
 #if defined(__SSE2__) || defined(__ARM_NEON__)
 template<typename T>
 static constexpr inline bool isArgb();
@@ -362,9 +395,25 @@ inline int getAlpha<QRgb>(const QRgb &p)
 template<>
 inline int getAlpha<QRgba64>(const QRgba64 &p)
 {    return p.alpha(); }
+
 #endif
 
 template<typename T>
+static float getAlphaF(const T &);
+template<> float getAlphaF(const QRgb &r)
+{
+    return qAlpha(r) * (1.f / 255.f);
+}
+template<> float getAlphaF(const QRgba64 &r)
+{
+    return r.alpha() * (1.f / 65535.f);
+}
+template<> float getAlphaF(const QRgbaFloat32 &r)
+{
+    return r.a;
+}
+
+template<typename T>
 static void loadPremultiplied(QColorVector *buffer, const T *src, const qsizetype len, const QColorTransformPrivate *d_ptr);
 template<typename T>
 static void loadUnpremultiplied(QColorVector *buffer, const T *src, const qsizetype len, const QColorTransformPrivate *d_ptr);
@@ -768,15 +817,16 @@ inline void storeP<QRgba64>(QRgba64 &p, __m128i &v, int a)
 #endif
 }
 
-template<typename T>
-static void storePremultiplied(T *dst, const T *src, const QColorVector *buffer, const qsizetype len,
+template<typename D, typename S,
+         typename = std::enable_if_t<!std::is_same_v<D, QRgbaFloat32>, void>>
+static void storePremultiplied(D *dst, const S *src, const QColorVector *buffer, const qsizetype len,
                                const QColorTransformPrivate *d_ptr)
 {
     const __m128 v4080 = _mm_set1_ps(4080.f);
     const __m128 iFF00 = _mm_set1_ps(1.0f / (255 * 256));
-    constexpr bool isARGB = isArgb<T>();
+    constexpr bool isARGB = isArgb<D>();
     for (qsizetype i = 0; i < len; ++i) {
-        const int a = getAlpha<T>(src[i]);
+        const int a = getAlpha<S>(src[i]);
         __m128 vf = _mm_loadu_ps(&buffer[i].x);
         __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, v4080));
         __m128 va = _mm_mul_ps(_mm_set1_ps(a), iFF00);
@@ -789,21 +839,21 @@ static void storePremultiplied(T *dst, const T *src, const QColorVector *buffer,
         vf = _mm_cvtepi32_ps(v);
         vf = _mm_mul_ps(vf, va);
         v = _mm_cvtps_epi32(vf);
-        storeP<T>(dst[i], v, a);
+        storeP<D>(dst[i], v, a);
     }
 }
 
-template<>
-void storePremultiplied<QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *src,
-                                      const QColorVector *buffer, const qsizetype len,
-                                      const QColorTransformPrivate *d_ptr)
+template<typename S>
+static void storePremultiplied(QRgbaFloat32 *dst, const S *src,
+                               const QColorVector *buffer, const qsizetype len,
+                               const QColorTransformPrivate *d_ptr)
 {
     const __m128 v4080 = _mm_set1_ps(4080.f);
     const __m128 vZero = _mm_set1_ps(0.0f);
     const __m128 vOne  = _mm_set1_ps(1.0f);
     const __m128 viFF00 = _mm_set1_ps(1.0f / (255 * 256));
     for (qsizetype i = 0; i < len; ++i) {
-        const float a = src[i].a;
+        const float a = getAlphaF<S>(src[i]);
         __m128 va = _mm_set1_ps(a);
         __m128 vf = _mm_loadu_ps(&buffer[i].x);
         const __m128 under = _mm_cmplt_ps(vf, vZero);
@@ -850,14 +900,15 @@ inline void storePU<QRgba64>(QRgba64 &p, __m128i &v, int a)
     _mm_storel_epi64((__m128i *)&p, v);
 }
 
-template<typename T>
-static void storeUnpremultiplied(T *dst, const T *src, const QColorVector *buffer, const qsizetype len,
+template<typename D, typename S,
+         typename = std::enable_if_t<!std::is_same_v<D, QRgbaFloat32>, void>>
+static void storeUnpremultiplied(D *dst, const S *src, const QColorVector *buffer, const qsizetype len,
                                  const QColorTransformPrivate *d_ptr)
 {
     const __m128 v4080 = _mm_set1_ps(4080.f);
-    constexpr bool isARGB = isArgb<T>();
+    constexpr bool isARGB = isArgb<D>();
     for (qsizetype i = 0; i < len; ++i) {
-        const int a = getAlpha<T>(src[i]);
+        const int a = getAlpha<S>(src[i]);
         __m128 vf = _mm_loadu_ps(&buffer[i].x);
         __m128i v = _mm_cvtps_epi32(_mm_mul_ps(vf, v4080));
         const int ridx = _mm_extract_epi16(v, 0);
@@ -867,21 +918,21 @@ static void storeUnpremultiplied(T *dst, const T *src, const QColorVector *buffe
         v = _mm_insert_epi16(v, d_ptr->colorSpaceOut->lut[0]->m_fromLinear[ridx], isARGB ? 2 : 0);
         v = _mm_insert_epi16(v, d_ptr->colorSpaceOut->lut[1]->m_fromLinear[gidx], 1);
         v = _mm_insert_epi16(v, d_ptr->colorSpaceOut->lut[2]->m_fromLinear[bidx], isARGB ? 0 : 2);
-        storePU<T>(dst[i], v, a);
+        storePU<D>(dst[i], v, a);
     }
 }
 
-template<>
-void storeUnpremultiplied<QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *src,
-                                        const QColorVector *buffer, const qsizetype len,
-                                        const QColorTransformPrivate *d_ptr)
+template<typename S>
+void storeUnpremultiplied(QRgbaFloat32 *dst, const S *src,
+                          const QColorVector *buffer, const qsizetype len,
+                          const QColorTransformPrivate *d_ptr)
 {
     const __m128 v4080 = _mm_set1_ps(4080.f);
     const __m128 vZero = _mm_set1_ps(0.0f);
     const __m128 vOne  = _mm_set1_ps(1.0f);
     const __m128 viFF00 = _mm_set1_ps(1.0f / (255 * 256));
     for (qsizetype i = 0; i < len; ++i) {
-        const float a = src[i].a;
+        const float a = getAlphaF<S>(src[i]);
         __m128 vf = _mm_loadu_ps(&buffer[i].x);
         const __m128 under = _mm_cmplt_ps(vf, vZero);
         const __m128 over = _mm_cmpgt_ps(vf, vOne);
@@ -907,10 +958,9 @@ void storeUnpremultiplied<QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *s
 }
 
 template<typename T>
-static void storeOpaque(T *dst, const T *src, const QColorVector *buffer, const qsizetype len,
+static void storeOpaque(T *dst, const QColorVector *buffer, const qsizetype len,
                         const QColorTransformPrivate *d_ptr)
 {
-    Q_UNUSED(src);
     const __m128 v4080 = _mm_set1_ps(4080.f);
     constexpr bool isARGB = isArgb<T>();
     for (qsizetype i = 0; i < len; ++i) {
@@ -928,11 +978,10 @@ static void storeOpaque(T *dst, const T *src, const QColorVector *buffer, const
 }
 
 template<>
-void storeOpaque<QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *src,
+void storeOpaque<QRgbaFloat32>(QRgbaFloat32 *dst,
                                const QColorVector *buffer, const qsizetype len,
                                const QColorTransformPrivate *d_ptr)
 {
-    Q_UNUSED(src);
     const __m128 v4080 = _mm_set1_ps(4080.f);
     const __m128 vZero = _mm_set1_ps(0.0f);
     const __m128 vOne  = _mm_set1_ps(1.0f);
@@ -976,14 +1025,15 @@ inline void storeP<QRgba64>(QRgba64 &p, const uint16x4_t &v)
     vst1_u16((uint16_t *)&p, v);
 }
 
-template<typename T>
-static void storePremultiplied(T *dst, const T *src, const QColorVector *buffer, const qsizetype len,
+template<typename D, typename S,
+         typename = std::enable_if_t<!std::is_same_v<D, QRgbaFloat32>, void>>
+static void storePremultiplied(D *dst, const S *src, const QColorVector *buffer, const qsizetype len,
                                const QColorTransformPrivate *d_ptr)
 {
     const float iFF00 = 1.0f / (255 * 256);
-    constexpr bool isARGB = isArgb<T>();
+    constexpr bool isARGB = isArgb<D>();
     for (qsizetype i = 0; i < len; ++i) {
-        const int a = getAlpha<T>(src[i]);
+        const int a = getAlpha<S>(src[i]);
         float32x4_t vf = vld1q_f32(&buffer[i].x);
         uint32x4_t v = vcvtq_u32_f32(vaddq_f32(vmulq_n_f32(vf, 4080.f), vdupq_n_f32(0.5f)));
         const int ridx = vgetq_lane_u32(v, 0);
@@ -998,7 +1048,7 @@ static void storePremultiplied(T *dst, const T *src, const QColorVector *buffer,
         v = vcvtq_u32_f32(vf);
         uint16x4_t v16 = vmovn_u32(v);
         v16 = vset_lane_u16(a, v16, 3);
-        storeP<T>(dst[i], v16);
+        storeP<D>(dst[i], v16);
     }
 }
 
@@ -1020,13 +1070,14 @@ inline void storePU<QRgba64>(QRgba64 &p, uint16x4_t &v, int a)
     vst1_u16((uint16_t *)&p, v);
 }
 
-template<typename T>
-static void storeUnpremultiplied(T *dst, const T *src, const QColorVector *buffer, const qsizetype len,
+template<typename D, typename S,
+         typename = std::enable_if_t<!std::is_same_v<D, QRgbaFloat32>, void>>
+static void storeUnpremultiplied(D *dst, const S *src, const QColorVector *buffer, const qsizetype len,
                                  const QColorTransformPrivate *d_ptr)
 {
-    constexpr bool isARGB = isArgb<T>();
+    constexpr bool isARGB = isArgb<D>();
     for (qsizetype i = 0; i < len; ++i) {
-        const int a = getAlpha<T>(src[i]);
+        const int a = getAlpha<S>(src[i]);
         float32x4_t vf = vld1q_f32(&buffer[i].x);
         uint16x4_t v = vmovn_u32(vcvtq_u32_f32(vaddq_f32(vmulq_n_f32(vf, 4080.f), vdupq_n_f32(0.5f))));
         const int ridx = vget_lane_u16(v, 0);
@@ -1035,15 +1086,14 @@ static void storeUnpremultiplied(T *dst, const T *src, const QColorVector *buffe
         v = vset_lane_u16(d_ptr->colorSpaceOut->lut[0]->m_fromLinear[ridx], v, isARGB ? 2 : 0);
         v = vset_lane_u16(d_ptr->colorSpaceOut->lut[1]->m_fromLinear[gidx], v, 1);
         v = vset_lane_u16(d_ptr->colorSpaceOut->lut[2]->m_fromLinear[bidx], v, isARGB ? 0 : 2);
-        storePU<T>(dst[i], v, a);
+        storePU<D>(dst[i], v, a);
     }
 }
 
 template<typename T>
-static void storeOpaque(T *dst, const T *src, const QColorVector *buffer, const qsizetype len,
+static void storeOpaque(T *dst, const QColorVector *buffer, const qsizetype len,
                         const QColorTransformPrivate *d_ptr)
 {
-    Q_UNUSED(src);
     constexpr bool isARGB = isArgb<T>();
     for (qsizetype i = 0; i < len; ++i) {
         float32x4_t vf = vld1q_f32(&buffer[i].x);
@@ -1082,10 +1132,9 @@ static void storeUnpremultiplied(QRgb *dst, const QRgb *src, const QColorVector
     }
 }
 
-static void storeOpaque(QRgb *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len,
+static void storeOpaque(QRgb *dst, const QColorVector *buffer, const qsizetype len,
                         const QColorTransformPrivate *d_ptr)
 {
-    Q_UNUSED(src);
     for (qsizetype i = 0; i < len; ++i) {
         const int r = d_ptr->colorSpaceOut->lut[0]->u8FromLinearF32(buffer[i].x);
         const int g = d_ptr->colorSpaceOut->lut[1]->u8FromLinearF32(buffer[i].y);
@@ -1094,11 +1143,12 @@ static void storeOpaque(QRgb *dst, const QRgb *src, const QColorVector *buffer,
     }
 }
 
-static void storePremultiplied(QRgba64 *dst, const QRgba64 *src, const QColorVector *buffer, const qsizetype len,
+template<typename S>
+static void storePremultiplied(QRgba64 *dst, const S *src, const QColorVector *buffer, const qsizetype len,
                                const QColorTransformPrivate *d_ptr)
 {
     for (qsizetype i = 0; i < len; ++i) {
-        const int a = src[i].alpha();
+        const int a = getAlphaF(src[i]) * 65535.f;
         const float fa = a / (255.0f * 256.0f);
         const float r = d_ptr->colorSpaceOut->lut[0]->m_fromLinear[int(buffer[i].x * 4080.0f + 0.5f)];
         const float g = d_ptr->colorSpaceOut->lut[1]->m_fromLinear[int(buffer[i].y * 4080.0f + 0.5f)];
@@ -1107,21 +1157,22 @@ static void storePremultiplied(QRgba64 *dst, const QRgba64 *src, const QColorVec
     }
 }
 
-static void storeUnpremultiplied(QRgba64 *dst, const QRgba64 *src, const QColorVector *buffer, const qsizetype len,
+template<typename S>
+static void storeUnpremultiplied(QRgba64 *dst, const S *src, const QColorVector *buffer, const qsizetype len,
                                  const QColorTransformPrivate *d_ptr)
 {
     for (qsizetype i = 0; i < len; ++i) {
+         const int a = getAlphaF(src[i]) * 65535.f;
          const int r = d_ptr->colorSpaceOut->lut[0]->u16FromLinearF32(buffer[i].x);
          const int g = d_ptr->colorSpaceOut->lut[1]->u16FromLinearF32(buffer[i].y);
          const int b = d_ptr->colorSpaceOut->lut[2]->u16FromLinearF32(buffer[i].z);
-         dst[i] = qRgba64(r, g, b, src[i].alpha());
+         dst[i] = qRgba64(r, g, b, a);
     }
 }
 
-static void storeOpaque(QRgba64 *dst, const QRgba64 *src, const QColorVector *buffer, const qsizetype len,
+static void storeOpaque(QRgba64 *dst, const QColorVector *buffer, const qsizetype len,
                         const QColorTransformPrivate *d_ptr)
 {
-    Q_UNUSED(src);
     for (qsizetype i = 0; i < len; ++i) {
         const int r = d_ptr->colorSpaceOut->lut[0]->u16FromLinearF32(buffer[i].x);
         const int g = d_ptr->colorSpaceOut->lut[1]->u16FromLinearF32(buffer[i].y);
@@ -1131,11 +1182,12 @@ static void storeOpaque(QRgba64 *dst, const QRgba64 *src, const QColorVector *bu
 }
 #endif
 #if !defined(__SSE2__)
-static void storePremultiplied(QRgbaFloat32 *dst, const QRgbaFloat32 *src, const QColorVector *buffer,
+template<typename S>
+static void storePremultiplied(QRgbaFloat32 *dst, const S *src, const QColorVector *buffer,
                                const qsizetype len, const QColorTransformPrivate *d_ptr)
 {
     for (qsizetype i = 0; i < len; ++i) {
-        const float a = src[i].a;
+        const float a = getAlphaF(src[i]);
         dst[i].r = d_ptr->colorSpaceOut->trc[0].applyInverseExtended(buffer[i].x) * a;
         dst[i].g = d_ptr->colorSpaceOut->trc[1].applyInverseExtended(buffer[i].y) * a;
         dst[i].b = d_ptr->colorSpaceOut->trc[2].applyInverseExtended(buffer[i].z) * a;
@@ -1143,11 +1195,12 @@ static void storePremultiplied(QRgbaFloat32 *dst, const QRgbaFloat32 *src, const
     }
 }
 
-static void storeUnpremultiplied(QRgbaFloat32 *dst, const QRgbaFloat32 *src, const QColorVector *buffer,
+template<typename S>
+static void storeUnpremultiplied(QRgbaFloat32 *dst, const S *src, const QColorVector *buffer,
                                  const qsizetype len, const QColorTransformPrivate *d_ptr)
 {
     for (qsizetype i = 0; i < len; ++i) {
-        const float a = src[i].a;
+        const float a = getAlphaF(src[i]);
         dst[i].r = d_ptr->colorSpaceOut->trc[0].applyInverseExtended(buffer[i].x);
         dst[i].g = d_ptr->colorSpaceOut->trc[1].applyInverseExtended(buffer[i].y);
         dst[i].b = d_ptr->colorSpaceOut->trc[2].applyInverseExtended(buffer[i].z);
@@ -1155,10 +1208,9 @@ static void storeUnpremultiplied(QRgbaFloat32 *dst, const QRgbaFloat32 *src, con
     }
 }
 
-static void storeOpaque(QRgbaFloat32 *dst, const QRgbaFloat32 *src, const QColorVector *buffer, const qsizetype len,
+static void storeOpaque(QRgbaFloat32 *dst, const QColorVector *buffer, const qsizetype len,
                         const QColorTransformPrivate *d_ptr)
 {
-    Q_UNUSED(src);
     for (qsizetype i = 0; i < len; ++i) {
         dst[i].r = d_ptr->colorSpaceOut->trc[0].applyInverseExtended(buffer[i].x);
         dst[i].g = d_ptr->colorSpaceOut->trc[1].applyInverseExtended(buffer[i].y);
@@ -1167,20 +1219,35 @@ static void storeOpaque(QRgbaFloat32 *dst, const QRgbaFloat32 *src, const QColor
     }
 }
 #endif
-static void storeGray(quint8 *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len,
+
+static void loadGray(QColorVector *buffer, const quint8 *src, const qsizetype len, const QColorTransformPrivate *d_ptr)
+{
+    for (qsizetype i = 0; i < len; ++i) {
+        const float y = d_ptr->colorSpaceIn->lut[0]->u8ToLinearF32(src[i]);
+        buffer[i] = d_ptr->colorSpaceIn->whitePoint * y;
+    }
+}
+
+static void loadGray(QColorVector *buffer, const quint16 *src, const qsizetype len, const QColorTransformPrivate *d_ptr)
+{
+    for (qsizetype i = 0; i < len; ++i) {
+        const float y = d_ptr->colorSpaceIn->lut[0]->u16ToLinearF32(src[i]);
+        buffer[i] = d_ptr->colorSpaceIn->whitePoint * y;
+    }
+}
+
+static void storeOpaque(quint8 *dst, const QColorVector *buffer, const qsizetype len,
                       const QColorTransformPrivate *d_ptr)
 {
-    Q_UNUSED(src);
     for (qsizetype i = 0; i < len; ++i)
-        dst[i] = d_ptr->colorSpaceOut->lut[1]->u8FromLinearF32(buffer[i].y);
+        dst[i] = d_ptr->colorSpaceOut->lut[0]->u8FromLinearF32(buffer[i].y);
 }
 
-static void storeGray(quint16 *dst, const QRgba64 *src, const QColorVector *buffer, const qsizetype len,
+static void storeOpaque(quint16 *dst, const QColorVector *buffer, const qsizetype len,
                       const QColorTransformPrivate *d_ptr)
 {
-    Q_UNUSED(src);
     for (qsizetype i = 0; i < len; ++i)
-        dst[i] = d_ptr->colorSpaceOut->lut[1]->u16FromLinearF32(buffer[i].y);
+        dst[i] = d_ptr->colorSpaceOut->lut[0]->u16FromLinearF32(buffer[i].y);
 }
 
 static constexpr qsizetype WorkBlockSize = 256;
@@ -1255,7 +1322,19 @@ void loadPremultipliedLUT(QColorVector *buffer, const QRgbaFloat32 *src, const q
     }
 }
 
-static void storeUnpremultipliedLUT(QRgb *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len)
+template<typename T>
+static void storeUnpremultipliedLUT(QRgb *dst, const T *, const QColorVector *buffer, const qsizetype len)
+{
+    for (qsizetype i = 0; i < len; ++i) {
+        const int r = buffer[i].x * 255.f;
+        const int g = buffer[i].y * 255.f;
+        const int b = buffer[i].z * 255.f;
+        dst[i] = 0xff000000 | (r << 16) | (g << 8) | (b << 0);
+    }
+}
+
+template<>
+void storeUnpremultipliedLUT(QRgb *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len)
 {
     for (qsizetype i = 0; i < len; ++i) {
         const int r = buffer[i].x * 255.f;
@@ -1265,29 +1344,60 @@ static void storeUnpremultipliedLUT(QRgb *dst, const QRgb *src, const QColorVect
     }
 }
 
-static void storeUnpremultipliedLUT(QRgba64 *dst, const QRgba64 *src,
+template<typename T>
+static void storeUnpremultipliedLUT(QRgba64 *dst, const T *,
                                     const QColorVector *buffer, const qsizetype len)
 {
     for (qsizetype i = 0; i < len; ++i) {
         const int r = buffer[i].x * 65535.f;
         const int g = buffer[i].y * 65535.f;
         const int b = buffer[i].z * 65535.f;
+        dst[i] = qRgba64(r, g, b, 65535);
+    }
+}
+
+template<>
+void storeUnpremultipliedLUT(QRgba64 *dst, const QRgb *src,
+                             const QColorVector *buffer, const qsizetype len)
+{
+    for (qsizetype i = 0; i < len; ++i) {
+        const int a = qAlpha(src[i]) * 257;
+        const int r = buffer[i].x * 65535.f;
+        const int g = buffer[i].y * 65535.f;
+        const int b = buffer[i].z * 65535.f;
+        dst[i] = qRgba64(r, g, b, a);
+    }
+}
+
+template<>
+void storeUnpremultipliedLUT(QRgba64 *dst, const QRgba64 *src,
+                             const QColorVector *buffer, const qsizetype len)
+{
+    for (qsizetype i = 0; i < len; ++i) {
+        const int r = buffer[i].x * 65535.f;
+        const int g = buffer[i].y * 65535.f;
+        const int b = buffer[i].z * 65535.f;
         dst[i] = qRgba64(r, g, b, src[i].alpha());
     }
 }
 
-static void storeUnpremultipliedLUT(QRgbaFloat32 *dst, const QRgbaFloat32 *src,
+template<typename T>
+static void storeUnpremultipliedLUT(QRgbaFloat32 *dst, const T *src,
                                     const QColorVector *buffer, const qsizetype len)
 {
     for (qsizetype i = 0; i < len; ++i) {
         const float r = buffer[i].x;
         const float g = buffer[i].y;
         const float b = buffer[i].z;
-        dst[i] = QRgbaFloat32{r, g, b, src[i].a};
+        dst[i] = QRgbaFloat32{r, g, b, getAlphaF(src[i])};
     }
 }
 
-static void storePremultipliedLUT(QRgb *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len)
+template<typename T>
+static void storePremultipliedLUT(QRgb *, const T *, const QColorVector *, const qsizetype);
+
+template<>
+void storePremultipliedLUT(QRgb *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len)
 {
     for (qsizetype i = 0; i < len; ++i) {
         const int a = qAlpha(src[i]);
@@ -1298,8 +1408,23 @@ static void storePremultipliedLUT(QRgb *dst, const QRgb *src, const QColorVector
     }
 }
 
-static void storePremultipliedLUT(QRgba64 *dst, const QRgba64 *src,
-                                  const QColorVector *buffer, const qsizetype len)
+template<typename T>
+static void storePremultipliedLUT(QRgba64 *, const T *, const QColorVector *, const qsizetype);
+
+template<>
+void storePremultipliedLUT(QRgba64 *dst, const QRgb *src, const QColorVector *buffer, const qsizetype len)
+{
+    for (qsizetype i = 0; i < len; ++i) {
+        const int a = qAlpha(src[i]) * 257;
+        const int r = buffer[i].x * a;
+        const int g = buffer[i].y * a;
+        const int b = buffer[i].z * a;
+        dst[i] = qRgba64(r, g, b, a);
+    }
+}
+
+template<>
+void storePremultipliedLUT(QRgba64 *dst, const QRgba64 *src, const QColorVector *buffer, const qsizetype len)
 {
     for (qsizetype i = 0; i < len; ++i) {
         const int a = src[i].alpha();
@@ -1310,11 +1435,11 @@ static void storePremultipliedLUT(QRgba64 *dst, const QRgba64 *src,
     }
 }
 
-static void storePremultipliedLUT(QRgbaFloat32 *dst, const QRgbaFloat32 *src,
-                                  const QColorVector *buffer, const qsizetype len)
+template<typename T>
+static void storePremultipliedLUT(QRgbaFloat32 *dst, const T *src, const QColorVector *buffer, const qsizetype len)
 {
     for (qsizetype i = 0; i < len; ++i) {
-        const float a = src[i].a;
+        const float a = getAlphaF(src[i]);
         const float r = buffer[i].x * a;
         const float g = buffer[i].y * a;
         const float b = buffer[i].z * a;
@@ -1372,6 +1497,9 @@ QColorVector QColorTransformPrivate::map(QColorVector c) const
         for (auto &&element : colorSpaceIn->mAB)
             std::visit([&c](auto &&elm) { visitElement(elm, &c, 1); }, element);
     }
+    c.x = std::clamp(c.x, 0.0f, 1.0f);
+    c.y = std::clamp(c.y, 0.0f, 1.0f);
+    c.z = std::clamp(c.z, 0.0f, 1.0f);
 
     // Match Profile Connection Spaces (PCS):
     if (colorSpaceOut->isPcsLab && !colorSpaceIn->isPcsLab)
@@ -1380,11 +1508,12 @@ QColorVector QColorTransformPrivate::map(QColorVector c) const
         c = c.labToXyz();
 
     if (colorSpaceOut->isThreeComponentMatrix()) {
-        if (!colorSpaceIn->isThreeComponentMatrix())
+        if (!colorSpaceIn->isThreeComponentMatrix()) {
             c = colorMatrix.map(c);
-        c.x = std::clamp(c.x, 0.0f, 1.0f);
-        c.y = std::clamp(c.y, 0.0f, 1.0f);
-        c.z = std::clamp(c.z, 0.0f, 1.0f);
+            c.x = std::clamp(c.x, 0.0f, 1.0f);
+            c.y = std::clamp(c.y, 0.0f, 1.0f);
+            c.z = std::clamp(c.z, 0.0f, 1.0f);
+        }
         if (colorSpaceOut->lut.generated.loadAcquire()) {
             c.x = colorSpaceOut->lut[0]->fromLinear(c.x);
             c.y = colorSpaceOut->lut[1]->fromLinear(c.y);
@@ -1398,6 +1527,9 @@ QColorVector QColorTransformPrivate::map(QColorVector c) const
         // Do element based conversion
         for (auto &&element : colorSpaceOut->mBA)
             std::visit([&c](auto &&elm) { visitElement(elm, &c, 1); }, element);
+        c.x = std::clamp(c.x, 0.0f, 1.0f);
+        c.y = std::clamp(c.y, 0.0f, 1.0f);
+        c.z = std::clamp(c.z, 0.0f, 1.0f);
     }
     return c;
 }
@@ -1438,8 +1570,8 @@ QColorVector QColorTransformPrivate::mapExtended(QColorVector c) const
     return c;
 }
 
-template<typename T>
-void QColorTransformPrivate::applyConvertIn(const T *src, QColorVector *buffer, qsizetype len, TransformFlags flags) const
+template<typename S>
+void QColorTransformPrivate::applyConvertIn(const S *src, QColorVector *buffer, qsizetype len, TransformFlags flags) const
 {
     if (colorSpaceIn->isThreeComponentMatrix()) {
         if (flags & InputPremultiplied)
@@ -1455,20 +1587,24 @@ void QColorTransformPrivate::applyConvertIn(const T *src, QColorVector *buffer,
         else
             loadUnpremultipliedLUT(buffer, src, len);
 
+        if constexpr (std::is_same_v<S, QRgbaFloat16> || std::is_same_v<S, QRgbaFloat32>)
+            clampIfNeeded<DoClamp>(buffer, len);
+
         // Do element based conversion
         for (auto &&element : colorSpaceIn->mAB)
             std::visit([&buffer, len](auto &&elm) { visitElement(elm, buffer, len); }, element);
     }
 }
 
-template<typename T>
-void QColorTransformPrivate::applyConvertOut(T *dst, const T *src, QColorVector *buffer, qsizetype len, TransformFlags flags) const
+template<typename D, typename S>
+void QColorTransformPrivate::applyConvertOut(D *dst, const S *src, QColorVector *buffer, qsizetype len, TransformFlags flags) const
 {
+    constexpr ApplyMatrixForm doClamp = (std::is_same_v<D, QRgbaFloat16> || std::is_same_v<D, QRgbaFloat32>) ? DoNotClamp : DoClamp;
     if (colorSpaceOut->isThreeComponentMatrix()) {
-        applyMatrix<DoClamp>(buffer, len, colorMatrix); // colorMatrix should have the latter half only.
+        applyMatrix<doClamp>(buffer, len, colorMatrix); // colorMatrix should have the latter half only.
 
         if (flags & InputOpaque)
-            storeOpaque(dst, src, buffer, len, this);
+            storeOpaque(dst, buffer, len, this);
         else if (flags & OutputPremultiplied)
             storePremultiplied(dst, src, buffer, len, this);
         else
@@ -1478,11 +1614,7 @@ void QColorTransformPrivate::applyConvertOut(T *dst, const T *src, QColorVector
         for (auto &&element : colorSpaceOut->mBA)
             std::visit([&buffer, len](auto &&elm) { visitElement(elm, buffer, len); }, element);
 
-        for (qsizetype j = 0; j < len; ++j) {
-            buffer[j].x = std::clamp(buffer[j].x, 0.f, 1.f);
-            buffer[j].y = std::clamp(buffer[j].y, 0.f, 1.f);
-            buffer[j].z = std::clamp(buffer[j].z, 0.f, 1.f);
-        }
+        clampIfNeeded<doClamp>(buffer, len);
 
         if (flags & OutputPremultiplied)
             storePremultipliedLUT(dst, src, buffer, len);
@@ -1491,8 +1623,8 @@ void QColorTransformPrivate::applyConvertOut(T *dst, const T *src, QColorVector
     }
 }
 
-template<typename T>
-void QColorTransformPrivate::applyElementListTransform(T *dst, const T *src, qsizetype count, TransformFlags flags) const
+template<typename D, typename S>
+void QColorTransformPrivate::applyElementListTransform(D *dst, const S *src, qsizetype count, TransformFlags flags) const
 {
     Q_ASSERT(!colorSpaceIn->isThreeComponentMatrix() || !colorSpaceOut->isThreeComponentMatrix());
 
@@ -1526,8 +1658,8 @@ void QColorTransformPrivate::applyElementListTransform(T *dst, const T *src, qsi
     }
 }
 
-template<typename T>
-void QColorTransformPrivate::applyThreeComponentMatrix(T *dst, const T *src, qsizetype count, TransformFlags flags) const
+template<typename D, typename S>
+void QColorTransformPrivate::applyThreeComponentMatrix(D *dst, const S *src, qsizetype count, TransformFlags flags) const
 {
     Q_ASSERT(colorSpaceIn->isThreeComponentMatrix() && colorSpaceOut->isThreeComponentMatrix());
 
@@ -1538,7 +1670,7 @@ void QColorTransformPrivate::applyThreeComponentMatrix(T *dst, const T *src, qsi
     updateLutsOut();
 
     bool doApplyMatrix = !colorMatrix.isIdentity();
-    constexpr ApplyMatrixForm doClamp = (std::is_same_v<T, QRgbaFloat16> || std::is_same_v<T, QRgbaFloat32>) ? DoNotClamp : DoClamp;
+    constexpr ApplyMatrixForm doClamp = (std::is_same_v<D, QRgbaFloat16> || std::is_same_v<D, QRgbaFloat32>) ? DoNotClamp : DoClamp;
 
     QUninitialized<QColorVector, WorkBlockSize> buffer;
     qsizetype i = 0;
@@ -1551,9 +1683,11 @@ void QColorTransformPrivate::applyThreeComponentMatrix(T *dst, const T *src, qsi
 
         if (doApplyMatrix)
             applyMatrix<doClamp>(buffer, len, colorMatrix);
+        else
+            clampIfNeeded<doClamp>(buffer, len);
 
         if (flags & InputOpaque)
-            storeOpaque(dst + i, src + i, buffer, len, this);
+            storeOpaque(dst + i, buffer, len, this);
         else if (flags & OutputPremultiplied)
             storePremultiplied(dst + i, src + i, buffer, len, this);
         else
@@ -1563,13 +1697,22 @@ void QColorTransformPrivate::applyThreeComponentMatrix(T *dst, const T *src, qsi
     }
 }
 
-template<typename T>
-void QColorTransformPrivate::apply(T *dst, const T *src, qsizetype count, TransformFlags flags) const
+/*!
+    \internal
+    Applies the color transformation on \a count S pixels starting from
+    \a src and stores the result in \a dst as D pixels .
+
+    Assumes unpremultiplied data by default. Set \a flags to change defaults.
+
+    \sa prepare()
+*/
+template<typename D, typename S>
+void QColorTransformPrivate::apply(D *dst, const S *src, qsizetype count, TransformFlags flags) const
 {
-    if (colorSpaceIn->isThreeComponentMatrix() && colorSpaceOut->isThreeComponentMatrix())
-        applyThreeComponentMatrix<T>(dst, src, count, flags);
+    if (isThreeComponentMatrix())
+        applyThreeComponentMatrix<D, S>(dst, src, count, flags);
     else
-        applyElementListTransform<T>(dst, src, count, flags);
+        applyElementListTransform<D, S>(dst, src, count, flags);
 }
 
 /*!
@@ -1580,6 +1723,7 @@ void QColorTransformPrivate::apply(T *dst, const T *src, qsizetype count, Transf
 template<typename D, typename S>
 void QColorTransformPrivate::applyReturnGray(D *dst, const S *src, qsizetype count, TransformFlags flags) const
 {
+    Q_ASSERT(colorSpaceOut->isThreeComponentMatrix());
     if (!colorSpaceIn->isThreeComponentMatrix()) {
         QUninitialized<QColorVector, WorkBlockSize> buffer;
 
@@ -1595,7 +1739,8 @@ void QColorTransformPrivate::applyReturnGray(D *dst, const S *src, qsizetype cou
             for (auto &&element : colorSpaceIn->mAB)
                 std::visit([&](auto &&elm) { visitElement(elm, buffer, len); }, element);
 
-            storeGray(dst + i, src + i, buffer, len, this);
+            applyMatrix<DoClamp>(buffer, len, colorMatrix);
+            storeOpaque(dst + i, buffer, len, this);
 
             i += len;
         }
@@ -1620,7 +1765,7 @@ void QColorTransformPrivate::applyReturnGray(D *dst, const S *src, qsizetype cou
 
         applyMatrix<DoClamp>(buffer, len, colorMatrix);
 
-        storeGray(dst + i, src + i, buffer, len, this);
+        storeOpaque(dst + i, buffer, len, this);
 
         i += len;
     }
@@ -1628,84 +1773,99 @@ void QColorTransformPrivate::applyReturnGray(D *dst, const S *src, qsizetype cou
 
 /*!
     \internal
-    \enum QColorTransformPrivate::TransformFlag
+*/
+template<typename D, typename S>
+void QColorTransformPrivate::applyGray(D *dst, const S *src, qsizetype count, TransformFlags) const
+{
+    Q_ASSERT(colorSpaceIn->isThreeComponentMatrix());
+    if constexpr (std::is_same_v<D, QRgb> || std::is_same_v<D, QRgba64> || std::is_same_v<D, QRgbaFloat32>) {
+        if (!colorSpaceOut->isThreeComponentMatrix()) {
+            QUninitialized<QColorVector, WorkBlockSize> buffer;
 
-    Defines how the transform is to be applied.
+            qsizetype i = 0;
+            while (i < count) {
+                const qsizetype len = qMin(count - i, WorkBlockSize);
+                loadGray(buffer, src + i, len, this);
 
-    \value Unpremultiplied The input and output should both be unpremultiplied.
-    \value InputOpaque The input is guaranteed to be opaque.
-    \value InputPremultiplied The input is premultiplied.
-    \value OutputPremultiplied The output should be premultiplied.
-    \value Premultiplied Both input and output should both be premultiplied.
-*/
+                applyMatrix<DoClamp>(buffer, len, colorMatrix);
 
-/*!
-    \internal
-    Prepares a color transformation for fast application. You do not need to
-    call this explicitly as it will be called implicitly on the first transforms, but
-    if you want predictable performance on the first transforms, you can perform it
-    in advance.
+                // Do element based conversion
+                for (auto &&element : colorSpaceOut->mBA)
+                    std::visit([&buffer, len](auto &&elm) { visitElement(elm, buffer, len); }, element);
+
+                clampIfNeeded<DoClamp>(buffer, len);
+
+                storeUnpremultipliedLUT(dst, src, buffer, len); // input is always opaque
+
+                i += len;
+            }
+            return;
+        }
+    }
+    Q_ASSERT(colorSpaceOut->isThreeComponentMatrix());
+    if (!colorMatrix.isValid())
+        return;
 
-    \sa QColorTransform::map(), apply()
-*/
-void QColorTransformPrivate::prepare()
-{
     updateLutsIn();
     updateLutsOut();
-}
 
-/*!
-    \internal
-    Applies the color transformation on \a count QRgb pixels starting from
-    \a src and stores the result in \a dst.
+    QUninitialized<QColorVector, WorkBlockSize> buffer;
 
-    Thread-safe if prepare() has been called first.
+    qsizetype i = 0;
+    while (i < count) {
+        const qsizetype len = qMin(count - i, WorkBlockSize);
+        loadGray(buffer, src + i, len, this);
 
-    Assumes unpremultiplied data by default. Set \a flags to change defaults.
+        applyMatrix<DoClamp>(buffer, len, colorMatrix);
 
-    \sa prepare()
-*/
-void QColorTransformPrivate::apply(QRgb *dst, const QRgb *src, qsizetype count, TransformFlags flags) const
-{
-    apply<QRgb>(dst, src, count, flags);
+        storeOpaque(dst + i, buffer, len, this);
+        i += len;
+    }
 }
 
 /*!
     \internal
-    Applies the color transformation on \a count QRgba64 pixels starting from
-    \a src and stores the result in \a dst.
-
-    Thread-safe if prepare() has been called first.
+    \enum QColorTransformPrivate::TransformFlag
 
-    Assumes unpremultiplied data by default. Set \a flags to change defaults.
+    Defines how the transform should handle alpha values.
 
-    \sa prepare()
+    \value Unpremultiplied The input and output should both be unpremultiplied.
+    \value InputOpaque The input is guaranteed to be opaque.
+    \value InputPremultiplied The input is premultiplied.
+    \value OutputPremultiplied The output should be premultiplied.
+    \value Premultiplied Both input and output should both be premultiplied.
 */
-void QColorTransformPrivate::apply(QRgba64 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags) const
-{
-    apply<QRgba64>(dst, src, count, flags);
-}
 
 /*!
     \internal
-    Applies the color transformation on \a count QRgbaFloat32 pixels starting from
-    \a src and stores the result in \a dst.
-
-    Thread-safe if prepare() has been called first.
-
-    Assumes unpremultiplied data by default. Set \a flags to change defaults.
+    Prepares a color transformation for fast application. You do not need to
+    call this explicitly as it will be called implicitly on the first transforms, but
+    if you want predictable performance on the first transforms, you can perform it
+    in advance.
 
-    \sa prepare()
+    \sa QColorTransform::map(), apply()
 */
-void QColorTransformPrivate::apply(QRgbaFloat32 *dst, const QRgbaFloat32 *src, qsizetype count,
-                                   TransformFlags flags) const
+void QColorTransformPrivate::prepare()
 {
-    apply<QRgbaFloat32>(dst, src, count, flags);
+    updateLutsIn();
+    updateLutsOut();
 }
 
-
+// Only allow versions increasing precision
 template void QColorTransformPrivate::applyReturnGray<quint8, QRgb>(quint8 *dst, const QRgb *src, qsizetype count, TransformFlags flags) const;
 template void QColorTransformPrivate::applyReturnGray<quint16, QRgba64>(quint16 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags) const;
+template void QColorTransformPrivate::applyGray<quint8, quint8>(quint8 *dst, const quint8 *src, qsizetype count, TransformFlags flags) const;
+template void QColorTransformPrivate::applyGray<quint16, quint8>(quint16 *dst, const quint8 *src, qsizetype count, TransformFlags flags) const;
+template void QColorTransformPrivate::applyGray<quint16, quint16>(quint16 *dst, const quint16 *src, qsizetype count, TransformFlags flags) const;
+template void QColorTransformPrivate::applyGray<QRgb, quint8>(QRgb *dst, const quint8 *src, qsizetype count, TransformFlags flags) const;
+template void QColorTransformPrivate::applyGray<QRgba64, quint16>(QRgba64 *dst, const quint16 *src, qsizetype count, TransformFlags flags) const;
+
+template void QColorTransformPrivate::apply<QRgb, QRgb>(QRgb *dst, const QRgb *src, qsizetype count, TransformFlags flags) const;
+template void QColorTransformPrivate::apply<QRgba64, QRgb>(QRgba64 *dst, const QRgb *src, qsizetype count, TransformFlags flags) const;
+template void QColorTransformPrivate::apply<QRgba64, QRgba64>(QRgba64 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags) const;
+template void QColorTransformPrivate::apply<QRgbaFloat32, QRgb>(QRgbaFloat32 *dst, const QRgb *src, qsizetype count, TransformFlags flags) const;
+template void QColorTransformPrivate::apply<QRgbaFloat32, QRgba64>(QRgbaFloat32 *dst, const QRgba64 *src, qsizetype count, TransformFlags flags) const;
+template void QColorTransformPrivate::apply<QRgbaFloat32, QRgbaFloat32>(QRgbaFloat32 *dst, const QRgbaFloat32 *src, qsizetype count, TransformFlags flags) const;
 
 bool QColorTransformPrivate::isThreeComponentMatrix() const
 {