/****************************************************************************

**

** Copyright (C) 2016 The Qt Company Ltd.

** Contact: https://www.qt.io/licensing/

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** Commercial License Usage

** Licensees holding valid commercial Qt licenses may use this file in

** accordance with the commercial license agreement provided with the

** Software or, alternatively, in accordance with the terms contained in

** a written agreement between you and The Qt Company. For licensing terms

** and conditions see https://www.qt.io/terms-conditions. For further

** information use the contact form at https://www.qt.io/contact-us.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 3 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL3 included in the

** packaging of this file. Please review the following information to

** ensure the GNU Lesser General Public License version 3 requirements

** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

**

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU

** General Public License version 2.0 or (at your option) the GNU General

** Public license version 3 or any later version approved by the KDE Free

** Qt Foundation. The licenses are as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

** included in the packaging of this file. Please review the following

** information to ensure the GNU General Public License requirements will

** be met: https://www.gnu.org/licenses/gpl-2.0.html and

** https://www.gnu.org/licenses/gpl-3.0.html.

**

** $QT_END_LICENSE$

**

****************************************************************************/

#ifndef QRGBA64_P_H

#define QRGBA64_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "qrgba64.h"

#include "qdrawhelper_p.h"

#include <QtCore/private/qsimd_p.h>

#include <QtGui/private/qtguiglobal_p.h>

QT_BEGIN_NAMESPACE

inline QRgba64 combineAlpha256(QRgba64 rgba64, uint alpha256)

{

    return QRgba64::fromRgba64(rgba64.red(), rgba64.green(), rgba64.blue(), (rgba64.alpha() * alpha256) >> 8);

}

inline QRgba64 multiplyAlpha65535(QRgba64 rgba64, uint alpha65535)

{

    return QRgba64::fromRgba64(qt_div_65535(rgba64.red()   * alpha65535),

                               qt_div_65535(rgba64.green() * alpha65535),

                               qt_div_65535(rgba64.blue()  * alpha65535),

                               qt_div_65535(rgba64.alpha() * alpha65535));

}

#ifdef __SSE2__

Q_ALWAYS_INLINE __m128i multiplyAlpha65535(__m128i rgba64, __m128i va)

{

    __m128i vs = rgba64;

    vs = _mm_unpacklo_epi16(_mm_mullo_epi16(vs, va), _mm_mulhi_epu16(vs, va));

    vs = _mm_add_epi32(vs, _mm_srli_epi32(vs, 16));

    vs = _mm_add_epi32(vs, _mm_set1_epi32(0x8000));

    vs = _mm_srai_epi32(vs, 16);

    vs = _mm_packs_epi32(vs, _mm_setzero_si128());

    return vs;

}

Q_ALWAYS_INLINE __m128i multiplyAlpha65535(__m128i rgba64, uint alpha65535)

{

    const __m128i va = _mm_shufflelo_epi16(_mm_cvtsi32_si128(alpha65535), _MM_SHUFFLE(0, 0, 0, 0));

    return multiplyAlpha65535(rgba64, va);

}

#endif

#if defined(__ARM_NEON__)

Q_ALWAYS_INLINE uint16x4_t multiplyAlpha65535(uint16x4_t rgba64, uint16x4_t alpha65535)

{

    uint32x4_t vs32 = vmull_u16(rgba64, alpha65535); // vs = vs * alpha

    vs32 = vsraq_n_u32(vs32, vs32, 16); // vs = vs + (vs >> 16)

    return vrshrn_n_u32(vs32, 16); // vs = (vs + 0x8000) >> 16

}

Q_ALWAYS_INLINE uint16x4_t multiplyAlpha65535(uint16x4_t rgba64, uint alpha65535)

{

    uint32x4_t vs32 = vmull_n_u16(rgba64, alpha65535); // vs = vs * alpha

    vs32 = vsraq_n_u32(vs32, vs32, 16); // vs = vs + (vs >> 16)

    return vrshrn_n_u32(vs32, 16); // vs = (vs + 0x8000) >> 16

}

