Coverage Report

Created: 2025-07-23 08:13

/work/prefix/include/QtGui/qrgba64.h
Line
Count
Source (jump to first uncovered line)
1
/****************************************************************************
2
**
3
** Copyright (C) 2016 The Qt Company Ltd.
4
** Contact: https://www.qt.io/licensing/
5
**
6
** This file is part of the QtGui module of the Qt Toolkit.
7
**
8
** $QT_BEGIN_LICENSE:LGPL$
9
** Commercial License Usage
10
** Licensees holding valid commercial Qt licenses may use this file in
11
** accordance with the commercial license agreement provided with the
12
** Software or, alternatively, in accordance with the terms contained in
13
** a written agreement between you and The Qt Company. For licensing terms
14
** and conditions see https://www.qt.io/terms-conditions. For further
15
** information use the contact form at https://www.qt.io/contact-us.
16
**
17
** GNU Lesser General Public License Usage
18
** Alternatively, this file may be used under the terms of the GNU Lesser
19
** General Public License version 3 as published by the Free Software
20
** Foundation and appearing in the file LICENSE.LGPL3 included in the
21
** packaging of this file. Please review the following information to
22
** ensure the GNU Lesser General Public License version 3 requirements
23
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24
**
25
** GNU General Public License Usage
26
** Alternatively, this file may be used under the terms of the GNU
27
** General Public License version 2.0 or (at your option) the GNU General
28
** Public license version 3 or any later version approved by the KDE Free
29
** Qt Foundation. The licenses are as published by the Free Software
30
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31
** included in the packaging of this file. Please review the following
32
** information to ensure the GNU General Public License requirements will
33
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34
** https://www.gnu.org/licenses/gpl-3.0.html.
35
**
36
** $QT_END_LICENSE$
37
**
38
****************************************************************************/
39
40
#ifndef QRGBA64_H
41
#define QRGBA64_H
42
43
#include <QtGui/qtguiglobal.h>
44
#include <QtCore/qprocessordetection.h>
45
46
QT_BEGIN_NAMESPACE
47
48
class QRgba64 {
49
    quint64 rgba;
50
51
    // Make sure that the representation always has the order: red green blue alpha, independent
52
    // of byte order. This way, vector operations that assume 4 16-bit values see the correct ones.
53
    enum Shifts {
54
#if Q_BYTE_ORDER == Q_BIG_ENDIAN
55
        RedShift = 48,
56
        GreenShift = 32,
57
        BlueShift = 16,
58
        AlphaShift = 0
59
#else // little endian:
60
        RedShift = 0,
61
        GreenShift = 16,
62
        BlueShift = 32,
63
        AlphaShift = 48
64
#endif
65
    };
66
67
    explicit Q_ALWAYS_INLINE Q_DECL_CONSTEXPR QRgba64(quint64 c) : rgba(c) { }
68
public:
69
    QRgba64() = default;
70
71
    Q_DECL_CONSTEXPR static
72
    QRgba64 fromRgba64(quint64 c)
73
    {
74
        return QRgba64(c);
75
    }
76
    Q_DECL_CONSTEXPR static
77
    QRgba64 fromRgba64(quint16 red, quint16 green, quint16 blue, quint16 alpha)
78
    {
79
        return fromRgba64(quint64(red)   << RedShift
80
                        | quint64(green) << GreenShift
81
                        | quint64(blue)  << BlueShift
82
                        | quint64(alpha) << AlphaShift);
83
    }
84
    Q_DECL_RELAXED_CONSTEXPR static QRgba64 fromRgba(quint8 red, quint8 green, quint8 blue, quint8 alpha)
85
    {
86
        QRgba64 rgb64 = fromRgba64(red, green, blue, alpha);
87
        // Expand the range so that 0x00 maps to 0x0000 and 0xff maps to 0xffff.
88
        rgb64.rgba |= rgb64.rgba << 8;
89
        return rgb64;
90
    }
91
    Q_DECL_RELAXED_CONSTEXPR static
92
    QRgba64 fromArgb32(uint rgb)
93
    {
94
        return fromRgba(quint8(rgb >> 16), quint8(rgb >> 8), quint8(rgb), quint8(rgb >> 24));
95
    }
96
97
    Q_DECL_CONSTEXPR bool isOpaque() const
98
    {
99
        return (rgba & alphaMask()) == alphaMask();
100
    }
101
    Q_DECL_CONSTEXPR bool isTransparent() const
102
    {
103
        return (rgba & alphaMask()) == 0;
104
    }
105
106
    Q_DECL_CONSTEXPR quint16 red()   const { return quint16(rgba >> RedShift);   }
107
    Q_DECL_CONSTEXPR quint16 green() const { return quint16(rgba >> GreenShift); }
108
    Q_DECL_CONSTEXPR quint16 blue()  const { return quint16(rgba >> BlueShift);  }
109
    Q_DECL_CONSTEXPR quint16 alpha() const { return quint16(rgba >> AlphaShift); }
110
0
    void setRed(quint16 _red)     { rgba = (rgba & ~(Q_UINT64_C(0xffff) << RedShift))   | (quint64(_red) << RedShift); }
111
0
    void setGreen(quint16 _green) { rgba = (rgba & ~(Q_UINT64_C(0xffff) << GreenShift)) | (quint64(_green) << GreenShift); }
112
0
    void setBlue(quint16 _blue)   { rgba = (rgba & ~(Q_UINT64_C(0xffff) << BlueShift))  | (quint64(_blue) << BlueShift); }
113
    void setAlpha(quint16 _alpha) { rgba = (rgba & ~(Q_UINT64_C(0xffff) << AlphaShift)) | (quint64(_alpha) << AlphaShift); }
114
115
0
    Q_DECL_CONSTEXPR quint8 red8()   const { return div_257(red()); }
116
0
    Q_DECL_CONSTEXPR quint8 green8() const { return div_257(green()); }
117
0
    Q_DECL_CONSTEXPR quint8 blue8()  const { return div_257(blue()); }
118
0
    Q_DECL_CONSTEXPR quint8 alpha8() const { return div_257(alpha()); }
119
    Q_DECL_CONSTEXPR uint toArgb32() const
120
    {
121
#if defined(__cpp_constexpr) && __cpp_constexpr-0 >= 201304
122
        quint64 br = rgba & Q_UINT64_C(0xffff0000ffff);
123
        quint64 ag = (rgba >> 16) & Q_UINT64_C(0xffff0000ffff);
124
        br += Q_UINT64_C(0x8000000080);
125
        ag += Q_UINT64_C(0x8000000080);
126
        br = (br - ((br >> 8) & Q_UINT64_C(0xffff0000ffff))) >> 8;
127
        ag = (ag - ((ag >> 8) & Q_UINT64_C(0xffff0000ffff)));
128
#if Q_BYTE_ORDER == Q_BIG_ENDIAN
129
        return ((br << 24) & 0xff000000)
130
             | ((ag >> 24) & 0xff0000)
131
             | ((br >> 24) & 0xff00)
132
             | ((ag >> 8)  & 0xff);
133
#else
134
        return ((ag >> 16) & 0xff000000)
135
             | ((br << 16) & 0xff0000)
136
             | (ag         & 0xff00)
137
             | ((br >> 32) & 0xff);
138
#endif
139
#else
140
        return uint((alpha8() << 24) | (red8() << 16) | (green8() << 8) | blue8());
141
#endif
142
    }
143
    Q_DECL_CONSTEXPR ushort toRgb16() const
144
    {
145
        return ushort((red() & 0xf800) | ((green() >> 10) << 5) | (blue() >> 11));
146
    }
147
148
    Q_DECL_RELAXED_CONSTEXPR QRgba64 premultiplied() const
149
    {
150
        if (isOpaque())
151
            return *this;
152
        if (isTransparent())
153
            return QRgba64::fromRgba64(0);
154
        const quint64 a = alpha();
155
        quint64 br = (rgba & Q_UINT64_C(0xffff0000ffff)) * a;
156
        quint64 ag = ((rgba >> 16) & Q_UINT64_C(0xffff0000ffff)) * a;
157
        br = (br + ((br >> 16) & Q_UINT64_C(0xffff0000ffff)) + Q_UINT64_C(0x800000008000));
158
        ag = (ag + ((ag >> 16) & Q_UINT64_C(0xffff0000ffff)) + Q_UINT64_C(0x800000008000));
159
#if Q_BYTE_ORDER == Q_BIG_ENDIAN
160
        ag = ag & Q_UINT64_C(0xffff0000ffff0000);
161
        br = (br >> 16) & Q_UINT64_C(0xffff00000000);
162
        return fromRgba64(a | br | ag);
163
#else
164
        br = (br >> 16) & Q_UINT64_C(0xffff0000ffff);
165
        ag = ag & Q_UINT64_C(0xffff0000);
166
        return fromRgba64((a << 48) | br | ag);
167
#endif
168
    }
169
170
    Q_DECL_RELAXED_CONSTEXPR QRgba64 unpremultiplied() const
171
    {
172
#if Q_PROCESSOR_WORDSIZE < 8
173
        return unpremultiplied_32bit();
174
#else
175
        return unpremultiplied_64bit();
176
#endif
177
    }
178
179
    Q_DECL_CONSTEXPR operator quint64() const
180
    {
181
        return rgba;
182
    }
183
184
    QRgba64 operator=(quint64 _rgba)
185
    {
186
        rgba = _rgba;
187
        return *this;
188
    }
189
190
private:
191
    static Q_DECL_CONSTEXPR Q_ALWAYS_INLINE quint64 alphaMask() { return Q_UINT64_C(0xffff) << AlphaShift; }
192
193
0
    static Q_DECL_CONSTEXPR Q_ALWAYS_INLINE quint8 div_257_floor(uint x) { return quint8((x - (x >> 8)) >> 8); }
194
0
    static Q_DECL_CONSTEXPR Q_ALWAYS_INLINE quint8 div_257(quint16 x) { return div_257_floor(x + 128U); }
195
    Q_DECL_RELAXED_CONSTEXPR Q_ALWAYS_INLINE QRgba64 unpremultiplied_32bit() const
196
0
    {
197
0
        if (isOpaque() || isTransparent())
198
0
            return *this;
199
0
        const quint32 a = alpha();
200
0
        const quint16 r = quint16((red()   * 0xffff + a/2) / a);
201
0
        const quint16 g = quint16((green() * 0xffff + a/2) / a);
202
0
        const quint16 b = quint16((blue()  * 0xffff + a/2) / a);
203
0
        return fromRgba64(r, g, b, quint16(a));
204
0
    }
205
    Q_DECL_RELAXED_CONSTEXPR Q_ALWAYS_INLINE QRgba64 unpremultiplied_64bit() const
206
    {
207
        if (isOpaque() || isTransparent())
208
            return *this;
209
        const quint64 a = alpha();
210
        const quint64 fa = (Q_UINT64_C(0xffff00008000) + a/2) / a;
211
        const quint16 r = quint16((red()   * fa + 0x80000000) >> 32);
212
        const quint16 g = quint16((green() * fa + 0x80000000) >> 32);
213
        const quint16 b = quint16((blue()  * fa + 0x80000000) >> 32);
214
        return fromRgba64(r, g, b, quint16(a));
215
    }
216
};
217
218
Q_DECLARE_TYPEINFO(QRgba64, Q_PRIMITIVE_TYPE);
219
220
Q_DECL_CONSTEXPR inline QRgba64 qRgba64(quint16 r, quint16 g, quint16 b, quint16 a)
221
{
222
    return QRgba64::fromRgba64(r, g, b, a);
223
}
224
225
Q_DECL_CONSTEXPR inline QRgba64 qRgba64(quint64 c)
226
0
{
227
0
    return QRgba64::fromRgba64(c);
228
0
}
229
230
Q_DECL_RELAXED_CONSTEXPR inline QRgba64 qPremultiply(QRgba64 c)
231
{
232
    return c.premultiplied();
233
}
234
235
Q_DECL_RELAXED_CONSTEXPR inline QRgba64 qUnpremultiply(QRgba64 c)
236
0
{
237
0
    return c.unpremultiplied();
238
0
}
239
240
inline Q_DECL_CONSTEXPR uint qRed(QRgba64 rgb)
241
0
{ return rgb.red8(); }
242
243
inline Q_DECL_CONSTEXPR uint qGreen(QRgba64 rgb)
244
0
{ return rgb.green8(); }
245
246
inline Q_DECL_CONSTEXPR uint qBlue(QRgba64 rgb)
247
0
{ return rgb.blue8(); }
248
249
inline Q_DECL_CONSTEXPR uint qAlpha(QRgba64 rgb)
250
0
{ return rgb.alpha8(); }
251
252
QT_END_NAMESPACE
253
254
#endif // QRGBA64_H