// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

#include <qglobal.h>

#include "qdrawhelper_p.h"
#include "qrgba64_p.h"
#include "qrgbafloat.h"

QT_BEGIN_NAMESPACE

/* The constant alpha factor describes an alpha factor that gets applied
   to the result of the composition operation combining it with the destination.

   The intent is that if const_alpha == 0. we get back dest, and if const_alpha == 1.
   we get the unmodified operation

   result = src op dest
   dest = result * const_alpha + dest * (1. - const_alpha)

   This means that in the comments below, the first line is the const_alpha==255 case, the
   second line the general one.

   In the lines below:
   s == src, sa == alpha(src), sia = 1 - alpha(src)
   d == dest, da == alpha(dest), dia = 1 - alpha(dest)
   ca = const_alpha, cia = 1 - const_alpha

   The methods exist in two variants. One where we have a constant source, the other
   where the source is an array of pixels.
*/

struct Argb32OperationsC
{
    typedef QRgb Type;
    typedef quint8 Scalar;
    typedef QRgb OptimalType;
    typedef quint8 OptimalScalar;

    static const Type clear;
    static bool isOpaque(Type val)
    { return qAlpha(val) == 255; }
    static bool isTransparent(Type val)
    { return qAlpha(val) == 0; }
    static Scalar scalarFrom8bit(uint8_t a)
    { return a; }
    static void memfill(Type *ptr, Type value, qsizetype len)
    { qt_memfill32(ptr, value, len); }
    static void memcpy(Type *Q_DECL_RESTRICT dest, const Type *Q_DECL_RESTRICT src, qsizetype len)
    { ::memcpy(dest, src, len * sizeof(Type)); }

    static OptimalType load(const Type *ptr)
    { return *ptr; }
    static OptimalType convert(const Type &val)
    { return val; }
    static void store(Type *ptr, OptimalType value)
    { *ptr = value; }
    static OptimalType add(OptimalType a, OptimalType b)
    { return a + b; }
    static OptimalScalar add(OptimalScalar a, OptimalScalar b)
    { return a + b; }
    static OptimalType plus(OptimalType a, OptimalType b)
    { return comp_func_Plus_one_pixel(a, b); }
    static OptimalScalar alpha(OptimalType val)
    { return qAlpha(val); }
    static OptimalScalar invAlpha(OptimalScalar c)
    { return 255 - c; }
    static OptimalScalar invAlpha(OptimalType val)
    { return alpha(~val); }
    static OptimalScalar scalar(Scalar v)
    { return v; }
    static OptimalType multiplyAlpha8bit(OptimalType val, uint8_t a)
    { return BYTE_MUL(val, a); }
    static OptimalType interpolate8bit(OptimalType x, uint8_t a1, OptimalType y, uint8_t a2)
    { return INTERPOLATE_PIXEL_255(x, a1, y, a2); }
    static OptimalType multiplyAlpha(OptimalType val, OptimalScalar a)
    { return BYTE_MUL(val, a); }
    static OptimalScalar multiplyAlpha8bit(OptimalScalar val, uint8_t a)
    { return qt_div_255(val * a); }
    static OptimalType interpolate(OptimalType x, OptimalScalar a1, OptimalType y, OptimalScalar a2)
    { return INTERPOLATE_PIXEL_255(x, a1, y, a2); }
};

const Argb32OperationsC::Type Argb32OperationsC::clear = 0;

typedef Argb32OperationsC Argb32Operations;

struct Rgba64OperationsBase
{
    typedef QRgba64 Type;
    typedef quint16 Scalar;

    static const Type clear;

    static bool isOpaque(Type val)
    { return val.isOpaque(); }
    static bool isTransparent(Type val)
    { return val.isTransparent(); }
    static Scalar scalarFrom8bit(uint8_t a)
    { return a * 257; }

    static void memfill(Type *ptr, Type value, qsizetype len)
    { qt_memfill64((quint64*)ptr, value, len); }
    static void memcpy(Type *Q_DECL_RESTRICT dest, const Type *Q_DECL_RESTRICT src, qsizetype len)
    { ::memcpy(dest, src, len * sizeof(Type)); }
};

#if QT_CONFIG(raster_64bit)
const Rgba64OperationsBase::Type Rgba64OperationsBase::clear = QRgba64::fromRgba64(0);

struct Rgba64OperationsC : public Rgba64OperationsBase
{
    typedef QRgba64 OptimalType;
    typedef quint16 OptimalScalar;

    static OptimalType load(const Type *ptr)
    { return *ptr; }
    static OptimalType convert(const Type &val)
    { return val; }
    static void store(Type *ptr, OptimalType value)
    { *ptr = value; }
    static OptimalType add(OptimalType a, OptimalType b)
    { return QRgba64::fromRgba64((quint64)a + (quint64)b); }
    static OptimalScalar add(OptimalScalar a, OptimalScalar b)
    { return a + b; }
    static OptimalType plus(OptimalType a, OptimalType b)
    { return addWithSaturation(a, b); }
    static OptimalScalar alpha(OptimalType val)
    { return val.alpha(); }
    static OptimalScalar invAlpha(Scalar c)
    { return 65535 - c; }
    static OptimalScalar invAlpha(OptimalType val)
    { return 65535 - alpha(val); }
    static OptimalScalar scalar(Scalar v)
    { return v; }
    static OptimalType multiplyAlpha8bit(OptimalType val, uint8_t a)
    { return multiplyAlpha255(val, a); }
    static OptimalScalar multiplyAlpha8bit(OptimalScalar val, uint8_t a)
    { return qt_div_255(val * a); }
    static OptimalType interpolate8bit(OptimalType x, uint8_t a1, OptimalType y, uint8_t a2)
    { return interpolate255(x, a1, y, a2); }
    static OptimalType multiplyAlpha(OptimalType val, OptimalScalar a)
    { return multiplyAlpha65535(val, a); }
    static OptimalType interpolate(OptimalType x, OptimalScalar a1, OptimalType y, OptimalScalar a2)
    { return interpolate65535(x, a1, y, a2); }
};

#if defined(__SSE2__)
struct Rgba64OperationsSSE2 : public Rgba64OperationsBase
{
    typedef __m128i OptimalType;
    typedef __m128i OptimalScalar;

    static OptimalType load(const Type *ptr)
    {
        return _mm_loadl_epi64(reinterpret_cast<const __m128i *>(ptr));
    }
    static OptimalType convert(const Type &value)
    {
#ifdef Q_PROCESSOR_X86_64
        return _mm_cvtsi64_si128(value);
#else
        return load(&value);
#endif
    }
    static void store(Type *ptr, OptimalType value)
    {
        _mm_storel_epi64(reinterpret_cast<__m128i *>(ptr), value);
    }
    static OptimalType add(OptimalType a, OptimalType b)
    {
        return _mm_add_epi16(a, b);
    }
//    same as above:
//    static OptimalScalar add(OptimalScalar a, OptimalScalar b)
    static OptimalType plus(OptimalType a, OptimalType b)
    {
        return _mm_adds_epu16(a, b);
    }
    static OptimalScalar alpha(OptimalType c)
    {
        return _mm_shufflelo_epi16(c, _MM_SHUFFLE(3, 3, 3, 3));
    }
    static OptimalScalar invAlpha(Scalar c)
    {
        return scalar(65535 - c);
    }
    static OptimalScalar invAlpha(OptimalType c)
    {
        return _mm_xor_si128(_mm_set1_epi16(-1), alpha(c));
    }
    static OptimalScalar scalar(Scalar n)
    {
        return _mm_shufflelo_epi16(_mm_cvtsi32_si128(n), _MM_SHUFFLE(0, 0, 0, 0));
    }
    static OptimalType multiplyAlpha8bit(OptimalType val, uint8_t a)
    {
        return multiplyAlpha255(val, a);
    }
//    same as above:
//    static OptimalScalar multiplyAlpha8bit(OptimalScalar a, uint8_t a)
    static OptimalType interpolate8bit(OptimalType x, uint8_t a1, OptimalType y, uint8_t a2)
    {
        return interpolate255(x, a1, y, a2);
    }
    static OptimalType multiplyAlpha(OptimalType val, OptimalScalar a)
    {
        return multiplyAlpha65535(val, a);
    }
    // a2 is const-ref because otherwise MSVC2015@x86 complains that it can't 16-byte align the argument.
    static OptimalType interpolate(OptimalType x, OptimalScalar a1, OptimalType y, const OptimalScalar &a2)
    {
        return interpolate65535(x, a1, y, a2);
    }
};
#endif

#if defined(__ARM_NEON__)
struct Rgba64OperationsNEON : public Rgba64OperationsBase
{
    typedef uint16x4_t OptimalType;
    typedef uint16x4_t OptimalScalar;

    static OptimalType load(const Type *ptr)
    {
        return vreinterpret_u16_u64(vld1_u64(reinterpret_cast<const uint64_t *>(ptr)));
    }
    static OptimalType convert(const Type &val)
    {
        return vreinterpret_u16_u64(vmov_n_u64(val));
    }
    static void store(Type *ptr, OptimalType value)
    {
        vst1_u64(reinterpret_cast<uint64_t *>(ptr), vreinterpret_u64_u16(value));
    }
    static OptimalType add(OptimalType a, OptimalType b)
    {
        return vadd_u16(a, b);
    }
//    same as above:
//    static OptimalScalar add(OptimalScalar a, OptimalScalar b)
    static OptimalType plus(OptimalType a, OptimalType b)
    {
        return vqadd_u16(a, b);
    }
    static OptimalScalar alpha(OptimalType c)
    {
        return vdup_lane_u16(c, 3);
    }
    static OptimalScalar invAlpha(Scalar c)
    {
        return scalar(65535 - c);
    }
    static OptimalScalar invAlpha(OptimalType c)
    {
        return vmvn_u16(alpha(c));
    }
    static OptimalScalar scalar(Scalar n)
    {
        return vdup_n_u16(n);
    }
    static OptimalType multiplyAlpha8bit(OptimalType val, uint8_t a)
    {
        return multiplyAlpha255(val, a);
    }
//    same as above:
//    static OptimalScalar multiplyAlpha8bit(OptimalScalar a, uint8_t a)
    static OptimalType interpolate8bit(OptimalType x, uint8_t a1, OptimalType y, uint8_t a2)
    {
        return interpolate255(x, a1, y, a2);
    }
    static OptimalType multiplyAlpha(OptimalType val, OptimalScalar a)
    {
        return multiplyAlpha65535(val, a);
    }
    static OptimalType interpolate(OptimalType x, OptimalScalar a1, OptimalType y, OptimalScalar a2)
    {
        return interpolate65535(x, a1, y, a2);
    }
};
#endif

#if defined(__SSE2__)
typedef Rgba64OperationsSSE2 Rgba64Operations;
#elif defined(__ARM_NEON__)
typedef Rgba64OperationsNEON Rgba64Operations;
#else
typedef Rgba64OperationsC Rgba64Operations;
#endif

#endif // QT_CONFIG(raster_64bit)

#if QT_CONFIG(raster_fp)

static inline QRgbaFloat32 qRgbaFloat32(float r, float g, float b, float a)
{
    return QRgbaFloat32{r, g, b, a};
}

struct RgbaFPOperationsBase
{
    typedef QRgbaFloat32 Type;
    typedef float Scalar;

    static inline constexpr Type clear = { 0, 0, 0, 0 };

    static bool isOpaque(Type val)
    { return val.a >= 1.0f; }
    static bool isTransparent(Type val)
    { return val.a <= 0.0f; }
    static Scalar scalarFrom8bit(uint8_t a)
    { return a * (1.0f / 255.0f); }

    static void memfill(Type *ptr, Type value, qsizetype len)
    {
        for (qsizetype i = 0; i < len; ++i)
            ptr[i] = value;
    }
    static void memcpy(Type *Q_DECL_RESTRICT dest, const Type *Q_DECL_RESTRICT src, qsizetype len)
    { ::memcpy(dest, src, len * sizeof(Type)); }
};

struct RgbaFPOperationsC : RgbaFPOperationsBase
{
    typedef QRgbaFloat32 OptimalType;
    typedef float OptimalScalar;