#endif

template<typename T>

inline T multiplyAlpha255(T rgba64, uint alpha255)

{

#if defined(__SSE2__) || defined(__ARM_NEON__)

    return multiplyAlpha65535(rgba64, alpha255 * 257);

#else

    return QRgba64::fromRgba64(qt_div_255(rgba64.red()   * alpha255),

                               qt_div_255(rgba64.green() * alpha255),

                               qt_div_255(rgba64.blue()  * alpha255),

                               qt_div_255(rgba64.alpha() * alpha255));

#endif

}

Unexecuted instantiation: QRgba64 multiplyAlpha255<QRgba64>(QRgba64, unsigned int)

Unexecuted instantiation: long long __vector(2) multiplyAlpha255<long long __vector(2)>(long long __vector(2), unsigned int)

inline QRgba64 interpolate255(QRgba64 x, uint alpha1, QRgba64 y, uint alpha2)

{

    return QRgba64::fromRgba64(multiplyAlpha255(x, alpha1) + multiplyAlpha255(y, alpha2));

}

#if defined __SSE2__

Q_ALWAYS_INLINE __m128i interpolate255(__m128i x, uint alpha1, __m128i y, uint alpha2)

{

    return _mm_add_epi32(multiplyAlpha255(x, alpha1), multiplyAlpha255(y, alpha2));

}

#endif

#if defined __ARM_NEON__

Q_ALWAYS_INLINE uint16x4_t interpolate255(uint16x4_t x, uint alpha1, uint16x4_t y, uint alpha2)

{

    return vadd_u16(multiplyAlpha255(x, alpha1), multiplyAlpha255(y, alpha2));

}

#endif

inline QRgba64 interpolate65535(QRgba64 x, uint alpha1, QRgba64 y, uint alpha2)

{

    return QRgba64::fromRgba64(multiplyAlpha65535(x, alpha1) + multiplyAlpha65535(y, alpha2));

}

#if defined __SSE2__

Q_ALWAYS_INLINE __m128i interpolate65535(__m128i x, uint alpha1, __m128i y, uint alpha2)

{

    return _mm_add_epi32(multiplyAlpha65535(x, alpha1), multiplyAlpha65535(y, alpha2));

}

// alpha2 below is const-ref because otherwise MSVC2015 complains that it can't 16-byte align the argument.

Q_ALWAYS_INLINE __m128i interpolate65535(__m128i x, __m128i alpha1, __m128i y, const __m128i &alpha2)

{

    return _mm_add_epi32(multiplyAlpha65535(x, alpha1), multiplyAlpha65535(y, alpha2));

}

#endif

#if defined __ARM_NEON__

Q_ALWAYS_INLINE uint16x4_t interpolate65535(uint16x4_t x, uint alpha1, uint16x4_t y, uint alpha2)

{

    return vadd_u16(multiplyAlpha65535(x, alpha1), multiplyAlpha65535(y, alpha2));

}

Q_ALWAYS_INLINE uint16x4_t interpolate65535(uint16x4_t x, uint16x4_t alpha1, uint16x4_t y, uint16x4_t alpha2)

{

    return vadd_u16(multiplyAlpha65535(x, alpha1), multiplyAlpha65535(y, alpha2));

}

#endif

inline QRgba64 addWithSaturation(QRgba64 a, QRgba64 b)

{

    return QRgba64::fromRgba64(qMin(a.red() + b.red(), 65535),

                               qMin(a.green() + b.green(), 65535),

                               qMin(a.blue() + b.blue(), 65535),

                               qMin(a.alpha() + b.alpha(), 65535));

}

#if QT_COMPILER_SUPPORTS_HERE(SSE2)

QT_FUNCTION_TARGET(SSE2)

Q_ALWAYS_INLINE uint toArgb32(__m128i v)

