18#include <QtGui/private/qtguiglobal_p.h>
19#include "QtCore/qmath.h"
20#include "QtGui/qcolor.h"
21#include "QtGui/qpainter.h"
22#include "QtGui/qimage.h"
23#include "QtGui/qrgba64.h"
24#ifndef QT_FT_BEGIN_HEADER
25#define QT_FT_BEGIN_HEADER
26#define QT_FT_END_HEADER
28#include "private/qpixellayout_p.h"
29#include "private/qrasterdefs_p.h"
30#include <private/qsimd_p.h>
37# define Q_DECL_RESTRICT __restrict__
38# if defined(Q_PROCESSOR_X86_32) && defined(Q_CC_GNU) && !defined(Q_CC_CLANG)
39# define Q_DECL_VECTORCALL __attribute__((sseregparm,regparm(3)))
41# define Q_DECL_VECTORCALL
43#elif defined(Q_CC_MSVC)
44# define Q_DECL_RESTRICT __restrict
45# define Q_DECL_VECTORCALL __vectorcall
47# define Q_DECL_RESTRICT
48# define Q_DECL_VECTORCALL
75 int mapWidth,
int mapHeight,
int mapStride);
80 int mapWidth,
int mapHeight,
int mapStride,
81 const QClipData *clip,
bool useGammaCorrection);
86 int mapWidth,
int mapHeight,
int mapStride,
87 const QClipData *clip,
bool useGammaCorrection);
99 const uchar *
src,
int spbl,
int srch,
102 const QRect &clipRect,
109 const QRect &clipRect,
145#ifdef Q_PROCESSOR_X86
265#define GRADIENT_STOPTABLE_SIZE 1024
266#define GRADIENT_STOPTABLE_SIZE_SHIFT 10
268#if QT_CONFIG(raster_64bit) || QT_CONFIG(raster_fp)
351 ipos = ipos < 0 ?
limit + ipos : ipos;
373#if QT_CONFIG(raster_64bit)
383 return (
b *
b) - (4 *
a *
c);
386template <
class RadialFetchFunc,
typename BlendType>
static
392 RadialFetchFunc::memfill(
buffer, RadialFetchFunc::null(),
length);
401 bool affine = !
data->m13 && !
data->m23;
407 rx -=
data->gradient.radial.focal.x;
408 ry -=
data->gradient.radial.focal.y;
415 const qreal b_delta_b = 2 *
b * delta_b;
416 const qreal delta_b_delta_b = 2 * delta_b * delta_b;
419 const qreal delta_bb = delta_b * delta_b;
425 const qreal delta_rxrxryry = delta_rx * delta_rx + delta_ry * delta_ry;
426 const qreal rx_plus_ry = 2*(
rx * delta_rx +
ry * delta_ry);
427 const qreal delta_rx_plus_ry = 2 * delta_rxrxryry;
432 qreal delta_det = (b_delta_b + delta_bb + 4 * op->
radial.
a * (rx_plus_ry + delta_rxrxryry)) * inv_a;
433 const qreal delta_delta_det = (delta_b_delta_b + 4 * op->
radial.
a * delta_rx_plus_ry) * inv_a;
435 RadialFetchFunc::fetch(
buffer,
end, op,
data, det, delta_det, delta_delta_det,
b, delta_b);
442 *
buffer = RadialFetchFunc::null();
444 qreal invRw = 1 / rw;
445 qreal gx =
rx * invRw -
data->gradient.radial.focal.x;
446 qreal gy =
ry * invRw -
data->gradient.radial.focal.y;
450 BlendType
result = RadialFetchFunc::null();
459 if (
data->gradient.radial.focal.radius + op->
radial.
dr *
s >= 0)
460 result = RadialFetchFunc::fetchSingle(
data->gradient,
s);
493 typename Simd::Vect_buffer_f det_vec;
494 typename Simd::Vect_buffer_f delta_det4_vec;
495 typename Simd::Vect_buffer_f b_vec;
497 for (
int i = 0;
i < 4; ++
i) {
499 delta_det4_vec.f[
i] = 4 * delta_det;
503 delta_det += delta_delta_det;
507 const typename Simd::Float32x4 v_delta_delta_det16 = Simd::v_dup(16 * delta_delta_det);
508 const typename Simd::Float32x4 v_delta_delta_det6 = Simd::v_dup(6 * delta_delta_det);
509 const typename Simd::Float32x4 v_delta_b4 = Simd::v_dup(4 * delta_b);
511 const typename Simd::Float32x4 v_r0 = Simd::v_dup(
data->gradient.radial.focal.radius);
512 const typename Simd::Float32x4 v_dr = Simd::v_dup(op->
radial.
dr);
514#if defined(__ARM_NEON__)
516 const typename Simd::Float32x4 v_min = Simd::v_dup(std::numeric_limits<float>::epsilon());
518 const typename Simd::Float32x4 v_min = Simd::v_dup(0.0f);
521 const typename Simd::Float32x4 v_half = Simd::v_dup(0.5f);
530#define FETCH_RADIAL_LOOP_PROLOGUE \
531 while (buffer < end) { \
532 typename Simd::Vect_buffer_i v_buffer_mask; \
533 v_buffer_mask.v = Simd::v_greaterOrEqual(det_vec.v, v_min); \
534 const typename Simd::Float32x4 v_index_local = Simd::v_sub(Simd::v_sqrt(Simd::v_max(v_min, det_vec.v)), b_vec.v); \
535 const typename Simd::Float32x4 v_index = Simd::v_add(Simd::v_mul(v_index_local, v_max), v_half); \
536 v_buffer_mask.v = Simd::v_and(v_buffer_mask.v, Simd::v_greaterOrEqual(Simd::v_add(v_r0, Simd::v_mul(v_dr, v_index_local)), v_min)); \
537 typename Simd::Vect_buffer_i index_vec;
538#define FETCH_RADIAL_LOOP_CLAMP_REPEAT \
539 index_vec.v = Simd::v_and(v_repeat_mask, Simd::v_toInt(v_index));
540#define FETCH_RADIAL_LOOP_CLAMP_REFLECT \
541 const typename Simd::Int32x4 v_index_i = Simd::v_and(v_reflect_mask, Simd::v_toInt(v_index)); \
542 const typename Simd::Int32x4 v_index_i_inv = Simd::v_sub(v_reflect_limit, v_index_i); \
543 index_vec.v = Simd::v_min_16(v_index_i, v_index_i_inv);
544#define FETCH_RADIAL_LOOP_CLAMP_PAD \
545 index_vec.v = Simd::v_toInt(Simd::v_min(v_max, Simd::v_max(v_min, v_index)));
546#define FETCH_RADIAL_LOOP_EPILOGUE \
547 det_vec.v = Simd::v_add(Simd::v_add(det_vec.v, delta_det4_vec.v), v_delta_delta_det6); \
548 delta_det4_vec.v = Simd::v_add(delta_det4_vec.v, v_delta_delta_det16); \
549 b_vec.v = Simd::v_add(b_vec.v, v_delta_b4); \
550 for (int i = 0; i < 4; ++i) \
551 *buffer++ = (extended_mask | v_buffer_mask.i[i]) & data->gradient.colorTable32[index_vec.i[i]]; \
554#define FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP) \
555 FETCH_RADIAL_LOOP_PROLOGUE \
556 FETCH_RADIAL_LOOP_CLAMP \
557 FETCH_RADIAL_LOOP_EPILOGUE
559 switch (
data->gradient.spread) {
576 uint t = (
x & 0xff00ff) *
a + (
y & 0xff00ff) *
b;
577 t = (
t + ((
t >> 8) & 0xff00ff) + 0x800080) >> 8;
580 x = ((
x >> 8) & 0xff00ff) *
a + ((
y >> 8) & 0xff00ff) *
b;
581 x = (
x + ((
x >> 8) & 0xff00ff) + 0x800080);
587#if Q_PROCESSOR_WORDSIZE == 8
593 t &= 0x00ff00ff00ff00ff;
599 t = (
t + ((
t >> 8) & 0xff00ff00ff00ff) + 0x80008000800080) >> 8;
600 t &= 0x00ff00ff00ff00ff;
607 uint t = (
x & 0xff00ff) *
a + (
y & 0xff00ff) *
b;
611 x = ((
x >> 8) & 0xff00ff) *
a + ((
y >> 8) & 0xff00ff) *
b;
619 t = (
t + ((
t >> 8) & 0xff00ff) + 0x800080) >> 8;
622 x = ((
x >> 8) & 0xff00ff) *
a;
623 x = (
x + ((
x >> 8) & 0xff00ff) + 0x800080);
632 if (
src >= 0xff000000)
640 if (const_alpha == 255)
652 vt = _mm_unpacklo_epi8(vt, _mm_setzero_si128());
653 vb = _mm_unpacklo_epi8(vb, _mm_setzero_si128());
654 vt = _mm_mullo_epi16(vt, _mm_set1_epi16(256 - disty));
655 vb = _mm_mullo_epi16(vb, _mm_set1_epi16(disty));
656 __m128i vlr = _mm_add_epi16(vt, vb);
657 vlr = _mm_srli_epi16(vlr, 8);
661 const __m128i vidistx = _mm_shufflelo_epi16(_mm_cvtsi32_si128(256 - distx), _MM_SHUFFLE(0, 0, 0, 0));
662 const __m128i vdistx = _mm_shufflelo_epi16(_mm_cvtsi32_si128(distx), _MM_SHUFFLE(0, 0, 0, 0));
663 const __m128i vmulx = _mm_unpacklo_epi16(vidistx, vdistx);
664 vlr = _mm_unpacklo_epi16(vlr, _mm_srli_si128(vlr, 8));
666 vlr = _mm_madd_epi16(vlr, vmulx);
667 vlr = _mm_srli_epi32(vlr, 8);
668 vlr = _mm_packs_epi32(vlr, vlr);
669 vlr = _mm_packus_epi16(vlr, vlr);
670 return _mm_cvtsi128_si32(vlr);
675 __m128i vt = _mm_unpacklo_epi32(_mm_cvtsi32_si128(tl), _mm_cvtsi32_si128(
tr));
676 __m128i vb = _mm_unpacklo_epi32(_mm_cvtsi32_si128(bl), _mm_cvtsi32_si128(br));
677 return interpolate_4_pixels_sse2(vt, vb, distx, disty);
682 __m128i vt = _mm_loadl_epi64((
const __m128i*)
t);
683 __m128i vb = _mm_loadl_epi64((
const __m128i*)
b);
684 return interpolate_4_pixels_sse2(vt, vb, distx, disty);
689#elif defined(__ARM_NEON__)
690static inline uint interpolate_4_pixels_neon(uint32x2_t vt32, uint32x2_t vb32,
uint distx,
uint disty)
692 uint16x8_t vt16 = vmovl_u8(vreinterpret_u8_u32(vt32));
693 uint16x8_t vb16 = vmovl_u8(vreinterpret_u8_u32(vb32));
694 vt16 = vmulq_n_u16(vt16, 256 - disty);
695 vt16 = vmlaq_n_u16(vt16, vb16, disty);
696 vt16 = vshrq_n_u16(vt16, 8);
697 uint16x4_t vl16 = vget_low_u16(vt16);
698 uint16x4_t vr16 = vget_high_u16(vt16);
699 vl16 = vmul_n_u16(vl16, 256 - distx);
700 vl16 = vmla_n_u16(vl16, vr16, distx);
701 vl16 = vshr_n_u16(vl16, 8);
702 uint8x8_t vr = vmovn_u16(vcombine_u16(vl16, vl16));
703 return vget_lane_u32(vreinterpret_u32_u8(vr), 0);
708 uint32x2_t vt32 = vmov_n_u32(tl);
709 uint32x2_t vb32 = vmov_n_u32(bl);
710 vt32 = vset_lane_u32(
tr, vt32, 1);
711 vb32 = vset_lane_u32(br, vb32, 1);
712 return interpolate_4_pixels_neon(vt32, vb32, distx, disty);
717 uint32x2_t vt32 = vld1_u32(
t);
718 uint32x2_t vb32 = vld1_u32(
b);
719 return interpolate_4_pixels_neon(vt32, vb32, distx, disty);
727 uint idistx = 256 - distx;
728 uint idisty = 256 - disty;
746 (rgba64.
green() * alpha256) >> 8,
747 (rgba64.
blue() * alpha256) >> 8,
748 (rgba64.
alpha() * alpha256) >> 8);
758 __m128i vt = _mm_loadu_si128((
const __m128i*)
t);
760 __m128i vb = _mm_loadu_si128((
const __m128i*)
b);
761 vt = _mm_mulhi_epu16(vt, _mm_set1_epi16(0x10000 - disty));
762 vb = _mm_mulhi_epu16(vb, _mm_set1_epi16(disty));
763 vt = _mm_add_epi16(vt, vb);
766 const __m128i vdistx = _mm_shufflelo_epi16(_mm_cvtsi32_si128(distx), _MM_SHUFFLE(0, 0, 0, 0));
767 const __m128i vidistx = _mm_shufflelo_epi16(_mm_cvtsi32_si128(0x10000 - distx), _MM_SHUFFLE(0, 0, 0, 0));
768 vt = _mm_mulhi_epu16(vt, _mm_unpacklo_epi64(vidistx, vdistx));
769 vt = _mm_add_epi16(vt, _mm_srli_si128(vt, 8));
771#ifdef Q_PROCESSOR_X86_64
775 _mm_storel_epi64((__m128i*)&
out, vt);
779#elif defined(__ARM_NEON__)
782 uint64x1x2_t vt = vld2_u64(
reinterpret_cast<const uint64_t *
>(
t));
784 uint64x1x2_t vb = vld2_u64(
reinterpret_cast<const uint64_t *
>(
b));
785 uint32x4_t vt0 = vmull_n_u16(vreinterpret_u16_u64(vt.val[0]), 0x10000 - disty);
786 uint32x4_t vt1 = vmull_n_u16(vreinterpret_u16_u64(vt.val[1]), 0x10000 - disty);
787 vt0 = vmlal_n_u16(vt0, vreinterpret_u16_u64(vb.val[0]), disty);
788 vt1 = vmlal_n_u16(vt1, vreinterpret_u16_u64(vb.val[1]), disty);
789 vt.val[0] = vreinterpret_u64_u16(vshrn_n_u32(vt0, 16));
790 vt.val[1] = vreinterpret_u64_u16(vshrn_n_u32(vt1, 16));
793 uint32x4_t vt0 = vmull_n_u16(vreinterpret_u16_u64(vt.val[0]), 0x10000 - distx);
794 vt0 = vmlal_n_u16(vt0, vreinterpret_u16_u64(vt.val[1]), distx);
795 vt.val[0] = vreinterpret_u64_u16(vshrn_n_u32(vt0, 16));
798 vst1_u64(
reinterpret_cast<uint64_t *
>(&
out), vt.val[0]);
804 const uint dx = distx>>8;
805 const uint dy = disty>>8;
806 const uint idx = 256 - dx;
807 const uint idy = 256 - dy;
814#if QT_CONFIG(raster_fp)
822 x = multiplyAlpha_rgba32f(
x, alpha1);
823 y = multiplyAlpha_rgba32f(
y, alpha2);
827static inline __m128
Q_DECL_VECTORCALL interpolate_rgba32f(__m128
x, __m128 alpha1, __m128
y, __m128 alpha2)
829 return _mm_add_ps(_mm_mul_ps(
x, alpha1), _mm_mul_ps(
y, alpha2));
835 constexpr float f = 1.0f / 65536.0f;
836 const float dx = distx *
f;
837 const float dy = disty *
f;
838 const float idx = 1.0f - dx;
839 const float idy = 1.0f - dy;
841 const __m128 vtl = _mm_load_ps((
const float *)&
t[0]);
842 const __m128 vtr = _mm_load_ps((
const float *)&
t[1]);
843 const __m128
vbl = _mm_load_ps((
const float *)&
b[0]);
844 const __m128 vbr = _mm_load_ps((
const float *)&
b[1]);
846 const __m128 vdx = _mm_set1_ps(dx);
847 const __m128 vidx = _mm_set1_ps(idx);
848 __m128 vt = interpolate_rgba32f(vtl, vidx, vtr, vdx);
849 __m128 vb = interpolate_rgba32f(
vbl, vidx, vbr, vdx);
850 const __m128 vdy = _mm_set1_ps(dy);
851 const __m128 vidy = _mm_set1_ps(idy);
852 vt = interpolate_rgba32f(vt, vidy, vb, vdy);
854 _mm_store_ps((
float*)&
res, vt);
859 xtop = interpolate_rgba32f(xtop, idy, xbot, dy);
867 uint t = (((
x & 0x07e0)*
a) >> 8) & 0x07e0;
868 t |= (((
x & 0xf81f)*(
a>>2)) >> 6) & 0xf81f;
873 uint t = (((
x & 0xf81f07e0) >> 5)*
a) & 0xf81f07e0;
874 t |= (((
x & 0x07e0f81f)*
a) >> 5) & 0x07e0f81f;
879static constexpr inline int qt_div_255(
int x) {
return (
x + (
x>>8) + 0x80) >> 8; }
890 switch (
count & 0x07)
899 case 1: *dest++ =
color;
934template <
class T>
static
938 char *
d =
reinterpret_cast<char*
>(dest +
x) +
y *
stride;
943 dest =
reinterpret_cast<T*
>(
d);
952 return (((
c) >> 3) & 0x001f)
953 | (((
c) >> 5) & 0x07e0)
954 | (((
c) >> 8) & 0xf800);
960 | ((((
c) << 3) & 0xf8) | (((
c) >> 2) & 0x7))
961 | ((((
c) << 5) & 0xfc00) | (((
c) >> 1) & 0x300))
962 | ((((
c) << 8) & 0xf80000) | (((
c) << 3) & 0x70000));
966 { 0x1, 0xc0, 0x30, 0xf0, 0xc, 0xcc, 0x3c, 0xfc,
967 0x3, 0xc3, 0x33, 0xf3, 0xf, 0xcf, 0x3f, 0xff},
968 { 0x80, 0x40, 0xb0, 0x70, 0x8c, 0x4c, 0xbc, 0x7c,
969 0x83, 0x43, 0xb3, 0x73, 0x8f, 0x4f, 0xbf, 0x7f},
970 { 0x20, 0xe0, 0x10, 0xd0, 0x2c, 0xec, 0x1c, 0xdc,
971 0x23, 0xe3, 0x13, 0xd3, 0x2f, 0xef, 0x1f, 0xdf},
972 { 0xa0, 0x60, 0x90, 0x50, 0xac, 0x6c, 0x9c, 0x5c,
973 0xa3, 0x63, 0x93, 0x53, 0xaf, 0x6f, 0x9f, 0x5f},
974 { 0x8, 0xc8, 0x38, 0xf8, 0x4, 0xc4, 0x34, 0xf4,
975 0xb, 0xcb, 0x3b, 0xfb, 0x7, 0xc7, 0x37, 0xf7},
976 { 0x88, 0x48, 0xb8, 0x78, 0x84, 0x44, 0xb4, 0x74,
977 0x8b, 0x4b, 0xbb, 0x7b, 0x87, 0x47, 0xb7, 0x77},
978 { 0x28, 0xe8, 0x18, 0xd8, 0x24, 0xe4, 0x14, 0xd4,
979 0x2b, 0xeb, 0x1b, 0xdb, 0x27, 0xe7, 0x17, 0xd7},
980 { 0xa8, 0x68, 0x98, 0x58, 0xa4, 0x64, 0x94, 0x54,
981 0xab, 0x6b, 0x9b, 0x5b, 0xa7, 0x67, 0x97, 0x57},
982 { 0x2, 0xc2, 0x32, 0xf2, 0xe, 0xce, 0x3e, 0xfe,
983 0x1, 0xc1, 0x31, 0xf1, 0xd, 0xcd, 0x3d, 0xfd},
984 { 0x82, 0x42, 0xb2, 0x72, 0x8e, 0x4e, 0xbe, 0x7e,
985 0x81, 0x41, 0xb1, 0x71, 0x8d, 0x4d, 0xbd, 0x7d},
986 { 0x22, 0xe2, 0x12, 0xd2, 0x2e, 0xee, 0x1e, 0xde,
987 0x21, 0xe1, 0x11, 0xd1, 0x2d, 0xed, 0x1d, 0xdd},
988 { 0xa2, 0x62, 0x92, 0x52, 0xae, 0x6e, 0x9e, 0x5e,
989 0xa1, 0x61, 0x91, 0x51, 0xad, 0x6d, 0x9d, 0x5d},
990 { 0xa, 0xca, 0x3a, 0xfa, 0x6, 0xc6, 0x36, 0xf6,
991 0x9, 0xc9, 0x39, 0xf9, 0x5, 0xc5, 0x35, 0xf5},
992 { 0x8a, 0x4a, 0xba, 0x7a, 0x86, 0x46, 0xb6, 0x76,
993 0x89, 0x49, 0xb9, 0x79, 0x85, 0x45, 0xb5, 0x75},
994 { 0x2a, 0xea, 0x1a, 0xda, 0x26, 0xe6, 0x16, 0xd6,
995 0x29, 0xe9, 0x19, 0xd9, 0x25, 0xe5, 0x15, 0xd5},
996 { 0xaa, 0x6a, 0x9a, 0x5a, 0xa6, 0x66, 0x96, 0x56,
997 0xa9, 0x69, 0x99, 0x59, 0xa5, 0x65, 0x95, 0x55}
1000#define ARGB_COMBINE_ALPHA(argb, alpha) \
1001 ((((argb >> 24) * alpha) >> 8) << 24) | (argb & 0x00ffffff)
1004#if Q_PROCESSOR_WORDSIZE == 8
1005#define AMIX(mask) (qMin(((quint64(s)&mask) + (quint64(d)&mask)), quint64(mask)))
1006#define MIX(mask) (qMin(((quint64(s)&mask) + (quint64(d)&mask)), quint64(mask)))
1009#define AMIX(mask) quint32(qMin(((quint64(s)&mask) + (quint64(d)&mask)), quint64(mask)))
1010#define MIX(mask) (qMin(((quint32(s)&mask) + (quint32(d)&mask)), quint32(mask)))
The QColor class provides colors based on RGB, HSV or CMYK values.
Spread
Specifies how the area outside the gradient area should be filled.
Format
The following image formats are available in Qt.
CompositionMode
Defines the modes supported for digital image compositing.
static void memfill(uint *buffer, uint fill, int length)
static void fetch(uint *buffer, uint *end, const Operator *op, const QSpanData *data, qreal det, qreal delta_det, qreal delta_delta_det, qreal b, qreal delta_b)
static uint fetchSingle(const QGradientData &gradient, qreal v)
The QRasterPaintEngine class enables hardware acceleration of painting operations in Qt for Embedded ...
\inmodule QtCore\reentrant
\inmodule QtCore\reentrant
constexpr quint16 red() const
constexpr quint16 alpha() const
constexpr quint16 green() const
constexpr quint16 blue() const
static constexpr QRgba64 fromRgba64(quint64 c)
Combined button and popup list for selecting options.
DBusConnection const char DBusError DBusBusType DBusError return DBusConnection DBusHandleMessageFunction void DBusFreeFunction return DBusConnection return DBusConnection return const char DBusError return DBusConnection DBusMessage dbus_uint32_t return DBusConnection dbus_bool_t DBusConnection DBusAddWatchFunction DBusRemoveWatchFunction DBusWatchToggledFunction void DBusFreeFunction return DBusConnection DBusDispatchStatusFunction void DBusFreeFunction DBusTimeout return DBusTimeout return DBusWatch return DBusWatch unsigned int return DBusError const DBusError return const DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessage return DBusMessageIter int const void return DBusMessageIter DBusMessageIter return DBusMessageIter void DBusMessageIter void int return DBusMessage DBusMessageIter return DBusMessageIter return DBusMessageIter DBusMessageIter const char const char const char const char return DBusMessage return DBusMessage const char return DBusMessage dbus_bool_t return DBusMessage dbus_uint32_t return DBusMessage void
void qt_memfill24(quint24 *dest, quint24 value, qsizetype count)
void(QT_FASTCALL * CompositionFunction64)(QRgba64 *Q_DECL_RESTRICT dest, const QRgba64 *Q_DECL_RESTRICT src, int length, uint const_alpha)
void(* RectFillFunc)(QRasterBuffer *rasterBuffer, int x, int y, int width, int height, const QRgba64 &color)
const QRgba64 *(QT_FASTCALL * SourceFetchProc64)(QRgba64 *buffer, const Operator *o, const QSpanData *data, int y, int x, int length)
DrawHelper qDrawHelper[QImage::NImageFormats]
static constexpr uint qt_div_65535(uint x)
void qt_memfill(T *dest, T value, qsizetype count)
uint comp_func_Plus_one_pixel_const_alpha(uint d, const uint s, const uint const_alpha, const uint one_minus_const_alpha)
#define FETCH_RADIAL_LOOP_CLAMP_PAD
void(QT_FASTCALL * CompositionFunctionSolid)(uint *dest, int length, uint color, uint const_alpha)
void(QT_FASTCALL * CompositionFunction)(uint *Q_DECL_RESTRICT dest, const uint *Q_DECL_RESTRICT src, int length, uint const_alpha)
#define FETCH_RADIAL_LOOP_CLAMP_REPEAT
const QRgbaFloat32 *(QT_FASTCALL * SourceFetchProcFP)(QRgbaFloat32 *buffer, const Operator *o, const QSpanData *data, int y, int x, int length)
static constexpr bool hasFastInterpolate4()
static constexpr int BufferSize
QRgba64 *(QT_FASTCALL * DestFetchProc64)(QRgba64 *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
static void qt_rectfill(T *dest, T value, int x, int y, int width, int height, qsizetype stride)
const uint *(QT_FASTCALL * SourceFetchProc)(uint *buffer, const Operator *o, const QSpanData *data, int y, int x, int length)
void(* SrcOverBlendFunc)(uchar *destPixels, int dbpl, const uchar *src, int spbl, int w, int h, int const_alpha)
void(QT_FASTCALL * DestStoreProcFP)(QRasterBuffer *rasterBuffer, int x, int y, const QRgbaFloat32 *buffer, int length)
static constexpr uint qt_div_257(uint x)
static uint INTERPOLATE_PIXEL_256(uint x, uint a, uint y, uint b)
void qt_memfill16(quint16 *dest, quint16 value, qsizetype count)
static qreal qRadialDeterminant(qreal a, qreal b, qreal c)
static constexpr uint qt_div_257_floor(uint x)
ushort qConvertRgb32To16(uint c)
static void blend_pixel(quint32 &dst, const quint32 src)
static constexpr int qt_div_255(int x)
static uint INTERPOLATE_PIXEL_255(uint x, uint a, uint y, uint b)
#define FETCH_RADIAL_LOOP_CLAMP_REFLECT
static uint interpolate_4_pixels(uint tl, uint tr, uint bl, uint br, uint distx, uint disty)
void(QT_FASTCALL * DestStoreProc)(QRasterBuffer *rasterBuffer, int x, int y, const uint *buffer, int length)
SrcOverTransformFunc qTransformFunctions[QImage::NImageFormats][QImage::NImageFormats]
QT_FT_SpanFunc ProcessSpans
QRgbaFloat< float > QRgbaFloat32
void(* BitmapBlitFunc)(QRasterBuffer *rasterBuffer, int x, int y, const QRgba64 &color, const uchar *bitmap, int mapWidth, int mapHeight, int mapStride)
static QRgba64 interpolate_4_pixels_rgb64(const QRgba64 t[], const QRgba64 b[], uint distx, uint disty)
#define FETCH_RADIAL_LOOP(FETCH_RADIAL_LOOP_CLAMP)
static uint qt_gradient_pixel(const QGradientData *data, qreal pos)
void qt_memfill32(quint32 *dest, quint32 value, qsizetype count)
SrcOverBlendFunc qBlendFunctions[QImage::NImageFormats][QImage::NImageFormats]
void(QT_FASTCALL * CompositionFunctionFP)(QRgbaFloat32 *Q_DECL_RESTRICT dest, const QRgbaFloat32 *Q_DECL_RESTRICT src, int length, uint const_alpha)
void(* AlphamapBlitFunc)(QRasterBuffer *rasterBuffer, int x, int y, const QRgba64 &color, const uchar *bitmap, int mapWidth, int mapHeight, int mapStride, const QClipData *clip, bool useGammaCorrection)
static uint BYTE_MUL(uint x, uint a)
void(QT_FASTCALL * CompositionFunctionSolid64)(QRgba64 *dest, int length, QRgba64 color, uint const_alpha)
static QRgba64 interpolate256(QRgba64 x, uint alpha1, QRgba64 y, uint alpha2)
QRgbaFloat32 *(QT_FASTCALL * DestFetchProcFP)(QRgbaFloat32 *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
static const BlendType *QT_FASTCALL qt_fetch_radial_gradient_template(BlendType *buffer, const Operator *op, const QSpanData *data, int y, int x, int length)
static QRgba64 multiplyAlpha256(QRgba64 rgba64, uint alpha256)
uint comp_func_Plus_one_pixel(uint d, const uint s)
#define GRADIENT_STOPTABLE_SIZE_SHIFT
static uint BYTE_MUL_RGB16_32(uint x, uint a)
static uint qt_gradient_clamp(const QGradientData *data, int ipos)
uint *(QT_FASTCALL * DestFetchProc)(uint *buffer, QRasterBuffer *rasterBuffer, int x, int y, int length)
void(QT_FASTCALL * CompositionFunctionSolidFP)(QRgbaFloat32 *dest, int length, QRgbaFloat32 color, uint const_alpha)
void(* AlphaRGBBlitFunc)(QRasterBuffer *rasterBuffer, int x, int y, const QRgba64 &color, const uint *rgbmask, int mapWidth, int mapHeight, int mapStride, const QClipData *clip, bool useGammaCorrection)
#define GRADIENT_STOPTABLE_SIZE
void qBlendGradient(int count, const QT_FT_Span *spans, void *userData)
void(QT_FASTCALL * DestStoreProc64)(QRasterBuffer *rasterBuffer, int x, int y, const QRgba64 *buffer, int length)
const uint qt_bayer_matrix[16][16]
QRgb qConvertRgb16To32(uint c)
void(* SrcOverScaleFunc)(uchar *destPixels, int dbpl, const uchar *src, int spbl, int srch, const QRectF &targetRect, const QRectF &sourceRect, const QRect &clipRect, int const_alpha)
void qt_memfill_template(T *dest, T color, qsizetype count)
void qBlendTexture(int count, const QT_FT_Span *spans, void *userData)
SrcOverScaleFunc qScaleFunctions[QImage::NImageFormats][QImage::NImageFormats]
void qt_memfill64(quint64 *dest, quint64 value, qsizetype count)
void(* SrcOverTransformFunc)(uchar *destPixels, int dbpl, const uchar *src, int spbl, const QRectF &targetRect, const QRectF &sourceRect, const QRect &clipRect, const QTransform &targetRectTransform, int const_alpha)
static uint BYTE_MUL_RGB16(uint x, uint a)
#define Q_DECL_VECTORCALL
EGLOutputLayerEXT EGLint EGLAttrib value
[5]
bool qFuzzyIsNull(qfloat16 f) noexcept
qfloat16 qSqrt(qfloat16 f)
constexpr const T & qMax(const T &a, const T &b)
GLboolean GLboolean GLboolean b
GLsizei const GLfloat * v
[13]
GLint GLint GLint GLint GLint x
[0]
GLfloat GLfloat GLfloat w
[0]
GLint GLsizei GLsizei height
GLboolean GLboolean GLboolean GLboolean a
[7]
GLuint GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat s1
GLenum GLuint GLenum GLsizei length
GLenum GLenum GLsizei count
GLint GLsizei GLsizei GLenum GLenum GLsizei void * data
const void GLsizei GLsizei stride
GLfloat GLfloat GLfloat GLfloat h
GLuint GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat s0
GLsizei GLfixed GLfixed GLfixed GLfixed const GLubyte * bitmap
GLfloat GLfloat GLfloat alpha
void(* QT_FT_SpanFunc)(int count, const QT_FT_Span *spans, void *worker)
QT_BEGIN_NAMESPACE typedef unsigned int QRgb
constexpr int qAlpha(QRgb rgb)
unsigned long long quint64
QTextStream out(stdout)
[7]
AlphaRGBBlitFunc alphaRGBBlit
AlphamapBlitFunc alphamapBlit
BitmapBlitFunc bitmapBlit
LinearGradientValues linear
CompositionFunction64 func64
DestStoreProcFP destStoreFP
CompositionFunctionSolidFP funcSolidFP
CompositionFunctionSolid funcSolid
DestStoreProc64 destStore64
SourceFetchProcFP srcFetchFP
SourceFetchProc64 srcFetch64
QPainter::CompositionMode mode
CompositionFunctionFP funcFP
DestFetchProcFP destFetchFP
DestFetchProc64 destFetch64
RadialGradientValues radial
CompositionFunctionSolid64 funcSolid64
struct QConicalGradientData::@215 center
QRadialGradientData radial
const QRgb * colorTable32
QLinearGradientData linear
QConicalGradientData conical
struct QLinearGradientData::@212 end
struct QLinearGradientData::@211 origin
struct QRadialGradientData::@213 center
struct QRadialGradientData::@214 focal
AlphaRGBBlitFunc alphaRGBBlit
QRasterBuffer * rasterBuffer
void initTexture(const QImage *image, int alpha, QTextureData::Type=QTextureData::Plain, const QRect &sourceRect=QRect())
void setup(const QBrush &brush, int alpha, QPainter::CompositionMode compositionMode, bool isCosmetic)
BitmapBlitFunc bitmapBlit
std::shared_ptr< const void > cachedGradient
enum QSpanData::Type type
ProcessSpans unclipped_blend
void init(QRasterBuffer *rb, const QRasterPaintEngine *pe)
AlphamapBlitFunc alphamapBlit
void setupMatrix(const QTransform &matrix, int bilinear)
const uchar * scanLine(int y) const
const QList< QRgb > * colorTable