1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef Sk4px_DEFINED
#define Sk4px_DEFINED
#include "SkNx.h"
#include "SkColor.h"
#include "SkColorPriv.h"
// This file may be included multiple times by .cpp files with different flags, leading
// to different definitions. Usually that doesn't matter because it's all inlined, but
// in Debug modes the compilers may not inline everything. So wrap everything in an
// anonymous namespace to give each includer their own silo of this code (or the linker
// will probably pick one randomly for us, which is rarely correct).
namespace {
// 1, 2 or 4 SkPMColors, generally vectorized.
class Sk4px : public Sk16b {
public:
static Sk4px DupAlpha(SkAlpha a) { return Sk16b(a); } // a -> aaaa aaaa aaaa aaaa
static Sk4px DupPMColor(SkPMColor c); // argb -> argb argb argb argb
Sk4px(const Sk16b& v) : INHERITED(v) {}
Sk4px alphas() const; // ARGB argb XYZW xyzw -> AAAA aaaa XXXX xxxx
// Mask away color or alpha lanes.
Sk4px zeroColors() const; // ARGB argb XYZW xyzw -> A000 a000 X000 x000
Sk4px zeroAlphas() const; // ARGB argb XYZW xyzw -> 0RGB 0rgb 0YZW 0yzw
Sk4px inv() const { return Sk16b(255) - *this; }
// When loading or storing fewer than 4 SkPMColors, we use the low lanes.
static Sk4px Load4(const SkPMColor[4]); // PMColor[4] -> ARGB argb XYZW xyzw
static Sk4px Load2(const SkPMColor[2]); // PMColor[2] -> ARGB argb ???? ????
static Sk4px Load1(const SkPMColor[1]); // PMColor[1] -> ARGB ???? ???? ????
// Ditto for Alphas... Load2Alphas fills the low two lanes of Sk4px.
static Sk4px Load4Alphas(const SkAlpha[4]); // AaXx -> AAAA aaaa XXXX xxxx
static Sk4px Load2Alphas(const SkAlpha[2]); // Aa -> AAAA aaaa ???? ????
void store4(SkPMColor[4]) const;
void store2(SkPMColor[2]) const;
void store1(SkPMColor[1]) const;
// Same as above for 565.
static Sk4px Load4(const SkPMColor16 src[4]);
static Sk4px Load2(const SkPMColor16 src[2]);
static Sk4px Load1(const SkPMColor16 src[1]);
void store4(SkPMColor16 dst[4]) const;
void store2(SkPMColor16 dst[2]) const;
void store1(SkPMColor16 dst[1]) const;
// 1, 2, or 4 SkPMColors with 16-bit components.
// This is most useful as the result of a multiply, e.g. from mulWiden().
class Wide : public Sk16h {
public:
Wide(const Sk16h& v) : Sk16h(v) {}
// Pack the top byte of each component back down into 4 SkPMColors.
Sk4px addNarrowHi(const Sk16h&) const;
// Rounds, i.e. (x+127) / 255.
Sk4px div255() const {
// Calculated as ((x+128) + ((x+128)>>8)) >> 8.
auto v = *this + Sk16h(128);
return v.addNarrowHi(v >> 8);
}
// These just keep the types as Wide so the user doesn't have to keep casting.
Wide operator * (const Wide& o) const { return INHERITED::operator*(o); }
Wide operator + (const Wide& o) const { return INHERITED::operator+(o); }
Wide operator - (const Wide& o) const { return INHERITED::operator-(o); }
Wide operator >> (int bits) const { return INHERITED::operator>>(bits); }
Wide operator << (int bits) const { return INHERITED::operator<<(bits); }
static Wide Min(const Wide& a, const Wide& b) { return INHERITED::Min(a,b); }
Wide thenElse(const Wide& t, const Wide& e) const { return INHERITED::thenElse(t,e); }
private:
typedef Sk16h INHERITED;
};
Wide widenLo() const; // ARGB -> 0A 0R 0G 0B
Wide widenHi() const; // ARGB -> A0 R0 G0 B0
Wide widenLoHi() const; // ARGB -> AA RR GG BB
Wide mulWiden(const Sk16b&) const; // 8-bit x 8-bit -> 16-bit components.
// The only 8-bit multiply we use is 8-bit x 8-bit -> 16-bit. Might as well make it pithy.
Wide operator * (const Sk4px& o) const { return this->mulWiden(o); }
// These just keep the types as Sk4px so the user doesn't have to keep casting.
Sk4px operator + (const Sk4px& o) const { return INHERITED::operator+(o); }
Sk4px operator - (const Sk4px& o) const { return INHERITED::operator-(o); }
Sk4px operator < (const Sk4px& o) const { return INHERITED::operator<(o); }
Sk4px thenElse(const Sk4px& t, const Sk4px& e) const { return INHERITED::thenElse(t,e); }
// Generally faster than (*this * o).div255().
// May be incorrect by +-1, but is always exactly correct when *this or o is 0 or 255.
Sk4px approxMulDiv255(const Sk16b& o) const {
// (x*y + x) / 256 meets these criteria. (As of course does (x*y + y) / 256 by symmetry.)
return this->widenLo().addNarrowHi(*this * o);
}
// A generic driver that maps fn over a src array into a dst array.
// fn should take an Sk4px (4 src pixels) and return an Sk4px (4 dst pixels).
template <typename Fn, typename Dst>
static void MapSrc(int n, Dst* dst, const SkPMColor* src, const Fn& fn) {
SkASSERT(dst);
SkASSERT(src);
// This looks a bit odd, but it helps loop-invariant hoisting across different calls to fn.
// Basically, we need to make sure we keep things inside a single loop.
while (n > 0) {
if (n >= 8) {
Sk4px dst0 = fn(Load4(src+0)),
dst4 = fn(Load4(src+4));
dst0.store4(dst+0);
dst4.store4(dst+4);
dst += 8; src += 8; n -= 8;
continue; // Keep our stride at 8 pixels as long as possible.
}
SkASSERT(n <= 7);
if (n >= 4) {
fn(Load4(src)).store4(dst);
dst += 4; src += 4; n -= 4;
}
if (n >= 2) {
fn(Load2(src)).store2(dst);
dst += 2; src += 2; n -= 2;
}
if (n >= 1) {
fn(Load1(src)).store1(dst);
}
break;
}
}
// As above, but with dst4' = fn(dst4, src4).
template <typename Fn, typename Dst>
static void MapDstSrc(int n, Dst* dst, const SkPMColor* src, const Fn& fn) {
SkASSERT(dst);
SkASSERT(src);
while (n > 0) {
if (n >= 8) {
Sk4px dst0 = fn(Load4(dst+0), Load4(src+0)),
dst4 = fn(Load4(dst+4), Load4(src+4));
dst0.store4(dst+0);
dst4.store4(dst+4);
dst += 8; src += 8; n -= 8;
continue; // Keep our stride at 8 pixels as long as possible.
}
SkASSERT(n <= 7);
if (n >= 4) {
fn(Load4(dst), Load4(src)).store4(dst);
dst += 4; src += 4; n -= 4;
}
if (n >= 2) {
fn(Load2(dst), Load2(src)).store2(dst);
dst += 2; src += 2; n -= 2;
}
if (n >= 1) {
fn(Load1(dst), Load1(src)).store1(dst);
}
break;
}
}
// As above, but with dst4' = fn(dst4, alpha4).
template <typename Fn, typename Dst>
static void MapDstAlpha(int n, Dst* dst, const SkAlpha* a, const Fn& fn) {
SkASSERT(dst);
SkASSERT(a);
while (n > 0) {
if (n >= 8) {
Sk4px dst0 = fn(Load4(dst+0), Load4Alphas(a+0)),
dst4 = fn(Load4(dst+4), Load4Alphas(a+4));
dst0.store4(dst+0);
dst4.store4(dst+4);
dst += 8; a += 8; n -= 8;
continue; // Keep our stride at 8 pixels as long as possible.
}
SkASSERT(n <= 7);
if (n >= 4) {
fn(Load4(dst), Load4Alphas(a)).store4(dst);
dst += 4; a += 4; n -= 4;
}
if (n >= 2) {
fn(Load2(dst), Load2Alphas(a)).store2(dst);
dst += 2; a += 2; n -= 2;
}
if (n >= 1) {
fn(Load1(dst), DupAlpha(*a)).store1(dst);
}
break;
}
}
// As above, but with dst4' = fn(dst4, src4, alpha4).
template <typename Fn, typename Dst>
static void MapDstSrcAlpha(int n, Dst* dst, const SkPMColor* src, const SkAlpha* a,
const Fn& fn) {
SkASSERT(dst);
SkASSERT(src);
SkASSERT(a);
while (n > 0) {
if (n >= 8) {
Sk4px dst0 = fn(Load4(dst+0), Load4(src+0), Load4Alphas(a+0)),
dst4 = fn(Load4(dst+4), Load4(src+4), Load4Alphas(a+4));
dst0.store4(dst+0);
dst4.store4(dst+4);
dst += 8; src += 8; a += 8; n -= 8;
continue; // Keep our stride at 8 pixels as long as possible.
}
SkASSERT(n <= 7);
if (n >= 4) {
fn(Load4(dst), Load4(src), Load4Alphas(a)).store4(dst);
dst += 4; src += 4; a += 4; n -= 4;
}
if (n >= 2) {
fn(Load2(dst), Load2(src), Load2Alphas(a)).store2(dst);
dst += 2; src += 2; a += 2; n -= 2;
}
if (n >= 1) {
fn(Load1(dst), Load1(src), DupAlpha(*a)).store1(dst);
}
break;
}
}
private:
typedef Sk16b INHERITED;
};
} // namespace
#ifdef SKNX_NO_SIMD
#include "../opts/Sk4px_none.h"
#else
#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
#include "../opts/Sk4px_SSE2.h"
#elif defined(SK_ARM_HAS_NEON)
#include "../opts/Sk4px_NEON.h"
#else
#include "../opts/Sk4px_none.h"
#endif
#endif
#endif//Sk4px_DEFINED
|