{

    v = _mm_unpacklo_epi16(v, _mm_setzero_si128());

    v = _mm_add_epi32(v, _mm_set1_epi32(128));

    v = _mm_sub_epi32(v, _mm_srli_epi32(v, 8));

    v = _mm_srli_epi32(v, 8);

    v = _mm_packs_epi32(v, v);

    v = _mm_packus_epi16(v, v);

    return _mm_cvtsi128_si32(v);

}

#elif defined __ARM_NEON__

Q_ALWAYS_INLINE uint toArgb32(uint16x4_t v)

{

    v = vsub_u16(v, vrshr_n_u16(v, 8));

    v = vrshr_n_u16(v, 8);

    uint8x8_t v8 = vmovn_u16(vcombine_u16(v, v));

    return vget_lane_u32(vreinterpret_u32_u8(v8), 0);

}

#endif

Q_ALWAYS_INLINE uint toArgb32(QRgba64 rgba64)

{

#if defined __SSE2__

    __m128i v = _mm_loadl_epi64((const __m128i *)&rgba64);

    v = _mm_shufflelo_epi16(v, _MM_SHUFFLE(3, 0, 1, 2));

    return toArgb32(v);

#elif defined __ARM_NEON__

    uint16x4_t v = vreinterpret_u16_u64(vld1_u64(reinterpret_cast<const uint64_t *>(&rgba64)));

#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN

    const uint8x8_t shuffleMask = { 4, 5, 2, 3, 0, 1, 6, 7 };

    v = vreinterpret_u16_u8(vtbl1_u8(vreinterpret_u8_u16(v), shuffleMask));

#else

    v = vext_u16(v, v, 3);

#endif

    return toArgb32(v);

#else

    return rgba64.toArgb32();

#endif

}

Q_ALWAYS_INLINE uint toRgba8888(QRgba64 rgba64)

{

#if defined __SSE2__

    __m128i v = _mm_loadl_epi64((const __m128i *)&rgba64);

    return toArgb32(v);

#elif defined __ARM_NEON__

    uint16x4_t v = vreinterpret_u16_u64(vld1_u64(reinterpret_cast<const uint64_t *>(&rgba64)));

    return toArgb32(v);

#else

    return ARGB2RGBA(toArgb32(rgba64));

#endif

}

inline QRgba64 rgbBlend(QRgba64 d, QRgba64 s, uint rgbAlpha)

{

    QRgba64 blend;

#if defined(__SSE2__)

    __m128i vd = _mm_loadl_epi64((const __m128i *)&d);

    __m128i vs = _mm_loadl_epi64((const __m128i *)&s);

    __m128i va =  _mm_cvtsi32_si128(rgbAlpha);

    va = _mm_unpacklo_epi8(va, va);

    va = _mm_shufflelo_epi16(va, _MM_SHUFFLE(3, 0, 1, 2));

    __m128i vb = _mm_xor_si128(_mm_set1_epi16(-1), va);

    vs = _mm_unpacklo_epi16(_mm_mullo_epi16(vs, va), _mm_mulhi_epu16(vs, va));

    vd = _mm_unpacklo_epi16(_mm_mullo_epi16(vd, vb), _mm_mulhi_epu16(vd, vb));

    vd = _mm_add_epi32(vd, vs);

    vd = _mm_add_epi32(vd, _mm_srli_epi32(vd, 16));

    vd = _mm_add_epi32(vd, _mm_set1_epi32(0x8000));

    vd = _mm_srai_epi32(vd, 16);

    vd = _mm_packs_epi32(vd, _mm_setzero_si128());

    _mm_storel_epi64((__m128i *)&blend, vd);

#elif defined(__ARM_NEON__)

    uint16x4_t vd = vreinterpret_u16_u64(vmov_n_u64(d));

    uint16x4_t vs = vreinterpret_u16_u64(vmov_n_u64(s));

    uint8x8_t va8 = vreinterpret_u8_u32(vmov_n_u32(ARGB2RGBA(rgbAlpha)));

    uint16x4_t va = vreinterpret_u16_u8(vzip_u8(va8, va8).val[0]);

    uint16x4_t vb = vdup_n_u16(0xffff);

    vb = vsub_u16(vb, va);

    uint32x4_t vs32 = vmull_u16(vs, va);

    uint32x4_t vd32 = vmull_u16(vd, vb);

    vd32 = vaddq_u32(vd32, vs32);

    vd32 = vsraq_n_u32(vd32, vd32, 16);

    vd = vrshrn_n_u32(vd32, 16);

    vst1_u64(reinterpret_cast<uint64_t *>(&blend), vreinterpret_u64_u16(vd));

#else

    const int mr = qRed(rgbAlpha);

    const int mg = qGreen(rgbAlpha);

    const int mb = qBlue(rgbAlpha);

    blend = qRgba64(qt_div_255(s.red()   * mr + d.red()   * (255 - mr)),

                    qt_div_255(s.green() * mg + d.green() * (255 - mg)),

                    qt_div_255(s.blue()  * mb + d.blue()  * (255 - mb)),

                    s.alpha());

#endif

    return blend;

}