    static OptimalType load(const Type *ptr)
    {
        return QRgbaFloat32 { ptr->r, ptr->g, ptr->b, ptr->a };
    }
    static OptimalType convert(const Type &val)
    {
        return QRgbaFloat32 { val.r, val.g, val.b, val.a };
    }
    static void store(Type *ptr, OptimalType value)
    {
        ptr->r = value.r;
        ptr->g = value.g;
        ptr->b = value.b;
        ptr->a = value.a;
    }
    static OptimalType add(OptimalType a, OptimalType b)
    {
        a.r += b.r;
        a.g += b.g;
        a.b += b.b;
        a.a += b.a;
        return a;
    }
    static OptimalScalar add(OptimalScalar a, OptimalScalar b)
    { return a + b; }
    static OptimalType plus(OptimalType a, OptimalType b)
    {
        a = add(a, b); // no saturation on color values
        if (a.a < 0.0f) a.a = 0.0f;
        else if (a.a > 1.0f) a.a = 1.0f;
        return a;
    }
    static OptimalScalar alpha(OptimalType val)
    { return val.a; }
    static OptimalScalar invAlpha(OptimalScalar c)
    { return 1.0f - c; }
    static OptimalScalar invAlpha(OptimalType val)
    { return 1.0f - val.a; }
    static OptimalScalar scalar(Scalar v)
    { return v; }
    static OptimalType multiplyAlpha(OptimalType val, OptimalScalar a)
    {
        val.r *= a;
        val.g *= a;
        val.b *= a;
        val.a *= a;
        return val;
    }
    static OptimalScalar multiplyAlpha8bit(OptimalScalar val, uint8_t a)
    {
        return val * a * (1.0f / 255.0f);
    }
    static OptimalType interpolate(OptimalType x, OptimalScalar a1, OptimalType y, OptimalScalar a2)
    {
        return add(multiplyAlpha(x, a1), multiplyAlpha(y, a2));
    }
    static OptimalType multiplyAlpha8bit(OptimalType val, uint8_t a)
    {
        return multiplyAlpha(val, a  * (1.0f / 255.0f));
    }
    static OptimalType interpolate8bit(OptimalType x, uint8_t a1, OptimalType y, uint8_t a2)
    {
        return add(multiplyAlpha8bit(x, a1), multiplyAlpha8bit(y, a2));
    }
};

#if defined(__SSE2__)
struct RgbaFPOperationsSSE2 : public RgbaFPOperationsBase
{
    typedef __m128 OptimalType;
    typedef __m128 OptimalScalar;

    static OptimalType Q_DECL_VECTORCALL load(const Type *ptr)
    {
        return _mm_loadu_ps(reinterpret_cast<const float *>(ptr));
    }
    static OptimalType Q_DECL_VECTORCALL convert(const Type &value)
    {
        return load(&value);
    }
    static void Q_DECL_VECTORCALL store(Type *ptr, OptimalType value)
    {
        _mm_storeu_ps(reinterpret_cast<float *>(ptr), value);
    }
    static OptimalType Q_DECL_VECTORCALL add(OptimalType a, OptimalType b)
    {
        return _mm_add_ps(a, b);
    }
//    same as above:
//    static OptimalScalar add(OptimalScalar a, OptimalScalar b)
    static OptimalType Q_DECL_VECTORCALL plus(OptimalType a, OptimalType b)
    {
        a = _mm_add_ps(a, b);
        __m128 aa = _mm_min_ps(a, _mm_set1_ps(1.0f));
        aa = _mm_max_ps(aa, _mm_set1_ps(0.0f));
        // An indirect insert using only SSE2:
        aa = _mm_shuffle_ps(aa, a, _MM_SHUFFLE(2, 2, 3, 3));
        a = _mm_shuffle_ps(a, aa, _MM_SHUFFLE(0, 2, 1, 0));
        return a;
    }
    static OptimalScalar Q_DECL_VECTORCALL alpha(OptimalType c)
    {
        return _mm_shuffle_ps(c, c, _MM_SHUFFLE(3, 3, 3, 3));
    }
    static OptimalScalar Q_DECL_VECTORCALL invAlpha(Scalar c)
    {
        return _mm_set1_ps(1.0f - float(c));
    }
    static OptimalScalar Q_DECL_VECTORCALL invAlpha(OptimalType c)
    {
        return _mm_sub_ps(_mm_set1_ps(1.0f), alpha(c));
    }
    static OptimalScalar Q_DECL_VECTORCALL scalar(Scalar n)
    {
        return _mm_set1_ps(float(n));
    }
    static OptimalType Q_DECL_VECTORCALL multiplyAlpha(OptimalType val, OptimalScalar a)
    {
        return _mm_mul_ps(val, a);
    }
    static OptimalType Q_DECL_VECTORCALL interpolate(OptimalType x, OptimalScalar a1, OptimalType y, OptimalScalar a2)
    {
        return add(multiplyAlpha(x, a1), multiplyAlpha(y, a2));
    }
    static OptimalType Q_DECL_VECTORCALL multiplyAlpha8bit(OptimalType val, uint8_t a)
    {
        return multiplyAlpha(val, _mm_set1_ps(a  * (1.0f / 255.0f)));
    }
//    same as above:
//    static OptimalScalar multiplyAlpha8bit(OptimalScalar a, uint8_t a)
    static OptimalType Q_DECL_VECTORCALL interpolate8bit(OptimalType x, uint8_t a1, OptimalType y, uint8_t a2)
    {
        return add(multiplyAlpha8bit(x, a1), multiplyAlpha8bit(y, a2));
    }
};
#endif

#if defined(__SSE2__)
typedef RgbaFPOperationsSSE2 RgbaFPOperations;
#else
typedef RgbaFPOperationsC RgbaFPOperations;
#endif

#endif // QT_CONFIG(raster_fp)

/*
  result = 0
  d = d * cia
*/
template<class Ops>
inline static void comp_func_Clear_template(typename Ops::Type *dest, int length, uint const_alpha)
{
    if (const_alpha == 255)
        Ops::memfill(dest, Ops::clear, length);
    else {
        uint ialpha = 255 - const_alpha;
        for (int i = 0; i < length; ++i) {
            Ops::store(&dest[i], Ops::multiplyAlpha8bit(Ops::load(&dest[i]), ialpha));
        }
    }
}

void QT_FASTCALL comp_func_solid_Clear(uint *dest, int length, uint, uint const_alpha)
{
    comp_func_Clear_template<Argb32Operations>(dest, length, const_alpha);
}

void QT_FASTCALL comp_func_Clear(uint *dest, const uint *, int length, uint const_alpha)
{
    comp_func_Clear_template<Argb32Operations>(dest, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_Clear_rgb64(QRgba64 *dest, int length, QRgba64, uint const_alpha)
{
    comp_func_Clear_template<Rgba64Operations>(dest, length, const_alpha);
}

void QT_FASTCALL comp_func_Clear_rgb64(QRgba64 *dest, const QRgba64 *, int length, uint const_alpha)
{
    comp_func_Clear_template<Rgba64Operations>(dest, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_Clear_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32, uint const_alpha)
{
    comp_func_Clear_template<RgbaFPOperations>(dest, length, const_alpha);
}

void QT_FASTCALL comp_func_Clear_rgbafp(QRgbaFloat32 *dest, const QRgbaFloat32 *, int length, uint const_alpha)
{
    comp_func_Clear_template<RgbaFPOperations>(dest, length, const_alpha);
}
#endif

/*
  result = s
  dest = s * ca + d * cia
*/
template<class Ops>
inline static void comp_func_solid_Source_template(typename Ops::Type *dest, int length, typename Ops::Type color, uint const_alpha)
{
    if (const_alpha == 255)
        Ops::memfill(dest, color, length);
    else {
        const uint ialpha = 255 - const_alpha;
        auto s = Ops::multiplyAlpha8bit(Ops::convert(color), const_alpha);
        for (int i = 0; i < length; ++i) {
            auto d = Ops::multiplyAlpha8bit(Ops::load(&dest[i]), ialpha);
            Ops::store(&dest[i], Ops::add(s, d));
        }
    }
}

template<class Ops>
inline static void comp_func_Source_template(typename Ops::Type *Q_DECL_RESTRICT dest,
                                             const typename Ops::Type *Q_DECL_RESTRICT src,
                                             int length, uint const_alpha)
{
    if (const_alpha == 255)
        Ops::memcpy(dest, src, length);
    else {
        const uint ialpha = 255 - const_alpha;
        for (int i = 0; i < length; ++i) {
            auto s = Ops::load(src + i);
            auto d = Ops::load(dest + i);
            Ops::store(&dest[i], Ops::interpolate8bit(s, const_alpha, d, ialpha));
        }
    }
}

void QT_FASTCALL comp_func_solid_Source(uint *dest, int length, uint color, uint const_alpha)
{
    comp_func_solid_Source_template<Argb32Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_Source(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_Source_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_Source_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_Source_template<Rgba64Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_Source_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_Source_template<Rgba64Operations>(dest, src, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_Source_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_Source_template<RgbaFPOperations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_Source_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_Source_template<RgbaFPOperations>(dest, src, length, const_alpha);
}
#endif

void QT_FASTCALL comp_func_solid_Destination(uint *, int, uint, uint)
{
}

void QT_FASTCALL comp_func_Destination(uint *, const uint *, int, uint)
{
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_Destination_rgb64(QRgba64 *, int, QRgba64, uint)
{
}

void QT_FASTCALL comp_func_Destination_rgb64(QRgba64 *, const QRgba64 *, int, uint)
{
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_Destination_rgbafp(QRgbaFloat32 *, int, QRgbaFloat32, uint)
{
}

void QT_FASTCALL comp_func_Destination_rgbafp(QRgbaFloat32 *, const QRgbaFloat32 *, int, uint)
{
}
#endif

/*
  result = s + d * sia
  dest = (s + d * sia) * ca + d * cia
       = s * ca + d * (sia * ca + cia)
       = s * ca + d * (1 - sa*ca)
*/
template<class Ops>
inline static void comp_func_solid_SourceOver_template(typename Ops::Type *dest, int length, typename Ops::Type color, uint const_alpha)
{
    if (const_alpha == 255 && Ops::isOpaque(color))
        Ops::memfill(dest, color, length);
    else {
        auto c = Ops::convert(color);
        if (const_alpha != 255)
            c = Ops::multiplyAlpha8bit(c, const_alpha);
        auto cAlpha = Ops::invAlpha(c);
        for (int i = 0; i < length; ++i) {
            auto d = Ops::multiplyAlpha(Ops::load(&dest[i]), cAlpha);
            Ops::store(&dest[i], Ops::add(c, d));
        }
    }
}

template<class Ops>
inline static void comp_func_SourceOver_template(typename Ops::Type *Q_DECL_RESTRICT dest,
                                                 const typename Ops::Type *Q_DECL_RESTRICT src,
                                                 int length, uint const_alpha)
{
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i) {
            auto c = src[i];
            if (Ops::isOpaque(c))
                Ops::store(&dest[i], Ops::convert(c));
            else if (!Ops::isTransparent(c)) {
                auto s = Ops::convert(c);
                auto d = Ops::multiplyAlpha(Ops::load(&dest[i]), Ops::invAlpha(s));
                Ops::store(&dest[i], Ops::add(s, d));
            }
        }
    } else {
        for (int i = 0; i < length; ++i) {
            auto s = Ops::multiplyAlpha8bit(Ops::load(&src[i]), const_alpha);
            auto d = Ops::multiplyAlpha(Ops::load(&dest[i]), Ops::invAlpha(s));
            Ops::store(&dest[i], Ops::add(s, d));
        }
    }
}

void QT_FASTCALL comp_func_solid_SourceOver(uint *dest, int length, uint color, uint const_alpha)
{
    comp_func_solid_SourceOver_template<Argb32Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_SourceOver(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceOver_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_SourceOver_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_SourceOver_template<Rgba64Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_SourceOver_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceOver_template<Rgba64Operations>(dest, src, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_SourceOver_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_SourceOver_template<RgbaFPOperations>(dest, length, color, const_alpha);
}


void QT_FASTCALL comp_func_SourceOver_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceOver_template<RgbaFPOperations>(dest, src, length, const_alpha);
}
#endif

/*
  result = d + s * dia
  dest = (d + s * dia) * ca + d * cia
       = d + s * dia * ca
*/
template<class Ops>
inline static void comp_func_solid_DestinationOver_template(typename Ops::Type *dest, int length, typename Ops::Type color, uint const_alpha)
{
    auto c = Ops::convert(color);
    if (const_alpha != 255)
        c = Ops::multiplyAlpha8bit(c, const_alpha);
    for (int i = 0; i < length; ++i) {
        auto d = Ops::load(&dest[i]);
        auto s = Ops::multiplyAlpha(c, Ops::invAlpha(d));
        Ops::store(&dest[i], Ops::add(s, d));
    }
}

template<class Ops>
inline static void comp_func_DestinationOver_template(typename Ops::Type *Q_DECL_RESTRICT dest,
                                                      const typename Ops::Type *Q_DECL_RESTRICT src,
                                                      int length, uint const_alpha)
{
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i) {
            auto d = Ops::load(&dest[i]);
            auto s = Ops::multiplyAlpha(Ops::load(&src[i]), Ops::invAlpha(d));
            Ops::store(&dest[i], Ops::add(s, d));
        }
    } else {
        for (int i = 0; i < length; ++i) {
            auto d = Ops::load(&dest[i]);
            auto s = Ops::multiplyAlpha8bit(Ops::load(&src[i]), const_alpha);
            s = Ops::multiplyAlpha(s, Ops::invAlpha(d));
            Ops::store(&dest[i], Ops::add(s, d));
        }
    }
}

void QT_FASTCALL comp_func_solid_DestinationOver(uint *dest, int length, uint color, uint const_alpha)
{
    comp_func_solid_DestinationOver_template<Argb32Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationOver(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationOver_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_DestinationOver_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_DestinationOver_template<Rgba64Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationOver_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationOver_template<Rgba64Operations>(dest, src, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_DestinationOver_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_DestinationOver_template<RgbaFPOperations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationOver_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationOver_template<RgbaFPOperations>(dest, src, length, const_alpha);
}
#endif

/*
  result = s * da
  dest = s * da * ca + d * cia
*/
template<class Ops>
inline static void comp_func_solid_SourceIn_template(typename Ops::Type *dest, int length, typename Ops::Type color, uint const_alpha)
{
    if (const_alpha == 255) {
        auto c = Ops::convert(color);
        for (int i = 0; i < length; ++i) {
            Ops::store(&dest[i], Ops::multiplyAlpha(c, Ops::alpha(Ops::load(&dest[i]))));
        }
    } else {
        auto c = Ops::multiplyAlpha8bit(Ops::convert(color), const_alpha);
        auto cia = Ops::invAlpha(Ops::scalarFrom8bit(const_alpha));
        for (int i = 0; i < length; ++i) {
            auto d = Ops::load(&dest[i]);
            Ops::store(&dest[i], Ops::interpolate(c, Ops::alpha(d), d, cia));
        }
    }
}

template<class Ops>
inline static void comp_func_SourceIn_template(typename Ops::Type *Q_DECL_RESTRICT dest,
                                               const typename Ops::Type *Q_DECL_RESTRICT src,
                                               int length, uint const_alpha)
{
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i) {
            auto s = Ops::load(&src[i]);
            Ops::store(&dest[i], Ops::multiplyAlpha(s, Ops::alpha(Ops::load(&dest[i]))));
        }
    } else {
        auto ca = Ops::scalarFrom8bit(const_alpha);
        auto cia = Ops::invAlpha(ca);
        auto cav = Ops::scalar(ca);
        for (int i = 0; i < length; ++i) {
            auto d = Ops::load(&dest[i]);
            auto s = Ops::multiplyAlpha(Ops::load(&src[i]), cav);
            Ops::store(&dest[i], Ops::interpolate(s, Ops::alpha(d), d, cia));
        }
    }
}

void QT_FASTCALL comp_func_solid_SourceIn(uint *dest, int length, uint color, uint const_alpha)
{
    comp_func_solid_SourceIn_template<Argb32Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_SourceIn(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceIn_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_SourceIn_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_SourceIn_template<Rgba64Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_SourceIn_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceIn_template<Rgba64Operations>(dest, src, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_SourceIn_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_SourceIn_template<RgbaFPOperations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_SourceIn_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceIn_template<RgbaFPOperations>(dest, src, length, const_alpha);
}
#endif

/*
  result = d * sa
  dest = d * sa * ca + d * cia
       = d * (sa * ca + cia)
*/
template<class Ops>
inline static void comp_func_solid_DestinationIn_template(typename Ops::Type *dest, int length, typename Ops::Type color, uint const_alpha)
{
    auto sa = Ops::alpha(Ops::convert(color));
    if (const_alpha != 255) {
        sa = Ops::multiplyAlpha8bit(sa, const_alpha);
        sa = Ops::add(sa, Ops::invAlpha(Ops::scalarFrom8bit(const_alpha)));
    }

    for (int i = 0; i < length; ++i) {
        Ops::store(&dest[i], Ops::multiplyAlpha(Ops::load(&dest[i]), sa));
    }
}

template<class Ops>
inline static void comp_func_DestinationIn_template(typename Ops::Type *Q_DECL_RESTRICT dest,
                                                    const typename Ops::Type *Q_DECL_RESTRICT src,
                                                    int length, uint const_alpha)
{
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i) {
            auto a = Ops::alpha(Ops::load(&src[i]));
            Ops::store(&dest[i], Ops::multiplyAlpha(Ops::load(&dest[i]), a));
        }
    } else {
        auto cia = Ops::invAlpha(Ops::scalarFrom8bit(const_alpha));
        for (int i = 0; i < length; ++i) {
            auto sa = Ops::multiplyAlpha8bit(Ops::alpha(Ops::load(&src[i])), const_alpha);
            sa = Ops::add(sa, cia);
            Ops::store(&dest[i], Ops::multiplyAlpha(Ops::load(&dest[i]), sa));
        }
    }
}

void QT_FASTCALL comp_func_solid_DestinationIn(uint *dest, int length, uint color, uint const_alpha)
{
    comp_func_solid_DestinationIn_template<Argb32Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationIn(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationIn_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_DestinationIn_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_DestinationIn_template<Rgba64Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationIn_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationIn_template<Rgba64Operations>(dest, src, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_DestinationIn_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_DestinationIn_template<RgbaFPOperations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationIn_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationIn_template<RgbaFPOperations>(dest, src, length, const_alpha);
}
#endif

/*
  result = s * dia
  dest = s * dia * ca + d * cia
*/
template<class Ops>
inline static void comp_func_solid_SourceOut_template(typename Ops::Type *dest, int length, typename Ops::Type color, uint const_alpha)
{
    auto c = Ops::convert(color);
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i)
            Ops::store(&dest[i], Ops::multiplyAlpha(c, Ops::invAlpha(Ops::load(&dest[i]))));
    } else {
        auto cia = Ops::invAlpha(Ops::scalarFrom8bit(const_alpha));
        c = Ops::multiplyAlpha8bit(c, const_alpha);
        for (int i = 0; i < length; ++i) {
            auto d = Ops::load(&dest[i]);
            Ops::store(&dest[i], Ops::interpolate(c, Ops::invAlpha(d), d, cia));
        }
    }
}

template<class Ops>
inline static void comp_func_SourceOut_template(typename Ops::Type *Q_DECL_RESTRICT dest,
                                                const typename Ops::Type *Q_DECL_RESTRICT src,
                                                int length, uint const_alpha)
{
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i) {
            auto s = Ops::load(&src[i]);
            auto d = Ops::load(&dest[i]);
            Ops::store(&dest[i], Ops::multiplyAlpha(s, Ops::invAlpha(d)));
        }
    } else {
        auto cia = Ops::invAlpha(Ops::scalarFrom8bit(const_alpha));
        for (int i = 0; i < length; ++i) {
            auto s = Ops::multiplyAlpha8bit(Ops::load(&src[i]), const_alpha);
            auto d = Ops::load(&dest[i]);
            Ops::store(&dest[i], Ops::interpolate(s, Ops::invAlpha(d), d, cia));
        }
    }
}

void QT_FASTCALL comp_func_solid_SourceOut(uint *dest, int length, uint color, uint const_alpha)
{
    comp_func_solid_SourceOut_template<Argb32Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_SourceOut(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceOut_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_SourceOut_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_SourceOut_template<Rgba64Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_SourceOut_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceOut_template<Rgba64Operations>(dest, src, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_SourceOut_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_SourceOut_template<RgbaFPOperations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_SourceOut_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceOut_template<RgbaFPOperations>(dest, src, length, const_alpha);
}
#endif

/*
  result = d * sia
  dest = d * sia * ca + d * cia
       = d * (sia * ca + cia)
*/
template<class Ops>
inline static void comp_func_solid_DestinationOut_template(typename Ops::Type *dest, int length, typename Ops::Type color, uint const_alpha)
{
    auto sai = Ops::invAlpha(Ops::convert(color));
    if (const_alpha != 255) {
        sai = Ops::multiplyAlpha8bit(sai, const_alpha);
        sai = Ops::add(sai, Ops::invAlpha(Ops::scalarFrom8bit(const_alpha)));
    }

    for (int i = 0; i < length; ++i) {
        Ops::store(&dest[i], Ops::multiplyAlpha(Ops::load(&dest[i]), sai));
    }
}

template<class Ops>
inline static void comp_func_DestinationOut_template(typename Ops::Type *Q_DECL_RESTRICT dest,
                                                     const typename Ops::Type *Q_DECL_RESTRICT src,
                                                     int length, uint const_alpha)
{
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i) {
            auto sia = Ops::invAlpha(Ops::load(&src[i]));
            Ops::store(&dest[i], Ops::multiplyAlpha(Ops::load(&dest[i]), sia));
        }
    } else {
        auto cia = Ops::invAlpha(Ops::scalarFrom8bit(const_alpha));
        for (int i = 0; i < length; ++i) {
            auto sia = Ops::multiplyAlpha8bit(Ops::invAlpha(Ops::load(&src[i])), const_alpha);
            sia = Ops::add(sia, cia);
            Ops::store(&dest[i], Ops::multiplyAlpha(Ops::load(&dest[i]), sia));
        }
    }
}

void QT_FASTCALL comp_func_solid_DestinationOut(uint *dest, int length, uint color, uint const_alpha)
{
    comp_func_solid_DestinationOut_template<Argb32Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationOut(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationOut_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_DestinationOut_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_DestinationOut_template<Rgba64Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationOut_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationOut_template<Rgba64Operations>(dest, src, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_DestinationOut_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_DestinationOut_template<RgbaFPOperations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationOut_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationOut_template<RgbaFPOperations>(dest, src, length, const_alpha);
}
#endif

/*
  result = s*da + d*sia
  dest = s*da*ca + d*sia*ca + d *cia
       = s*ca * da + d * (sia*ca + cia)
       = s*ca * da + d * (1 - sa*ca)
*/
template<class Ops>
inline static void comp_func_solid_SourceAtop_template(typename Ops::Type *dest, int length, typename Ops::Type color, uint const_alpha)
{
    auto c = Ops::convert(color);
    if (const_alpha != 255)
        c = Ops::multiplyAlpha8bit(c, const_alpha);
    auto sia = Ops::invAlpha(c);
    for (int i = 0; i < length; ++i) {
        auto d = Ops::load(&dest[i]);
        Ops::store(&dest[i], Ops::interpolate(c, Ops::alpha(d), d, sia));
    }
}

template<class Ops>
inline static void comp_func_SourceAtop_template(typename Ops::Type *Q_DECL_RESTRICT dest,
                                                 const typename Ops::Type *Q_DECL_RESTRICT src,
                                                 int length, uint const_alpha)
{
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i) {
            auto s = Ops::load(&src[i]);
            auto d = Ops::load(&dest[i]);
            Ops::store(&dest[i], Ops::interpolate(s, Ops::alpha(d), d, Ops::invAlpha(s)));
        }
    } else {
        for (int i = 0; i < length; ++i) {
            auto s = Ops::multiplyAlpha8bit(Ops::load(&src[i]), const_alpha);
            auto d = Ops::load(&dest[i]);
            Ops::store(&dest[i], Ops::interpolate(s, Ops::alpha(d), d, Ops::invAlpha(s)));
        }
    }
}

void QT_FASTCALL comp_func_solid_SourceAtop(uint *dest, int length, uint color, uint const_alpha)
{
    comp_func_solid_SourceAtop_template<Argb32Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_SourceAtop(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceAtop_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_SourceAtop_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_SourceAtop_template<Rgba64Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_SourceAtop_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceAtop_template<Rgba64Operations>(dest, src, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_SourceAtop_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_SourceAtop_template<RgbaFPOperations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_SourceAtop_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_SourceAtop_template<RgbaFPOperations>(dest, src, length, const_alpha);
}
#endif

/*
  result = d*sa + s*dia
  dest = d*sa*ca + s*dia*ca + d *cia
       = s*ca * dia + d * (sa*ca + cia)
*/
template<class Ops>
inline static void comp_func_solid_DestinationAtop_template(typename Ops::Type *dest, int length, typename Ops::Type color, uint const_alpha)
{
    auto c = Ops::convert(color);
    auto sa = Ops::alpha(c);
    if (const_alpha != 255) {
        c = Ops::multiplyAlpha8bit(c, const_alpha);
        auto cia = Ops::invAlpha(Ops::scalarFrom8bit(const_alpha));
        sa = Ops::add(Ops::alpha(c), cia);
    }

    for (int i = 0; i < length; ++i) {
        auto d = Ops::load(&dest[i]);
        Ops::store(&dest[i], Ops::interpolate(c, Ops::invAlpha(d), d, sa));
    }
}

template<class Ops>
inline static void comp_func_DestinationAtop_template(typename Ops::Type *Q_DECL_RESTRICT dest,
                                                      const typename Ops::Type *Q_DECL_RESTRICT src,
                                                      int length, uint const_alpha)
{
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i) {
            auto s = Ops::load(&src[i]);
            auto d = Ops::load(&dest[i]);
            Ops::store(&dest[i], Ops::interpolate(s, Ops::invAlpha(d), d, Ops::alpha(s)));
        }
    } else {
        auto cia = Ops::invAlpha(Ops::scalarFrom8bit(const_alpha));
        for (int i = 0; i < length; ++i) {
            auto s = Ops::multiplyAlpha8bit(Ops::load(&src[i]), const_alpha);
            auto d = Ops::load(&dest[i]);
            auto sa = Ops::add(Ops::alpha(s), cia);
            Ops::store(&dest[i], Ops::interpolate(s, Ops::invAlpha(d), d, sa));
        }
    }
}

void QT_FASTCALL comp_func_solid_DestinationAtop(uint *dest, int length, uint color, uint const_alpha)
{
    comp_func_solid_DestinationAtop_template<Argb32Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationAtop(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationAtop_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_DestinationAtop_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_DestinationAtop_template<Rgba64Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationAtop_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationAtop_template<Rgba64Operations>(dest, src, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_DestinationAtop_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_DestinationAtop_template<RgbaFPOperations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_DestinationAtop_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_DestinationAtop_template<RgbaFPOperations>(dest, src, length, const_alpha);
}
#endif

/*
  result = d*sia + s*dia
  dest = d*sia*ca + s*dia*ca + d *cia
       = s*ca * dia + d * (sia*ca + cia)
       = s*ca * dia + d * (1 - sa*ca)
*/
template<class Ops>
inline static void comp_func_solid_XOR_template(typename Ops::Type *dest, int length, typename Ops::Type color, uint const_alpha)
{
    auto c = Ops::convert(color);
    if (const_alpha != 255)
        c = Ops::multiplyAlpha8bit(c, const_alpha);

    auto sia = Ops::invAlpha(c);
    for (int i = 0; i < length; ++i) {
        auto d = Ops::load(&dest[i]);
        Ops::store(&dest[i], Ops::interpolate(c, Ops::invAlpha(d), d, sia));
    }
}

template<class Ops>
inline static void comp_func_XOR_template(typename Ops::Type *Q_DECL_RESTRICT dest,
                                          const typename Ops::Type *Q_DECL_RESTRICT src,
                                          int length, uint const_alpha)
{
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i) {
            auto d = Ops::load(&dest[i]);
            auto s = Ops::load(&src[i]);
            Ops::store(&dest[i], Ops::interpolate(s, Ops::invAlpha(d), d, Ops::invAlpha(s)));
        }
    } else {
        for (int i = 0; i < length; ++i) {
            auto d = Ops::load(&dest[i]);
            auto s = Ops::multiplyAlpha8bit(Ops::load(&src[i]), const_alpha);
            Ops::store(&dest[i], Ops::interpolate(s, Ops::invAlpha(d), d, Ops::invAlpha(s)));
        }
    }
}

void QT_FASTCALL comp_func_solid_XOR(uint *dest, int length, uint color, uint const_alpha)
{
    comp_func_solid_XOR_template<Argb32Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_XOR(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_XOR_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_XOR_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_XOR_template<Rgba64Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_XOR_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_XOR_template<Rgba64Operations>(dest, src, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_XOR_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_XOR_template<RgbaFPOperations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_XOR_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_XOR_template<RgbaFPOperations>(dest, src, length, const_alpha);
}
#endif

struct QFullCoverage {
    inline void store(uint *dest, const uint src) const
    {
        *dest = src;
    }
#if QT_CONFIG(raster_64bit)
    inline void store(QRgba64 *dest, const QRgba64 src) const
    {
        *dest = src;
    }
#endif
#if QT_CONFIG(raster_fp)
    inline void store(QRgbaFloat32 *dest, const QRgbaFloat32 src) const
    {
        *dest = src;
    }
#endif
};

struct QPartialCoverage {
    inline QPartialCoverage(uint const_alpha)
        : ca(const_alpha)
        , ica(255 - const_alpha)
    {
    }

    template<typename Op>
    inline void store_template(typename Op::Type *dest, const typename Op::Type src) const
    {
        Op::store(dest, Op::interpolate8bit(Op::convert(src), ca, Op::load(dest), ica));
    }
    inline void store(uint *dest, const uint src) const
    {
        store_template<Argb32Operations>(dest, src);
    }
#if QT_CONFIG(raster_64bit)
    inline void store(QRgba64 *dest, const QRgba64 src) const
    {
        store_template<Rgba64Operations>(dest, src);
    }
#endif
#if QT_CONFIG(raster_fp)
    inline void store(QRgbaFloat32 *dest, const QRgbaFloat32 src) const
    {
        store_template<RgbaFPOperations>(dest, src);
    }
#endif

private:
    const uint ca;
    const uint ica;
};

static inline int mix_alpha(int da, int sa)
{
    return 255 - qt_div_255((255 - sa) * (255 - da));
}

#if QT_CONFIG(raster_64bit)
static inline uint mix_alpha_rgb64(uint da, uint sa)
{
    return 65535U - qt_div_65535((65535U - sa) * (65535U - da));
}
#endif

#if QT_CONFIG(raster_fp)
static inline float mix_alpha_rgbafp(float da, float sa)
{
    return 1.0f - (1.0f - sa) * (1.0f - da);
}
#endif

/*
    Dca' = Sca.Da + Dca.Sa + Sca.(1 - Da) + Dca.(1 - Sa)
         = Sca + Dca
*/
template<class Ops>
inline static void comp_func_solid_Plus_template(typename Ops::Type *dest, int length, typename Ops::Type color, uint const_alpha)
{
    auto c = Ops::convert(color);
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i) {
            auto d = Ops::load(&dest[i]);
            d = Ops::plus(d, c);
            Ops::store(&dest[i], d);
        }
    } else {
        uint ia = 255 - const_alpha;
        for (int i = 0; i < length; ++i) {
            auto d = Ops::load(&dest[i]);
            d = Ops::interpolate8bit(Ops::plus(d, c), const_alpha, d, ia);
            Ops::store(&dest[i], d);
        }
    }
}

template<class Ops>
inline static void comp_func_Plus_template(typename Ops::Type *Q_DECL_RESTRICT dest,
                                           const typename Ops::Type *Q_DECL_RESTRICT src,
                                           int length, uint const_alpha)
{
    if (const_alpha == 255) {
        for (int i = 0; i < length; ++i) {
            auto d = Ops::load(&dest[i]);
            auto s = Ops::load(&src[i]);
            d = Ops::plus(d, s);
            Ops::store(&dest[i], d);
        }
    } else {
        uint ia = 255 - const_alpha;
        for (int i = 0; i < length; ++i) {
            auto d = Ops::load(&dest[i]);
            auto s = Ops::load(&src[i]);
            d = Ops::interpolate8bit(Ops::plus(d, s), const_alpha, d, ia);
            Ops::store(&dest[i], d);
        }
    }
}

void QT_FASTCALL comp_func_solid_Plus(uint *dest, int length, uint color, uint const_alpha)
{
    comp_func_solid_Plus_template<Argb32Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_Plus(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_Plus_template<Argb32Operations>(dest, src, length, const_alpha);
}

#if QT_CONFIG(raster_64bit)
void QT_FASTCALL comp_func_solid_Plus_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    comp_func_solid_Plus_template<Rgba64Operations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_Plus_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_Plus_template<Rgba64Operations>(dest, src, length, const_alpha);
}
#endif

#if QT_CONFIG(raster_fp)
void QT_FASTCALL comp_func_solid_Plus_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    comp_func_solid_Plus_template<RgbaFPOperations>(dest, length, color, const_alpha);
}

void QT_FASTCALL comp_func_Plus_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    comp_func_Plus_template<RgbaFPOperations>(dest, src, length, const_alpha);
}
#endif