static Q_ALWAYS_INLINE void blend_pixel(QRgba64 &dst, QRgba64 src)

{

    if (src.isOpaque())

        dst = src;

    else if (!src.isTransparent())

        dst = src + multiplyAlpha65535(dst, 65535 - src.alpha());

}

Unexecuted instantiation: qdrawhelper.cpp:blend_pixel(QRgba64&, QRgba64)

Unexecuted instantiation: qimagescale.cpp:blend_pixel(QRgba64&, QRgba64)

Unexecuted instantiation: qpaintengine_raster.cpp:blend_pixel(QRgba64&, QRgba64)

Unexecuted instantiation: qdrawhelper_sse2.cpp:blend_pixel(QRgba64&, QRgba64)

Unexecuted instantiation: qdrawhelper_ssse3.cpp:blend_pixel(QRgba64&, QRgba64)

Unexecuted instantiation: qdrawhelper_sse4.cpp:blend_pixel(QRgba64&, QRgba64)

Unexecuted instantiation: qdrawhelper_avx2.cpp:blend_pixel(QRgba64&, QRgba64)

Unexecuted instantiation: qcompositionfunctions.cpp:blend_pixel(QRgba64&, QRgba64)

Unexecuted instantiation: qcosmeticstroker.cpp:blend_pixel(QRgba64&, QRgba64)

static Q_ALWAYS_INLINE void blend_pixel(QRgba64 &dst, QRgba64 src, const int const_alpha)

{

    if (const_alpha == 255)

        return blend_pixel(dst, src);

    if (!src.isTransparent()) {

        src = multiplyAlpha255(src, const_alpha);

        dst = src + multiplyAlpha65535(dst, 65535 - src.alpha());

    }

}

Unexecuted instantiation: qdrawhelper.cpp:blend_pixel(QRgba64&, QRgba64, int)

Unexecuted instantiation: qimagescale.cpp:blend_pixel(QRgba64&, QRgba64, int)

Unexecuted instantiation: qpaintengine_raster.cpp:blend_pixel(QRgba64&, QRgba64, int)

Unexecuted instantiation: qdrawhelper_sse2.cpp:blend_pixel(QRgba64&, QRgba64, int)

Unexecuted instantiation: qdrawhelper_ssse3.cpp:blend_pixel(QRgba64&, QRgba64, int)

Unexecuted instantiation: qdrawhelper_sse4.cpp:blend_pixel(QRgba64&, QRgba64, int)

Unexecuted instantiation: qdrawhelper_avx2.cpp:blend_pixel(QRgba64&, QRgba64, int)

Unexecuted instantiation: qcompositionfunctions.cpp:blend_pixel(QRgba64&, QRgba64, int)

Unexecuted instantiation: qcosmeticstroker.cpp:blend_pixel(QRgba64&, QRgba64, int)

QT_END_NAMESPACE

#endif // QRGBA64_P_H