/*
    Dca' = Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
*/
static inline int multiply_op(int dst, int src, int da, int sa)
{
    return qt_div_255(src * dst + src * (255 - da) + dst * (255 - sa));
}

template <typename T>
static inline void comp_func_solid_Multiply_impl(uint *dest, int length, uint color, const T &coverage)
{
    int sa = qAlpha(color);
    int sr = qRed(color);
    int sg = qGreen(color);
    int sb = qBlue(color);

    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        int da = qAlpha(d);

#define OP(a, b) multiply_op(a, b, da, sa)
        int r = OP(  qRed(d), sr);
        int b = OP( qBlue(d), sb);
        int g = OP(qGreen(d), sg);
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Multiply(uint *dest, int length, uint color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Multiply_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Multiply_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
static inline uint multiply_op_rgb64(uint dst, uint src, uint da, uint sa)
{
    return qt_div_65535(src * dst + src * (65535U - da) + dst * (65535U - sa));
}

template <typename T>
static inline void comp_func_solid_Multiply_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{
    uint sa = color.alpha();
    uint sr = color.red();
    uint sg = color.green();
    uint sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        uint da = d.alpha();

#define OP(a, b) multiply_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(), sr);
        uint b = OP( d.blue(), sb);
        uint g = OP(d.green(), sg);
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Multiply_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Multiply_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Multiply_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
static inline float multiply_op_rgbafp(float dst, float src, float da, float sa)
{
    return src * dst + src * (1.0f - da) + dst * (1.0f - sa);
}

template <typename T>
static inline void comp_func_solid_Multiply_impl(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, const T &coverage)
{
    float sa = color.alpha();
    float sr = color.red();
    float sg = color.green();
    float sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        float da = d.alpha();

#define OP(a, b) multiply_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(), sr);
        float b = OP( d.blue(), sb);
        float g = OP(d.green(), sg);
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Multiply_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Multiply_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Multiply_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif


template <typename T>
static inline void comp_func_Multiply_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        uint s = src[i];

        int da = qAlpha(d);
        int sa = qAlpha(s);

#define OP(a, b) multiply_op(a, b, da, sa)
        int r = OP(  qRed(d),   qRed(s));
        int b = OP( qBlue(d),  qBlue(s));
        int g = OP(qGreen(d), qGreen(s));
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Multiply(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Multiply_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Multiply_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_Multiply_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        QRgba64 s = src[i];

        uint da = d.alpha();
        uint sa = s.alpha();

#define OP(a, b) multiply_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(),   s.red());
        uint b = OP( d.blue(),  s.blue());
        uint g = OP(d.green(), s.green());
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Multiply_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Multiply_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Multiply_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_Multiply_impl(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        QRgbaFloat32 s = src[i];

        float da = d.alpha();
        float sa = s.alpha();

#define OP(a, b) multiply_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(),   s.red());
        float b = OP( d.blue(),  s.blue());
        float g = OP(d.green(), s.green());
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Multiply_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Multiply_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Multiply_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

/*
    Dca' = (Sca.Da + Dca.Sa - Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)
         = Sca + Dca - Sca.Dca
*/
template <typename T>
static inline void comp_func_solid_Screen_impl(uint *dest, int length, uint color, const T &coverage)
{
    int sa = qAlpha(color);
    int sr = qRed(color);
    int sg = qGreen(color);
    int sb = qBlue(color);

    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        int da = qAlpha(d);

#define OP(a, b) 255 - qt_div_255((255-a) * (255-b))
        int r = OP(  qRed(d), sr);
        int b = OP( qBlue(d), sb);
        int g = OP(qGreen(d), sg);
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Screen(uint *dest, int length, uint color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Screen_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Screen_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_solid_Screen_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{
    uint sa = color.alpha();
    uint sr = color.red();
    uint sg = color.green();
    uint sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        uint da = d.alpha();

#define OP(a, b) 65535 - qt_div_65535((65535U-a) * (65535U-b))
        uint r = OP(  d.red(), sr);
        uint b = OP( d.blue(), sb);
        uint g = OP(d.green(), sg);
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Screen_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Screen_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Screen_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_solid_Screen_impl(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, const T &coverage)
{
    float sa = color.alpha();
    float sr = color.red();
    float sg = color.green();
    float sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        float da = d.alpha();

#define OP(a, b) (1.0f - ((1.0f - a) * (1.0f - b)))
        float r = OP(  d.red(), sr);
        float b = OP( d.blue(), sb);
        float g = OP(d.green(), sg);
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Screen_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Screen_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Screen_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

template <typename T>
static inline void comp_func_Screen_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        uint s = src[i];

        int da = qAlpha(d);
        int sa = qAlpha(s);

#define OP(a, b) 255 - qt_div_255((255-a) * (255-b))
        int r = OP(  qRed(d),   qRed(s));
        int b = OP( qBlue(d),  qBlue(s));
        int g = OP(qGreen(d), qGreen(s));
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Screen(uint *dest, const uint *src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Screen_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Screen_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_Screen_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        QRgba64 s = src[i];

        uint da = d.alpha();
        uint sa = s.alpha();

#define OP(a, b) 65535U - qt_div_65535((65535U-a) * (65535U-b))
        uint r = OP(  d.red(),   s.red());
        uint b = OP( d.blue(),  s.blue());
        uint g = OP(d.green(), s.green());
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Screen_rgb64(QRgba64 *dest, const QRgba64 *src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Screen_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Screen_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_Screen_impl(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        QRgbaFloat32 s = src[i];

        float da = d.alpha();
        float sa = s.alpha();

#define OP(a, b) (1.0f - ((1.0f - a) * (1.0f - b)))
        float r = OP(  d.red(),   s.red());
        float b = OP( d.blue(),  s.blue());
        float g = OP(d.green(), s.green());
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Screen_rgbafp(QRgbaFloat32 *dest, const QRgbaFloat32 *src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Screen_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Screen_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

/*
    if 2.Dca < Da
        Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
    otherwise
        Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
*/
static inline int overlay_op(int dst, int src, int da, int sa)
{
    const int temp = src * (255 - da) + dst * (255 - sa);
    if (2 * dst < da)
        return qt_div_255(2 * src * dst + temp);
    else
        return qt_div_255(sa * da - 2 * (da - dst) * (sa - src) + temp);
}

template <typename T>
static inline void comp_func_solid_Overlay_impl(uint *dest, int length, uint color, const T &coverage)
{
    int sa = qAlpha(color);
    int sr = qRed(color);
    int sg = qGreen(color);
    int sb = qBlue(color);

    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        int da = qAlpha(d);

#define OP(a, b) overlay_op(a, b, da, sa)
        int r = OP(  qRed(d), sr);
        int b = OP( qBlue(d), sb);
        int g = OP(qGreen(d), sg);
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Overlay(uint *dest, int length, uint color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Overlay_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Overlay_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
static inline uint overlay_op_rgb64(uint dst, uint src, uint da, uint sa)
{
    const uint temp = src * (65535U - da) + dst * (65535U - sa);
    if (2 * dst < da)
        return qt_div_65535(2 * src * dst + temp);
    else
        return qt_div_65535(sa * da - 2 * (da - dst) * (sa - src) + temp);
}

template <typename T>
static inline void comp_func_solid_Overlay_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{
    uint sa = color.alpha();
    uint sr = color.red();
    uint sg = color.green();
    uint sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        uint da = d.alpha();

#define OP(a, b) overlay_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(), sr);
        uint b = OP( d.blue(), sb);
        uint g = OP(d.green(), sg);
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Overlay_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Overlay_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Overlay_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
static inline float overlay_op_rgbafp(float dst, float src, float da, float sa)
{
    const float temp = src * (1.0f - da) + dst * (1.0f - sa);
    if (2 * dst < da)
        return 2 * src * dst + temp;
    else
        return sa * da - 2 * (da - dst) * (sa - src) + temp;
}

template <typename T>
static inline void comp_func_solid_Overlay_impl(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, const T &coverage)
{
    float sa = color.alpha();
    float sr = color.red();
    float sg = color.green();
    float sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        float da = d.alpha();

#define OP(a, b) overlay_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(), sr);
        float b = OP( d.blue(), sb);
        float g = OP(d.green(), sg);
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Overlay_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Overlay_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Overlay_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

template <typename T>
static inline void comp_func_Overlay_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        uint s = src[i];

        int da = qAlpha(d);
        int sa = qAlpha(s);

#define OP(a, b) overlay_op(a, b, da, sa)
        int r = OP(  qRed(d),   qRed(s));
        int b = OP( qBlue(d),  qBlue(s));
        int g = OP(qGreen(d), qGreen(s));
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Overlay(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Overlay_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Overlay_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_Overlay_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        QRgba64 s = src[i];

        uint da = d.alpha();
        uint sa = s.alpha();

#define OP(a, b) overlay_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(),   s.red());
        uint b = OP( d.blue(),  s.blue());
        uint g = OP(d.green(), s.green());
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Overlay_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Overlay_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Overlay_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_Overlay_impl(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        QRgbaFloat32 s = src[i];

        float da = d.alpha();
        float sa = s.alpha();

#define OP(a, b) overlay_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(),   s.red());
        float b = OP( d.blue(),  s.blue());
        float g = OP(d.green(), s.green());
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Overlay_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Overlay_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Overlay_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

/*
    Dca' = min(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
    Da'  = Sa + Da - Sa.Da
*/
static inline int darken_op(int dst, int src, int da, int sa)
{
    return qt_div_255(qMin(src * da, dst * sa) + src * (255 - da) + dst * (255 - sa));
}

template <typename T>
static inline void comp_func_solid_Darken_impl(uint *dest, int length, uint color, const T &coverage)
{
    int sa = qAlpha(color);
    int sr = qRed(color);
    int sg = qGreen(color);
    int sb = qBlue(color);

    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        int da = qAlpha(d);

#define OP(a, b) darken_op(a, b, da, sa)
        int r =  OP(  qRed(d), sr);
        int b =  OP( qBlue(d), sb);
        int g =  OP(qGreen(d), sg);
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Darken(uint *dest, int length, uint color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Darken_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Darken_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
static inline uint darken_op_rgb64(uint dst, uint src, uint da, uint sa)
{
    return qt_div_65535(qMin(src * da, dst * sa) + src * (65535U - da) + dst * (65535U - sa));
}

template <typename T>
static inline void comp_func_solid_Darken_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{
    uint sa = color.alpha();
    uint sr = color.red();
    uint sg = color.green();
    uint sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        uint da = d.alpha();

#define OP(a, b) darken_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(), sr);
        uint b = OP( d.blue(), sb);
        uint g = OP(d.green(), sg);
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Darken_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Darken_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Darken_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
static inline float darken_op_rgbafp(float dst, float src, float da, float sa)
{
    return qMin(src * da, dst * sa) + src * (1.0f - da) + dst * (1.0f - sa);
}

template <typename T>
static inline void comp_func_solid_Darken_impl(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, const T &coverage)
{
    float sa = color.alpha();
    float sr = color.red();
    float sg = color.green();
    float sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        float da = d.alpha();

#define OP(a, b) darken_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(), sr);
        float b = OP( d.blue(), sb);
        float g = OP(d.green(), sg);
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Darken_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Darken_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Darken_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

template <typename T>
static inline void comp_func_Darken_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        uint s = src[i];

        int da = qAlpha(d);
        int sa = qAlpha(s);

#define OP(a, b) darken_op(a, b, da, sa)
        int r = OP(  qRed(d),   qRed(s));
        int b = OP( qBlue(d),  qBlue(s));
        int g = OP(qGreen(d), qGreen(s));
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Darken(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Darken_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Darken_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_Darken_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        QRgba64 s = src[i];

        uint da = d.alpha();
        uint sa = s.alpha();

#define OP(a, b) darken_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(),   s.red());
        uint b = OP( d.blue(),  s.blue());
        uint g = OP(d.green(), s.green());
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Darken_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Darken_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Darken_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_Darken_impl(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        QRgbaFloat32 s = src[i];

        float da = d.alpha();
        float sa = s.alpha();

#define OP(a, b) darken_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(),   s.red());
        float b = OP( d.blue(),  s.blue());
        float g = OP(d.green(), s.green());
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Darken_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Darken_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Darken_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

/*
   Dca' = max(Sca.Da, Dca.Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
   Da'  = Sa + Da - Sa.Da
*/
static inline int lighten_op(int dst, int src, int da, int sa)
{
    return qt_div_255(qMax(src * da, dst * sa) + src * (255 - da) + dst * (255 - sa));
}

template <typename T>
static inline void comp_func_solid_Lighten_impl(uint *dest, int length, uint color, const T &coverage)
{
    int sa = qAlpha(color);
    int sr = qRed(color);
    int sg = qGreen(color);
    int sb = qBlue(color);

    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        int da = qAlpha(d);

#define OP(a, b) lighten_op(a, b, da, sa)
        int r =  OP(  qRed(d), sr);
        int b =  OP( qBlue(d), sb);
        int g =  OP(qGreen(d), sg);
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Lighten(uint *dest, int length, uint color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Lighten_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Lighten_impl(dest, length, color, QPartialCoverage(const_alpha));
}


#if QT_CONFIG(raster_64bit)
static inline uint lighten_op_rgb64(uint dst, uint src, uint da, uint sa)
{
    return qt_div_65535(qMax(src * da, dst * sa) + src * (65535U - da) + dst * (65535U - sa));
}

template <typename T>
static inline void comp_func_solid_Lighten_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{
    uint sa = color.alpha();
    uint sr = color.red();
    uint sg = color.green();
    uint sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        uint da = d.alpha();

#define OP(a, b) lighten_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(), sr);
        uint b = OP( d.blue(), sb);
        uint g = OP(d.green(), sg);
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Lighten_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Lighten_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Lighten_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
static inline float lighten_op_rgbafp(float dst, float src, float da, float sa)
{
    return qMax(src * da, dst * sa) + src * (1.0f - da) + dst * (1.0f - sa);
}

template <typename T>
static inline void comp_func_solid_Lighten_impl(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, const T &coverage)
{
    float sa = color.alpha();
    float sr = color.red();
    float sg = color.green();
    float sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        float da = d.alpha();

#define OP(a, b) lighten_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(), sr);
        float b = OP( d.blue(), sb);
        float g = OP(d.green(), sg);
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Lighten_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Lighten_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Lighten_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

template <typename T>
static inline void comp_func_Lighten_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        uint s = src[i];

        int da = qAlpha(d);
        int sa = qAlpha(s);

#define OP(a, b) lighten_op(a, b, da, sa)
        int r = OP(  qRed(d),   qRed(s));
        int b = OP( qBlue(d),  qBlue(s));
        int g = OP(qGreen(d), qGreen(s));
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Lighten(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Lighten_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Lighten_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_Lighten_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        QRgba64 s = src[i];

        uint da = d.alpha();
        uint sa = s.alpha();

#define OP(a, b) lighten_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(),   s.red());
        uint b = OP( d.blue(),  s.blue());
        uint g = OP(d.green(), s.green());
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Lighten_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Lighten_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Lighten_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_Lighten_impl(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        QRgbaFloat32 s = src[i];

        float da = d.alpha();
        float sa = s.alpha();

#define OP(a, b) lighten_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(),   s.red());
        float b = OP( d.blue(),  s.blue());
        float g = OP(d.green(), s.green());
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Lighten_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Lighten_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Lighten_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

/*
   if Sca.Da + Dca.Sa > Sa.Da
       Dca' = Sa.Da + Sca.(1 - Da) + Dca.(1 - Sa)
   else if Sca == Sa
       Dca' = Dca.Sa + Sca.(1 - Da) + Dca.(1 - Sa)
   otherwise
       Dca' = Dca.Sa/(1-Sca/Sa) + Sca.(1 - Da) + Dca.(1 - Sa)
*/
static inline int color_dodge_op(int dst, int src, int da, int sa)
{
    const int sa_da = sa * da;
    const int dst_sa = dst * sa;
    const int src_da = src * da;

    const int temp = src * (255 - da) + dst * (255 - sa);
    if (src_da + dst_sa > sa_da)
        return qt_div_255(sa_da + temp);
    else if (src == sa || sa == 0)
        return qt_div_255(temp);
    else
        return qt_div_255(255 * dst_sa / (255 - 255 * src / sa) + temp);
}

template <typename T>
static inline void comp_func_solid_ColorDodge_impl(uint *dest, int length, uint color, const T &coverage)
{
    int sa = qAlpha(color);
    int sr = qRed(color);
    int sg = qGreen(color);
    int sb = qBlue(color);

    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        int da = qAlpha(d);

#define OP(a,b) color_dodge_op(a, b, da, sa)
        int r = OP(  qRed(d), sr);
        int b = OP( qBlue(d), sb);
        int g = OP(qGreen(d), sg);
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_ColorDodge(uint *dest, int length, uint color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_ColorDodge_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_ColorDodge_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
static inline uint color_dodge_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
{
    const qint64 sa_da = sa * da;
    const qint64 dst_sa = dst * sa;
    const qint64 src_da = src * da;

    const qint64 temp = src * (65535U - da) + dst * (65535U - sa);
    if (src_da + dst_sa > sa_da)
        return qt_div_65535(sa_da + temp);
    else if (src == sa || sa == 0)
        return qt_div_65535(temp);
    else
        return qt_div_65535(65535U * dst_sa / (65535U - 65535U * src / sa) + temp);
}

template <typename T>
static inline void comp_func_solid_ColorDodge_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{
    uint sa = color.alpha();
    uint sr = color.red();
    uint sg = color.green();
    uint sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        uint da = d.alpha();

#define OP(a,b) color_dodge_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(), sr);
        uint b = OP( d.blue(), sb);
        uint g = OP(d.green(), sg);
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_ColorDodge_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_ColorDodge_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_ColorDodge_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
static inline float color_dodge_op_rgbafp(float dst, float src, float da, float sa)
{
    const float sa_da = sa * da;
    const float dst_sa = dst * sa;
    const float src_da = src * da;

    const float temp = src * (1.0f - da) + dst * (1.0f - sa);
    if (src_da + dst_sa > sa_da)
        return sa_da + temp;
    else if (src == sa || sa == 0.0f)
        return temp;
    else
        return dst_sa / (1.0f - src / sa) + temp;
}

template <typename T>
static inline void comp_func_solid_ColorDodge_impl(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, const T &coverage)
{
    float sa = color.alpha();
    float sr = color.red();
    float sg = color.green();
    float sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        float da = d.alpha();

#define OP(a,b) color_dodge_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(), sr);
        float b = OP( d.blue(), sb);
        float g = OP(d.green(), sg);
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_ColorDodge_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_ColorDodge_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_ColorDodge_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

template <typename T>
static inline void comp_func_ColorDodge_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        uint s = src[i];

        int da = qAlpha(d);
        int sa = qAlpha(s);

#define OP(a, b) color_dodge_op(a, b, da, sa)
        int r = OP(  qRed(d),   qRed(s));
        int b = OP( qBlue(d),  qBlue(s));
        int g = OP(qGreen(d), qGreen(s));
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_ColorDodge(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_ColorDodge_impl(dest, src, length, QFullCoverage());
    else
        comp_func_ColorDodge_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_ColorDodge_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        QRgba64 s = src[i];

        uint da = d.alpha();
        uint sa = s.alpha();

#define OP(a, b) color_dodge_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(),   s.red());
        uint b = OP( d.blue(),  s.blue());
        uint g = OP(d.green(), s.green());
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_ColorDodge_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_ColorDodge_impl(dest, src, length, QFullCoverage());
    else
        comp_func_ColorDodge_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_ColorDodge_impl(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        QRgbaFloat32 s = src[i];

        float da = d.alpha();
        float sa = s.alpha();

#define OP(a, b) color_dodge_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(),   s.red());
        float b = OP( d.blue(),  s.blue());
        float g = OP(d.green(), s.green());
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_ColorDodge_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_ColorDodge_impl(dest, src, length, QFullCoverage());
    else
        comp_func_ColorDodge_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

/*
   if Sca.Da + Dca.Sa < Sa.Da
       Dca' = Sca.(1 - Da) + Dca.(1 - Sa)
   else if Sca == 0
       Dca' = Dca.Sa + Sca.(1 - Da) + Dca.(1 - Sa)
   otherwise
       Dca' = Sa.(Sca.Da + Dca.Sa - Sa.Da)/Sca + Sca.(1 - Da) + Dca.(1 - Sa)
*/
static inline int color_burn_op(int dst, int src, int da, int sa)
{
    const int src_da = src * da;
    const int dst_sa = dst * sa;
    const int sa_da = sa * da;

    const int temp = src * (255 - da) + dst * (255 - sa);

    if (src_da + dst_sa < sa_da)
        return qt_div_255(temp);
    else if (src == 0)
        return qt_div_255(dst_sa + temp);
    return qt_div_255(sa * (src_da + dst_sa - sa_da) / src + temp);
}

template <typename T>
static inline void comp_func_solid_ColorBurn_impl(uint *dest, int length, uint color, const T &coverage)
{
    int sa = qAlpha(color);
    int sr = qRed(color);
    int sg = qGreen(color);
    int sb = qBlue(color);

    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        int da = qAlpha(d);

#define OP(a, b) color_burn_op(a, b, da, sa)
        int r =  OP(  qRed(d), sr);
        int b =  OP( qBlue(d), sb);
        int g =  OP(qGreen(d), sg);
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_ColorBurn(uint *dest, int length, uint color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_ColorBurn_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_ColorBurn_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
static inline uint color_burn_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
{
    const qint64 src_da = src * da;
    const qint64 dst_sa = dst * sa;
    const qint64 sa_da = sa * da;

    const qint64 temp = src * (65535U - da) + dst * (65535U - sa);

    if (src_da + dst_sa < sa_da)
        return qt_div_65535(temp);
    else if (src == 0)
        return qt_div_65535(dst_sa + temp);
    return qt_div_65535(sa * (src_da + dst_sa - sa_da) / src + temp);
}

template <typename T>
static inline void comp_func_solid_ColorBurn_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{
    uint sa = color.alpha();
    uint sr = color.red();
    uint sg = color.green();
    uint sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        uint da = d.alpha();

#define OP(a, b) color_burn_op_rgb64(a, b, da, sa)
        uint r =  OP(  d.red(), sr);
        uint b =  OP( d.blue(), sb);
        uint g =  OP(d.green(), sg);
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_ColorBurn_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_ColorBurn_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_ColorBurn_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
static inline float color_burn_op_rgbafp(float dst, float src, float da, float sa)
{
    const float src_da = src * da;
    const float dst_sa = dst * sa;
    const float sa_da = sa * da;

    const float temp = src * (1.0f - da) + dst * (1.0f - sa);

    if (src_da + dst_sa < sa_da)
        return temp;
    else if (src == 0)
        return dst_sa + temp;
    return sa * (src_da + dst_sa - sa_da) / src + temp;
}

template <typename T>
static inline void comp_func_solid_ColorBurn_impl(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, const T &coverage)
{
    float sa = color.alpha();
    float sr = color.red();
    float sg = color.green();
    float sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        float da = d.alpha();

#define OP(a, b) color_burn_op_rgbafp(a, b, da, sa)
        float r =  OP(  d.red(), sr);
        float b =  OP( d.blue(), sb);
        float g =  OP(d.green(), sg);
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_ColorBurn_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_ColorBurn_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_ColorBurn_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

template <typename T>
static inline void comp_func_ColorBurn_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        uint s = src[i];

        int da = qAlpha(d);
        int sa = qAlpha(s);

#define OP(a, b) color_burn_op(a, b, da, sa)
        int r = OP(  qRed(d),   qRed(s));
        int b = OP( qBlue(d),  qBlue(s));
        int g = OP(qGreen(d), qGreen(s));
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_ColorBurn(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_ColorBurn_impl(dest, src, length, QFullCoverage());
    else
        comp_func_ColorBurn_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_ColorBurn_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        QRgba64 s = src[i];

        uint da = d.alpha();
        uint sa = s.alpha();

#define OP(a, b) color_burn_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(),   s.red());
        uint b = OP( d.blue(),  s.blue());
        uint g = OP(d.green(), s.green());
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_ColorBurn_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_ColorBurn_impl(dest, src, length, QFullCoverage());
    else
        comp_func_ColorBurn_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_ColorBurn_impl(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        QRgbaFloat32 s = src[i];

        float da = d.alpha();
        float sa = s.alpha();

#define OP(a, b) color_burn_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(),   s.red());
        float b = OP( d.blue(),  s.blue());
        float g = OP(d.green(), s.green());
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_ColorBurn_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_ColorBurn_impl(dest, src, length, QFullCoverage());
    else
        comp_func_ColorBurn_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

/*
    if 2.Sca < Sa
        Dca' = 2.Sca.Dca + Sca.(1 - Da) + Dca.(1 - Sa)
    otherwise
        Dca' = Sa.Da - 2.(Da - Dca).(Sa - Sca) + Sca.(1 - Da) + Dca.(1 - Sa)
*/
static inline uint hardlight_op(int dst, int src, int da, int sa)
{
    const uint temp = src * (255 - da) + dst * (255 - sa);

    if (2 * src < sa)
        return qt_div_255(2 * src * dst + temp);
    else
        return qt_div_255(sa * da - 2 * (da - dst) * (sa - src) + temp);
}

template <typename T>
static inline void comp_func_solid_HardLight_impl(uint *dest, int length, uint color, const T &coverage)
{
    int sa = qAlpha(color);
    int sr = qRed(color);
    int sg = qGreen(color);
    int sb = qBlue(color);

    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        int da = qAlpha(d);

#define OP(a, b) hardlight_op(a, b, da, sa)
        int r =  OP(  qRed(d), sr);
        int b =  OP( qBlue(d), sb);
        int g =  OP(qGreen(d), sg);
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_HardLight(uint *dest, int length, uint color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_HardLight_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_HardLight_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
static inline uint hardlight_op_rgb64(uint dst, uint src, uint da, uint sa)
{
    const uint temp = src * (65535U - da) + dst * (65535U - sa);

    if (2 * src < sa)
        return qt_div_65535(2 * src * dst + temp);
    else
        return qt_div_65535(sa * da - 2 * (da - dst) * (sa - src) + temp);
}

template <typename T>
static inline void comp_func_solid_HardLight_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{
    uint sa = color.alpha();
    uint sr = color.red();
    uint sg = color.green();
    uint sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        uint da = d.alpha();

#define OP(a, b) hardlight_op_rgb64(a, b, da, sa)
        uint r =  OP(  d.red(), sr);
        uint b =  OP( d.blue(), sb);
        uint g =  OP(d.green(), sg);
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_HardLight_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_HardLight_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_HardLight_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
static inline float hardlight_op_rgbafp(float dst, float src, float da, float sa)
{
    const float temp = src * (1.0f - da) + dst * (1.0f - sa);

    if (2 * src < sa)
        return 2 * src * dst + temp;
    else
        return sa * da - 2 * (da - dst) * (sa - src) + temp;
}

template <typename T>
static inline void comp_func_solid_HardLight_impl(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, const T &coverage)
{
    float sa = color.alpha();
    float sr = color.red();
    float sg = color.green();
    float sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        float da = d.alpha();

#define OP(a, b) hardlight_op_rgbafp(a, b, da, sa)
        float r =  OP(  d.red(), sr);
        float b =  OP( d.blue(), sb);
        float g =  OP(d.green(), sg);
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_HardLight_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_HardLight_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_HardLight_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

template <typename T>
static inline void comp_func_HardLight_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        uint s = src[i];

        int da = qAlpha(d);
        int sa = qAlpha(s);

#define OP(a, b) hardlight_op(a, b, da, sa)
        int r = OP(  qRed(d),   qRed(s));
        int b = OP( qBlue(d),  qBlue(s));
        int g = OP(qGreen(d), qGreen(s));
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_HardLight(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_HardLight_impl(dest, src, length, QFullCoverage());
    else
        comp_func_HardLight_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_HardLight_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        QRgba64 s = src[i];

        uint da = d.alpha();
        uint sa = s.alpha();

#define OP(a, b) hardlight_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(),   s.red());
        uint b = OP( d.blue(),  s.blue());
        uint g = OP(d.green(), s.green());
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_HardLight_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_HardLight_impl(dest, src, length, QFullCoverage());
    else
        comp_func_HardLight_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_HardLight_impl(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        QRgbaFloat32 s = src[i];

        float da = d.alpha();
        float sa = s.alpha();

#define OP(a, b) hardlight_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(),   s.red());
        float b = OP( d.blue(),  s.blue());
        float g = OP(d.green(), s.green());
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_HardLight_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_HardLight_impl(dest, src, length, QFullCoverage());
    else
        comp_func_HardLight_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

/*
    if 2.Sca <= Sa
        Dca' = Dca.(Sa + (2.Sca - Sa).(1 - Dca/Da)) + Sca.(1 - Da) + Dca.(1 - Sa)
    otherwise if 2.Sca > Sa and 4.Dca <= Da
        Dca' = Dca.Sa + Da.(2.Sca - Sa).(4.Dca/Da.(4.Dca/Da + 1).(Dca/Da - 1) + 7.Dca/Da) + Sca.(1 - Da) + Dca.(1 - Sa)
    otherwise if 2.Sca > Sa and 4.Dca > Da
        Dca' = Dca.Sa + Da.(2.Sca - Sa).((Dca/Da)^0.5 - Dca/Da) + Sca.(1 - Da) + Dca.(1 - Sa)
*/
static inline int soft_light_op(int dst, int src, int da, int sa)
{
    const int src2 = src << 1;
    const int dst_np = da != 0 ? (255 * dst) / da : 0;
    const int temp = (src * (255 - da) + dst * (255 - sa)) * 255;

    if (src2 < sa)
        return (dst * (sa * 255 + (src2 - sa) * (255 - dst_np)) + temp) / 65025;
    else if (4 * dst <= da)
        return (dst * sa * 255 + da * (src2 - sa) * ((((16 * dst_np - 12 * 255) * dst_np + 3 * 65025) * dst_np) / 65025) + temp) / 65025;
    else {
        return (dst * sa * 255 + da * (src2 - sa) * (int(qSqrt(qreal(dst_np * 255))) - dst_np) + temp) / 65025;
    }
}

template <typename T>
static inline void comp_func_solid_SoftLight_impl(uint *dest, int length, uint color, const T &coverage)
{
    int sa = qAlpha(color);
    int sr = qRed(color);
    int sg = qGreen(color);
    int sb = qBlue(color);

    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        int da = qAlpha(d);

#define OP(a, b) soft_light_op(a, b, da, sa)
        int r =  OP(  qRed(d), sr);
        int b =  OP( qBlue(d), sb);
        int g =  OP(qGreen(d), sg);
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_SoftLight(uint *dest, int length, uint color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_SoftLight_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_SoftLight_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
static inline uint soft_light_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
{
    const qint64 src2 = src << 1;
    const qint64 dst_np = da != 0 ? (65535U * dst) / da : 0;
    const qint64 temp = (src * (65535U - da) + dst * (65535U - sa)) * 65535U;
    const qint64 factor = Q_UINT64_C(65535) * 65535U;

    if (src2 < sa)
        return (dst * (sa * 65535U + (src2 - sa) * (65535U - dst_np)) + temp) / factor;
    else if (4 * dst <= da)
        return (dst * sa * 65535U + da * (src2 - sa) * ((((16 * dst_np - 12 * 65535U) * dst_np + 3 * factor) * dst_np) / factor) + temp) / factor;
    else {
        return (dst * sa * 65535U + da * (src2 - sa) * (int(qSqrt(qreal(dst_np * 65535U))) - dst_np) + temp) / factor;
    }
}

template <typename T>
static inline void comp_func_solid_SoftLight_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{
    uint sa = color.alpha();
    uint sr = color.red();
    uint sg = color.green();
    uint sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        uint da = d.alpha();

#define OP(a, b) soft_light_op_rgb64(a, b, da, sa)
        uint r =  OP(  d.red(), sr);
        uint b =  OP( d.blue(), sb);
        uint g =  OP(d.green(), sg);
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_SoftLight_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_SoftLight_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_SoftLight_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#endif

#if QT_CONFIG(raster_fp)
static inline float soft_light_op_rgbafp(float dst, float src, float da, float sa)
{
    const float src2 = src * 2;
    const float dst_np = da != 0.0f ? (dst / da) : 0.0f;
    const float temp = src * (1.0f - da) + dst * (1.0f - sa);

    if (src2 < sa)
        return dst * (sa + (src2 - sa) * (1.0f - dst_np)) + temp;
    else if (4 * dst <= da)
        return dst * sa + da * (src2 - sa) * (((16 * dst_np - 12) * dst_np + 3) * dst_np) + temp;
    else {
        return dst * sa + da * (src2 - sa) * (qSqrt(qreal(dst_np)) - dst_np) + temp;
    }
}

template <typename T>
static inline void comp_func_solid_SoftLight_impl(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, const T &coverage)
{
    float sa = color.alpha();
    float sr = color.red();
    float sg = color.green();
    float sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        float da = d.alpha();

#define OP(a, b) soft_light_op_rgbafp(a, b, da, sa)
        float r =  OP(  d.red(), sr);
        float b =  OP( d.blue(), sb);
        float g =  OP(d.green(), sg);
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_SoftLight_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_SoftLight_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_SoftLight_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

template <typename T>
static inline void comp_func_SoftLight_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        uint s = src[i];

        int da = qAlpha(d);
        int sa = qAlpha(s);

#define OP(a, b) soft_light_op(a, b, da, sa)
        int r = OP(  qRed(d),   qRed(s));
        int b = OP( qBlue(d),  qBlue(s));
        int g = OP(qGreen(d), qGreen(s));
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_SoftLight(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_SoftLight_impl(dest, src, length, QFullCoverage());
    else
        comp_func_SoftLight_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_SoftLight_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        QRgba64 s = src[i];

        uint da = d.alpha();
        uint sa = s.alpha();

#define OP(a, b) soft_light_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(),   s.red());
        uint b = OP( d.blue(),  s.blue());
        uint g = OP(d.green(), s.green());
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_SoftLight_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_SoftLight_impl(dest, src, length, QFullCoverage());
    else
        comp_func_SoftLight_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_SoftLight_impl(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        QRgbaFloat32 s = src[i];

        float da = d.alpha();
        float sa = s.alpha();

#define OP(a, b) soft_light_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(),   s.red());
        float b = OP( d.blue(),  s.blue());
        float g = OP(d.green(), s.green());
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_SoftLight_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_SoftLight_impl(dest, src, length, QFullCoverage());
    else
        comp_func_SoftLight_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

/*
   Dca' = abs(Dca.Sa - Sca.Da) + Sca.(1 - Da) + Dca.(1 - Sa)
        = Sca + Dca - 2.min(Sca.Da, Dca.Sa)
*/
static inline int difference_op(int dst, int src, int da, int sa)
{
    return src + dst - qt_div_255(2 * qMin(src * da, dst * sa));
}

template <typename T>
static inline void comp_func_solid_Difference_impl(uint *dest, int length, uint color, const T &coverage)
{
    int sa = qAlpha(color);
    int sr = qRed(color);
    int sg = qGreen(color);
    int sb = qBlue(color);

    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        int da = qAlpha(d);

#define OP(a, b) difference_op(a, b, da, sa)
        int r =  OP(  qRed(d), sr);
        int b =  OP( qBlue(d), sb);
        int g =  OP(qGreen(d), sg);
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Difference(uint *dest, int length, uint color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Difference_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Difference_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
static inline uint difference_op_rgb64(qint64 dst, qint64 src, qint64 da, qint64 sa)
{
    return src + dst - qt_div_65535(2 * qMin(src * da, dst * sa));
}

template <typename T>
static inline void comp_func_solid_Difference_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{
    uint sa = color.alpha();
    uint sr = color.red();
    uint sg = color.green();
    uint sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        uint da = d.alpha();

#define OP(a, b) difference_op_rgb64(a, b, da, sa)
        uint r =  OP(  d.red(), sr);
        uint b =  OP( d.blue(), sb);
        uint g =  OP(d.green(), sg);
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Difference_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Difference_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Difference_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
static inline float difference_op_rgbafp(float dst, float src, float da, float sa)
{
    return src + dst - (2 * qMin(src * da, dst * sa));
}

template <typename T>
static inline void comp_func_solid_Difference_impl(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, const T &coverage)
{
    float sa = color.alpha();
    float sr = color.red();
    float sg = color.green();
    float sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        float da = d.alpha();

#define OP(a, b) difference_op_rgbafp(a, b, da, sa)
        float r =  OP(  d.red(), sr);
        float b =  OP( d.blue(), sb);
        float g =  OP(d.green(), sg);
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Difference_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Difference_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Difference_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

template <typename T>
static inline void comp_func_Difference_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        uint s = src[i];

        int da = qAlpha(d);
        int sa = qAlpha(s);

#define OP(a, b) difference_op(a, b, da, sa)
        int r = OP(  qRed(d),   qRed(s));
        int b = OP( qBlue(d),  qBlue(s));
        int g = OP(qGreen(d), qGreen(s));
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Difference(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Difference_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Difference_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_Difference_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        QRgba64 s = src[i];

        uint da = d.alpha();
        uint sa = s.alpha();

#define OP(a, b) difference_op_rgb64(a, b, da, sa)
        uint r = OP(  d.red(),   s.red());
        uint b = OP( d.blue(),  s.blue());
        uint g = OP(d.green(), s.green());
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Difference_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Difference_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Difference_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_Difference_impl(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        QRgbaFloat32 s = src[i];

        float da = d.alpha();
        float sa = s.alpha();

#define OP(a, b) difference_op_rgbafp(a, b, da, sa)
        float r = OP(  d.red(),   s.red());
        float b = OP( d.blue(),  s.blue());
        float g = OP(d.green(), s.green());
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Difference_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Difference_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Difference_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

/*
    Dca' = (Sca.Da + Dca.Sa - 2.Sca.Dca) + Sca.(1 - Da) + Dca.(1 - Sa)
*/
template <typename T>
static inline void QT_FASTCALL comp_func_solid_Exclusion_impl(uint *dest, int length, uint color, const T &coverage)
{
    int sa = qAlpha(color);
    int sr = qRed(color);
    int sg = qGreen(color);
    int sb = qBlue(color);

    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        int da = qAlpha(d);

#define OP(a, b) (a + b - qt_div_255(2*(a*b)))
        int r =  OP(  qRed(d), sr);
        int b =  OP( qBlue(d), sb);
        int g =  OP(qGreen(d), sg);
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Exclusion(uint *dest, int length, uint color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Exclusion_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Exclusion_impl(dest, length, color, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void QT_FASTCALL comp_func_solid_Exclusion_impl(QRgba64 *dest, int length, QRgba64 color, const T &coverage)
{
    uint sa = color.alpha();
    uint sr = color.red();
    uint sg = color.green();
    uint sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        uint da = d.alpha();

#define OP(a, b) (a + b - qt_div_65535(2*(qint64(a)*b)))
        uint r =  OP(  d.red(), sr);
        uint b =  OP( d.blue(), sb);
        uint g =  OP(d.green(), sg);
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Exclusion_rgb64(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Exclusion_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Exclusion_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void QT_FASTCALL comp_func_solid_Exclusion_impl(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, const T &coverage)
{
    float sa = color.alpha();
    float sr = color.red();
    float sg = color.green();
    float sb = color.blue();

    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        float da = d.alpha();

#define OP(a, b) (a + b - (2.0f * a * b))
        float r =  OP(  d.red(), sr);
        float b =  OP( d.blue(), sb);
        float g =  OP(d.green(), sg);
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_solid_Exclusion_rgbafp(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_solid_Exclusion_impl(dest, length, color, QFullCoverage());
    else
        comp_func_solid_Exclusion_impl(dest, length, color, QPartialCoverage(const_alpha));
}
#endif

template <typename T>
static inline void comp_func_Exclusion_impl(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        uint d = dest[i];
        uint s = src[i];

        int da = qAlpha(d);
        int sa = qAlpha(s);

#define OP(a, b) (a + b - ((a*b) >> 7))
        int r = OP(  qRed(d),   qRed(s));
        int b = OP( qBlue(d),  qBlue(s));
        int g = OP(qGreen(d), qGreen(s));
        int a = mix_alpha(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Exclusion(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Exclusion_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Exclusion_impl(dest, src, length, QPartialCoverage(const_alpha));
}

#if QT_CONFIG(raster_64bit)
template <typename T>
static inline void comp_func_Exclusion_impl(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgba64 d = dest[i];
        QRgba64 s = src[i];

        uint da = d.alpha();
        uint sa = s.alpha();

#define OP(a, b)  (a + b - ((qint64(a)*b) >> 15))
        uint r = OP(  d.red(),   s.red());
        uint b = OP( d.blue(),  s.blue());
        uint g = OP(d.green(), s.green());
        uint a = mix_alpha_rgb64(da, sa);
#undef OP

        coverage.store(&dest[i], qRgba64(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Exclusion_rgb64(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Exclusion_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Exclusion_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

#if QT_CONFIG(raster_fp)
template <typename T>
static inline void comp_func_Exclusion_impl(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, const T &coverage)
{
    for (int i = 0; i < length; ++i) {
        QRgbaFloat32 d = dest[i];
        QRgbaFloat32 s = src[i];

        float da = d.alpha();
        float sa = s.alpha();

#define OP(a, b) (a + b - (2.0f * a * b))
        float r = OP(  d.red(),   s.red());
        float b = OP( d.blue(),  s.blue());
        float g = OP(d.green(), s.green());
        float a = mix_alpha_rgbafp(da, sa);
#undef OP

        coverage.store(&dest[i], qRgbaFloat32(r, g, b, a));
    }
}

void QT_FASTCALL comp_func_Exclusion_rgbafp(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
{
    if (const_alpha == 255)
        comp_func_Exclusion_impl(dest, src, length, QFullCoverage());
    else
        comp_func_Exclusion_impl(dest, src, length, QPartialCoverage(const_alpha));
}
#endif

void QT_FASTCALL rasterop_solid_SourceOrDestination(uint *dest,
                                                    int length,
                                                    uint color,
                                                    uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--)
        *dest++ |= color;
}

void QT_FASTCALL rasterop_SourceOrDestination(uint *Q_DECL_RESTRICT dest,
                                              const uint *Q_DECL_RESTRICT src,
                                              int length,
                                              uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--)
        *dest++ |= *src++;
}

void QT_FASTCALL rasterop_solid_SourceAndDestination(uint *dest,
                                                     int length,
                                                     uint color,
                                                     uint const_alpha)
{
    Q_UNUSED(const_alpha);
    color |= 0xff000000;
    while (length--)
        *dest++ &= color;
}

void QT_FASTCALL rasterop_SourceAndDestination(uint *Q_DECL_RESTRICT dest,
                                               const uint *Q_DECL_RESTRICT src,
                                               int length,
                                               uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--) {
        *dest = (*src & *dest) | 0xff000000;
        ++dest; ++src;
    }
}

void QT_FASTCALL rasterop_solid_SourceXorDestination(uint *dest,
                                                     int length,
                                                     uint color,
                                                     uint const_alpha)
{
    Q_UNUSED(const_alpha);
    color &= 0x00ffffff;
    while (length--)
        *dest++ ^= color;
}

void QT_FASTCALL rasterop_SourceXorDestination(uint *Q_DECL_RESTRICT dest,
                                               const uint *Q_DECL_RESTRICT src,
                                               int length,
                                               uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--) {
        *dest = (*src ^ *dest) | 0xff000000;
        ++dest; ++src;
    }
}

void QT_FASTCALL rasterop_solid_NotSourceAndNotDestination(uint *dest,
                                                           int length,
                                                           uint color,
                                                           uint const_alpha)
{
    Q_UNUSED(const_alpha);
    color = ~color;
    while (length--) {
        *dest = (color & ~(*dest)) | 0xff000000;
        ++dest;
    }
}

void QT_FASTCALL rasterop_NotSourceAndNotDestination(uint *Q_DECL_RESTRICT dest,
                                                     const uint *Q_DECL_RESTRICT src,
                                                     int length,
                                                     uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--) {
        *dest = (~(*src) & ~(*dest)) | 0xff000000;
        ++dest; ++src;
    }
}

void QT_FASTCALL rasterop_solid_NotSourceOrNotDestination(uint *dest,
                                                          int length,
                                                          uint color,
                                                          uint const_alpha)
{
    Q_UNUSED(const_alpha);
    color = ~color | 0xff000000;
    while (length--) {
        *dest = color | ~(*dest);
        ++dest;
    }
}

void QT_FASTCALL rasterop_NotSourceOrNotDestination(uint *Q_DECL_RESTRICT dest,
                                                    const uint *Q_DECL_RESTRICT src,
                                                    int length,
                                                    uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--) {
        *dest = ~(*src) | ~(*dest) | 0xff000000;
        ++dest; ++src;
    }
}

void QT_FASTCALL rasterop_solid_NotSourceXorDestination(uint *dest,
                                                        int length,
                                                        uint color,
                                                        uint const_alpha)
{
    Q_UNUSED(const_alpha);
    color = ~color & 0x00ffffff;
    while (length--) {
        *dest = color ^ (*dest);
        ++dest;
    }
}

void QT_FASTCALL rasterop_NotSourceXorDestination(uint *Q_DECL_RESTRICT dest,
                                                  const uint *Q_DECL_RESTRICT src,
                                                  int length,
                                                  uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--) {
        *dest = ((~(*src)) ^ (*dest)) | 0xff000000;
        ++dest; ++src;
    }
}

void QT_FASTCALL rasterop_solid_NotSource(uint *dest, int length,
                                          uint color, uint const_alpha)
{
    Q_UNUSED(const_alpha);
    qt_memfill(dest, ~color | 0xff000000, length);
}

void QT_FASTCALL rasterop_NotSource(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src,
                                    int length, uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--)
        *dest++ = ~(*src++) | 0xff000000;
}

void QT_FASTCALL rasterop_solid_NotSourceAndDestination(uint *dest,
                                                        int length,
                                                        uint color,
                                                        uint const_alpha)
{
    Q_UNUSED(const_alpha);
    color = ~color | 0xff000000;
    while (length--) {
        *dest = color & *dest;
        ++dest;
    }
}

void QT_FASTCALL rasterop_NotSourceAndDestination(uint *Q_DECL_RESTRICT dest,
                                                  const uint *Q_DECL_RESTRICT src,
                                                  int length,
                                                  uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--) {
        *dest = (~(*src) & *dest) | 0xff000000;
        ++dest; ++src;
    }
}

void QT_FASTCALL rasterop_solid_SourceAndNotDestination(uint *dest,
                                                        int length,
                                                        uint color,
                                                        uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--) {
        *dest = (color & ~(*dest)) | 0xff000000;
        ++dest;
    }
}

void QT_FASTCALL rasterop_SourceAndNotDestination(uint *Q_DECL_RESTRICT dest,
                                                  const uint *Q_DECL_RESTRICT src,
                                                  int length,
                                                  uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--) {
        *dest = (*src & ~(*dest)) | 0xff000000;
        ++dest; ++src;
    }
}

void QT_FASTCALL rasterop_NotSourceOrDestination(uint *Q_DECL_RESTRICT dest,
                                                 const uint *Q_DECL_RESTRICT src,
                                                 int length,
                                                 uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--) {
        *dest = (~(*src) | *dest) | 0xff000000;
        ++dest; ++src;
    }
}

void QT_FASTCALL rasterop_solid_NotSourceOrDestination(uint *Q_DECL_RESTRICT dest,
                                                       int length,
                                                       uint color,
                                                       uint const_alpha)
{
    Q_UNUSED(const_alpha);
    color = ~color | 0xff000000;
    while (length--)
        *dest++ |= color;
}

void QT_FASTCALL rasterop_SourceOrNotDestination(uint *Q_DECL_RESTRICT dest,
                                                 const uint *Q_DECL_RESTRICT src,
                                                 int length,
                                                 uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--) {
        *dest = (*src | ~(*dest)) | 0xff000000;
        ++dest; ++src;
    }
}

void QT_FASTCALL rasterop_solid_SourceOrNotDestination(uint *Q_DECL_RESTRICT dest,
                                                       int length,
                                                       uint color,
                                                       uint const_alpha)
{
    Q_UNUSED(const_alpha);
    while (length--) {
        *dest = (color | ~(*dest)) | 0xff000000;
        ++dest;
    }
}

void QT_FASTCALL rasterop_ClearDestination(uint *Q_DECL_RESTRICT dest,
                                           const uint *Q_DECL_RESTRICT src,
                                           int length,
                                           uint const_alpha)
{
    Q_UNUSED(src);
    comp_func_solid_SourceOver (dest, length, 0xff000000, const_alpha);
}

void QT_FASTCALL rasterop_solid_ClearDestination(uint *Q_DECL_RESTRICT dest,
                                                 int length,
                                                 uint color,
                                                 uint const_alpha)
{
    Q_UNUSED(color);
    comp_func_solid_SourceOver (dest, length, 0xff000000, const_alpha);
}

void QT_FASTCALL rasterop_SetDestination(uint *Q_DECL_RESTRICT dest,
                                         const uint *Q_DECL_RESTRICT src,
                                         int length,
                                         uint const_alpha)
{
    Q_UNUSED(src);
    comp_func_solid_SourceOver (dest, length, 0xffffffff, const_alpha);
}

void QT_FASTCALL rasterop_solid_SetDestination(uint *Q_DECL_RESTRICT dest,
                                               int length,
                                               uint color,
                                               uint const_alpha)
{
    Q_UNUSED(color);
    comp_func_solid_SourceOver (dest, length, 0xffffffff, const_alpha);
}

void QT_FASTCALL rasterop_NotDestination(uint *Q_DECL_RESTRICT dest,
                                         const uint *Q_DECL_RESTRICT src,
                                         int length,
                                         uint const_alpha)
{
    Q_UNUSED(src);
    rasterop_solid_SourceXorDestination (dest, length, 0x00ffffff, const_alpha);
}

void QT_FASTCALL rasterop_solid_NotDestination(uint *Q_DECL_RESTRICT dest,
                                               int length,
                                               uint color,
                                               uint const_alpha)
{
    Q_UNUSED(color);
    rasterop_solid_SourceXorDestination (dest, length, 0x00ffffff, const_alpha);
}

CompositionFunctionSolid qt_functionForModeSolid_C[] = {
        comp_func_solid_SourceOver,
        comp_func_solid_DestinationOver,
        comp_func_solid_Clear,
        comp_func_solid_Source,
        comp_func_solid_Destination,
        comp_func_solid_SourceIn,
        comp_func_solid_DestinationIn,
        comp_func_solid_SourceOut,
        comp_func_solid_DestinationOut,
        comp_func_solid_SourceAtop,
        comp_func_solid_DestinationAtop,
        comp_func_solid_XOR,
        comp_func_solid_Plus,
        comp_func_solid_Multiply,
        comp_func_solid_Screen,
        comp_func_solid_Overlay,
        comp_func_solid_Darken,
        comp_func_solid_Lighten,
        comp_func_solid_ColorDodge,
        comp_func_solid_ColorBurn,
        comp_func_solid_HardLight,
        comp_func_solid_SoftLight,
        comp_func_solid_Difference,
        comp_func_solid_Exclusion,
        rasterop_solid_SourceOrDestination,
        rasterop_solid_SourceAndDestination,
        rasterop_solid_SourceXorDestination,
        rasterop_solid_NotSourceAndNotDestination,
        rasterop_solid_NotSourceOrNotDestination,
        rasterop_solid_NotSourceXorDestination,
        rasterop_solid_NotSource,
        rasterop_solid_NotSourceAndDestination,
        rasterop_solid_SourceAndNotDestination,
        rasterop_solid_NotSourceOrDestination,
        rasterop_solid_SourceOrNotDestination,
        rasterop_solid_ClearDestination,
        rasterop_solid_SetDestination,
        rasterop_solid_NotDestination
};

CompositionFunctionSolid64 qt_functionForModeSolid64_C[] = {
#if QT_CONFIG(raster_64bit)
        comp_func_solid_SourceOver_rgb64,
        comp_func_solid_DestinationOver_rgb64,
        comp_func_solid_Clear_rgb64,
        comp_func_solid_Source_rgb64,
        comp_func_solid_Destination_rgb64,
        comp_func_solid_SourceIn_rgb64,
        comp_func_solid_DestinationIn_rgb64,
        comp_func_solid_SourceOut_rgb64,
        comp_func_solid_DestinationOut_rgb64,
        comp_func_solid_SourceAtop_rgb64,
        comp_func_solid_DestinationAtop_rgb64,
        comp_func_solid_XOR_rgb64,
        comp_func_solid_Plus_rgb64,
        comp_func_solid_Multiply_rgb64,
        comp_func_solid_Screen_rgb64,
        comp_func_solid_Overlay_rgb64,
        comp_func_solid_Darken_rgb64,
        comp_func_solid_Lighten_rgb64,
        comp_func_solid_ColorDodge_rgb64,
        comp_func_solid_ColorBurn_rgb64,
        comp_func_solid_HardLight_rgb64,
        comp_func_solid_SoftLight_rgb64,
        comp_func_solid_Difference_rgb64,
        comp_func_solid_Exclusion_rgb64,
#else
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
#endif
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr
};

CompositionFunctionSolidFP qt_functionForModeSolidFP_C[] = {
#if QT_CONFIG(raster_fp)
        comp_func_solid_SourceOver_rgbafp,
        comp_func_solid_DestinationOver_rgbafp,
        comp_func_solid_Clear_rgbafp,
        comp_func_solid_Source_rgbafp,
        comp_func_solid_Destination_rgbafp,
        comp_func_solid_SourceIn_rgbafp,
        comp_func_solid_DestinationIn_rgbafp,
        comp_func_solid_SourceOut_rgbafp,
        comp_func_solid_DestinationOut_rgbafp,
        comp_func_solid_SourceAtop_rgbafp,
        comp_func_solid_DestinationAtop_rgbafp,
        comp_func_solid_XOR_rgbafp,
        comp_func_solid_Plus_rgbafp,
        comp_func_solid_Multiply_rgbafp,
        comp_func_solid_Screen_rgbafp,
        comp_func_solid_Overlay_rgbafp,
        comp_func_solid_Darken_rgbafp,
        comp_func_solid_Lighten_rgbafp,
        comp_func_solid_ColorDodge_rgbafp,
        comp_func_solid_ColorBurn_rgbafp,
        comp_func_solid_HardLight_rgbafp,
        comp_func_solid_SoftLight_rgbafp,
        comp_func_solid_Difference_rgbafp,
        comp_func_solid_Exclusion_rgbafp,
#else
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
#endif
        0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0
};

CompositionFunction qt_functionForMode_C[] = {
        comp_func_SourceOver,
        comp_func_DestinationOver,
        comp_func_Clear,
        comp_func_Source,
        comp_func_Destination,
        comp_func_SourceIn,
        comp_func_DestinationIn,
        comp_func_SourceOut,
        comp_func_DestinationOut,
        comp_func_SourceAtop,
        comp_func_DestinationAtop,
        comp_func_XOR,
        comp_func_Plus,
        comp_func_Multiply,
        comp_func_Screen,
        comp_func_Overlay,
        comp_func_Darken,
        comp_func_Lighten,
        comp_func_ColorDodge,
        comp_func_ColorBurn,
        comp_func_HardLight,
        comp_func_SoftLight,
        comp_func_Difference,
        comp_func_Exclusion,
        rasterop_SourceOrDestination,
        rasterop_SourceAndDestination,
        rasterop_SourceXorDestination,
        rasterop_NotSourceAndNotDestination,
        rasterop_NotSourceOrNotDestination,
        rasterop_NotSourceXorDestination,
        rasterop_NotSource,
        rasterop_NotSourceAndDestination,
        rasterop_SourceAndNotDestination,
        rasterop_NotSourceOrDestination,
        rasterop_SourceOrNotDestination,
        rasterop_ClearDestination,
        rasterop_SetDestination,
        rasterop_NotDestination
};

CompositionFunction64 qt_functionForMode64_C[] = {
#if QT_CONFIG(raster_64bit)
        comp_func_SourceOver_rgb64,
        comp_func_DestinationOver_rgb64,
        comp_func_Clear_rgb64,
        comp_func_Source_rgb64,
        comp_func_Destination_rgb64,
        comp_func_SourceIn_rgb64,
        comp_func_DestinationIn_rgb64,
        comp_func_SourceOut_rgb64,
        comp_func_DestinationOut_rgb64,
        comp_func_SourceAtop_rgb64,
        comp_func_DestinationAtop_rgb64,
        comp_func_XOR_rgb64,
        comp_func_Plus_rgb64,
        comp_func_Multiply_rgb64,
        comp_func_Screen_rgb64,
        comp_func_Overlay_rgb64,
        comp_func_Darken_rgb64,
        comp_func_Lighten_rgb64,
        comp_func_ColorDodge_rgb64,
        comp_func_ColorBurn_rgb64,
        comp_func_HardLight_rgb64,
        comp_func_SoftLight_rgb64,
        comp_func_Difference_rgb64,
        comp_func_Exclusion_rgb64,
#else
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
#endif
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
        nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr
};

CompositionFunctionFP qt_functionForModeFP_C[] = {
#if QT_CONFIG(raster_fp)
        comp_func_SourceOver_rgbafp,
        comp_func_DestinationOver_rgbafp,
        comp_func_Clear_rgbafp,
        comp_func_Source_rgbafp,
        comp_func_Destination_rgbafp,
        comp_func_SourceIn_rgbafp,
        comp_func_DestinationIn_rgbafp,
        comp_func_SourceOut_rgbafp,
        comp_func_DestinationOut_rgbafp,
        comp_func_SourceAtop_rgbafp,
        comp_func_DestinationAtop_rgbafp,
        comp_func_XOR_rgbafp,
        comp_func_Plus_rgbafp,
        comp_func_Multiply_rgbafp,
        comp_func_Screen_rgbafp,
        comp_func_Overlay_rgbafp,
        comp_func_Darken_rgbafp,
        comp_func_Lighten_rgbafp,
        comp_func_ColorDodge_rgbafp,
        comp_func_ColorBurn_rgbafp,
        comp_func_HardLight_rgbafp,
        comp_func_SoftLight_rgbafp,
        comp_func_Difference_rgbafp,
        comp_func_Exclusion_rgbafp,
#else
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
#endif
        0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0
};

QT_END_NAMESPACE
