The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/opts/SkBitmapProcState_matrix_neon.h

gfx/skia/trunk/src/opts/SkBitmapProcState_matrix_neon.h

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:c11d5341005e
1
2 #include <arm_neon.h>
3
4
5 #define SCALE_NOFILTER_NAME MAKENAME(_nofilter_scale)
6 #define SCALE_FILTER_NAME MAKENAME(_filter_scale)
7 #define AFFINE_NOFILTER_NAME MAKENAME(_nofilter_affine)
8 #define AFFINE_FILTER_NAME MAKENAME(_filter_affine)
9 #define PERSP_NOFILTER_NAME MAKENAME(_nofilter_persp)
10 #define PERSP_FILTER_NAME MAKENAME(_filter_persp)
11
12 #define PACK_FILTER_X_NAME MAKENAME(_pack_filter_x)
13 #define PACK_FILTER_Y_NAME MAKENAME(_pack_filter_y)
14 #define PACK_FILTER_X4_NAME MAKENAME(_pack_filter_x4)
15 #define PACK_FILTER_Y4_NAME MAKENAME(_pack_filter_y4)
16
17 #ifndef PREAMBLE
18 #define PREAMBLE(state)
19 #define PREAMBLE_PARAM_X
20 #define PREAMBLE_PARAM_Y
21 #define PREAMBLE_ARG_X
22 #define PREAMBLE_ARG_Y
23 #endif
24
25 static void SCALE_NOFILTER_NAME(const SkBitmapProcState& s,
26 uint32_t xy[], int count, int x, int y) {
27 SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
28 SkMatrix::kScale_Mask)) == 0);
29
30 PREAMBLE(s);
31
32 // we store y, x, x, x, x, x
33 const unsigned maxX = s.fBitmap->width() - 1;
34 SkFractionalInt fx;
35 {
36 SkPoint pt;
37 s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
38 SkIntToScalar(y) + SK_ScalarHalf, &pt);
39 fx = SkScalarToFractionalInt(pt.fY);
40 const unsigned maxY = s.fBitmap->height() - 1;
41 *xy++ = TILEY_PROCF(SkFractionalIntToFixed(fx), maxY);
42 fx = SkScalarToFractionalInt(pt.fX);
43 }
44
45 if (0 == maxX) {
46 // all of the following X values must be 0
47 memset(xy, 0, count * sizeof(uint16_t));
48 return;
49 }
50
51 const SkFractionalInt dx = s.fInvSxFractionalInt;
52
53 #ifdef CHECK_FOR_DECAL
54 // test if we don't need to apply the tile proc
55 if (can_truncate_to_fixed_for_decal(fx, dx, count, maxX)) {
56 decal_nofilter_scale_neon(xy, SkFractionalIntToFixed(fx),
57 SkFractionalIntToFixed(dx), count);
58 return;
59 }
60 #endif
61
62 if (count >= 8) {
63 SkFractionalInt dx2 = dx+dx;
64 SkFractionalInt dx4 = dx2+dx2;
65 SkFractionalInt dx8 = dx4+dx4;
66
67 // now build fx/fx+dx/fx+2dx/fx+3dx
68 SkFractionalInt fx1, fx2, fx3;
69 int32x4_t lbase, hbase;
70 int16_t *dst16 = (int16_t *)xy;
71
72 fx1 = fx+dx;
73 fx2 = fx1+dx;
74 fx3 = fx2+dx;
75
76 lbase = vdupq_n_s32(SkFractionalIntToFixed(fx));
77 lbase = vsetq_lane_s32(SkFractionalIntToFixed(fx1), lbase, 1);
78 lbase = vsetq_lane_s32(SkFractionalIntToFixed(fx2), lbase, 2);
79 lbase = vsetq_lane_s32(SkFractionalIntToFixed(fx3), lbase, 3);
80 hbase = vaddq_s32(lbase, vdupq_n_s32(SkFractionalIntToFixed(dx4)));
81
82 // store & bump
83 while (count >= 8) {
84
85 int16x8_t fx8;
86
87 fx8 = TILEX_PROCF_NEON8(lbase, hbase, maxX);
88
89 vst1q_s16(dst16, fx8);
90
91 // but preserving base & on to the next
92 lbase = vaddq_s32 (lbase, vdupq_n_s32(SkFractionalIntToFixed(dx8)));
93 hbase = vaddq_s32 (hbase, vdupq_n_s32(SkFractionalIntToFixed(dx8)));
94 dst16 += 8;
95 count -= 8;
96 fx += dx8;
97 };
98 xy = (uint32_t *) dst16;
99 }
100
101 uint16_t* xx = (uint16_t*)xy;
102 for (int i = count; i > 0; --i) {
103 *xx++ = TILEX_PROCF(SkFractionalIntToFixed(fx), maxX);
104 fx += dx;
105 }
106 }
107
108 static void AFFINE_NOFILTER_NAME(const SkBitmapProcState& s,
109 uint32_t xy[], int count, int x, int y) {
110 SkASSERT(s.fInvType & SkMatrix::kAffine_Mask);
111 SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
112 SkMatrix::kScale_Mask |
113 SkMatrix::kAffine_Mask)) == 0);
114
115 PREAMBLE(s);
116 SkPoint srcPt;
117 s.fInvProc(s.fInvMatrix,
118 SkIntToScalar(x) + SK_ScalarHalf,
119 SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
120
121 SkFractionalInt fx = SkScalarToFractionalInt(srcPt.fX);
122 SkFractionalInt fy = SkScalarToFractionalInt(srcPt.fY);
123 SkFractionalInt dx = s.fInvSxFractionalInt;
124 SkFractionalInt dy = s.fInvKyFractionalInt;
125 int maxX = s.fBitmap->width() - 1;
126 int maxY = s.fBitmap->height() - 1;
127
128 if (count >= 8) {
129 SkFractionalInt dx4 = dx * 4;
130 SkFractionalInt dy4 = dy * 4;
131 SkFractionalInt dx8 = dx * 8;
132 SkFractionalInt dy8 = dy * 8;
133
134 int32x4_t xbase, ybase;
135 int32x4_t x2base, y2base;
136 int16_t *dst16 = (int16_t *) xy;
137
138 // now build fx, fx+dx, fx+2dx, fx+3dx
139 xbase = vdupq_n_s32(SkFractionalIntToFixed(fx));
140 xbase = vsetq_lane_s32(SkFractionalIntToFixed(fx+dx), xbase, 1);
141 xbase = vsetq_lane_s32(SkFractionalIntToFixed(fx+dx+dx), xbase, 2);
142 xbase = vsetq_lane_s32(SkFractionalIntToFixed(fx+dx+dx+dx), xbase, 3);
143
144 // same for fy
145 ybase = vdupq_n_s32(SkFractionalIntToFixed(fy));
146 ybase = vsetq_lane_s32(SkFractionalIntToFixed(fy+dy), ybase, 1);
147 ybase = vsetq_lane_s32(SkFractionalIntToFixed(fy+dy+dy), ybase, 2);
148 ybase = vsetq_lane_s32(SkFractionalIntToFixed(fy+dy+dy+dy), ybase, 3);
149
150 x2base = vaddq_s32(xbase, vdupq_n_s32(SkFractionalIntToFixed(dx4)));
151 y2base = vaddq_s32(ybase, vdupq_n_s32(SkFractionalIntToFixed(dy4)));
152
153 // store & bump
154 do {
155 int16x8x2_t hi16;
156
157 hi16.val[0] = TILEX_PROCF_NEON8(xbase, x2base, maxX);
158 hi16.val[1] = TILEY_PROCF_NEON8(ybase, y2base, maxY);
159
160 vst2q_s16(dst16, hi16);
161
162 // moving base and on to the next
163 xbase = vaddq_s32(xbase, vdupq_n_s32(SkFractionalIntToFixed(dx8)));
164 ybase = vaddq_s32(ybase, vdupq_n_s32(SkFractionalIntToFixed(dy8)));
165 x2base = vaddq_s32(x2base, vdupq_n_s32(SkFractionalIntToFixed(dx8)));
166 y2base = vaddq_s32(y2base, vdupq_n_s32(SkFractionalIntToFixed(dy8)));
167
168 dst16 += 16; // 8x32 aka 16x16
169 count -= 8;
170 fx += dx8;
171 fy += dy8;
172 } while (count >= 8);
173 xy = (uint32_t *) dst16;
174 }
175
176 for (int i = count; i > 0; --i) {
177 *xy++ = (TILEY_PROCF(SkFractionalIntToFixed(fy), maxY) << 16) |
178 TILEX_PROCF(SkFractionalIntToFixed(fx), maxX);
179 fx += dx; fy += dy;
180 }
181 }
182
183 static void PERSP_NOFILTER_NAME(const SkBitmapProcState& s,
184 uint32_t* SK_RESTRICT xy,
185 int count, int x, int y) {
186 SkASSERT(s.fInvType & SkMatrix::kPerspective_Mask);
187
188 PREAMBLE(s);
189 // max{X,Y} are int here, but later shown/assumed to fit in 16 bits
190 int maxX = s.fBitmap->width() - 1;
191 int maxY = s.fBitmap->height() - 1;
192
193 SkPerspIter iter(s.fInvMatrix,
194 SkIntToScalar(x) + SK_ScalarHalf,
195 SkIntToScalar(y) + SK_ScalarHalf, count);
196
197 while ((count = iter.next()) != 0) {
198 const SkFixed* SK_RESTRICT srcXY = iter.getXY();
199
200 if (count >= 8) {
201 int32_t *mysrc = (int32_t *) srcXY;
202 int16_t *mydst = (int16_t *) xy;
203 do {
204 int16x8x2_t hi16;
205 int32x4x2_t xy1, xy2;
206
207 xy1 = vld2q_s32(mysrc);
208 xy2 = vld2q_s32(mysrc+8);
209
210 hi16.val[0] = TILEX_PROCF_NEON8(xy1.val[0], xy2.val[0], maxX);
211 hi16.val[1] = TILEY_PROCF_NEON8(xy1.val[1], xy2.val[1], maxY);
212
213 vst2q_s16(mydst, hi16);
214
215 count -= 8; // 8 iterations
216 mysrc += 16; // 16 longs
217 mydst += 16; // 16 shorts, aka 8 longs
218 } while (count >= 8);
219 // get xy and srcXY fixed up
220 srcXY = (const SkFixed *) mysrc;
221 xy = (uint32_t *) mydst;
222 }
223
224 while (--count >= 0) {
225 *xy++ = (TILEY_PROCF(srcXY[1], maxY) << 16) |
226 TILEX_PROCF(srcXY[0], maxX);
227 srcXY += 2;
228 }
229 }
230 }
231
232 static inline uint32_t PACK_FILTER_Y_NAME(SkFixed f, unsigned max,
233 SkFixed one PREAMBLE_PARAM_Y) {
234 unsigned i = TILEY_PROCF(f, max);
235 i = (i << 4) | TILEY_LOW_BITS(f, max);
236 return (i << 14) | (TILEY_PROCF((f + one), max));
237 }
238
239 static inline uint32_t PACK_FILTER_X_NAME(SkFixed f, unsigned max,
240 SkFixed one PREAMBLE_PARAM_X) {
241 unsigned i = TILEX_PROCF(f, max);
242 i = (i << 4) | TILEX_LOW_BITS(f, max);
243 return (i << 14) | (TILEX_PROCF((f + one), max));
244 }
245
246 static inline int32x4_t PACK_FILTER_X4_NAME(int32x4_t f, unsigned max,
247 SkFixed one PREAMBLE_PARAM_X) {
248 int32x4_t ret, res, wide_one;
249
250 // Prepare constants
251 wide_one = vdupq_n_s32(one);
252
253 // Step 1
254 res = TILEX_PROCF_NEON4(f, max);
255
256 // Step 2
257 ret = TILEX_LOW_BITS_NEON4(f, max);
258 ret = vsliq_n_s32(ret, res, 4);
259
260 // Step 3
261 res = TILEX_PROCF_NEON4(f + wide_one, max);
262 ret = vorrq_s32(vshlq_n_s32(ret, 14), res);
263
264 return ret;
265 }
266
267 static inline int32x4_t PACK_FILTER_Y4_NAME(int32x4_t f, unsigned max,
268 SkFixed one PREAMBLE_PARAM_X) {
269 int32x4_t ret, res, wide_one;
270
271 // Prepare constants
272 wide_one = vdupq_n_s32(one);
273
274 // Step 1
275 res = TILEY_PROCF_NEON4(f, max);
276
277 // Step 2
278 ret = TILEY_LOW_BITS_NEON4(f, max);
279 ret = vsliq_n_s32(ret, res, 4);
280
281 // Step 3
282 res = TILEY_PROCF_NEON4(f + wide_one, max);
283 ret = vorrq_s32(vshlq_n_s32(ret, 14), res);
284
285 return ret;
286 }
287
288 static void SCALE_FILTER_NAME(const SkBitmapProcState& s,
289 uint32_t xy[], int count, int x, int y) {
290 SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
291 SkMatrix::kScale_Mask)) == 0);
292 SkASSERT(s.fInvKy == 0);
293
294 PREAMBLE(s);
295
296 const unsigned maxX = s.fBitmap->width() - 1;
297 const SkFixed one = s.fFilterOneX;
298 const SkFractionalInt dx = s.fInvSxFractionalInt;
299 SkFractionalInt fx;
300
301 {
302 SkPoint pt;
303 s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
304 SkIntToScalar(y) + SK_ScalarHalf, &pt);
305 const SkFixed fy = SkScalarToFixed(pt.fY) - (s.fFilterOneY >> 1);
306 const unsigned maxY = s.fBitmap->height() - 1;
307 // compute our two Y values up front
308 *xy++ = PACK_FILTER_Y_NAME(fy, maxY, s.fFilterOneY PREAMBLE_ARG_Y);
309 // now initialize fx
310 fx = SkScalarToFractionalInt(pt.fX) - (SkFixedToFractionalInt(one) >> 1);
311 }
312
313 #ifdef CHECK_FOR_DECAL
314 // test if we don't need to apply the tile proc
315 if (can_truncate_to_fixed_for_decal(fx, dx, count, maxX)) {
316 decal_filter_scale_neon(xy, SkFractionalIntToFixed(fx),
317 SkFractionalIntToFixed(dx), count);
318 return;
319 }
320 #endif
321 {
322
323 if (count >= 4) {
324 int32x4_t wide_fx;
325
326 wide_fx = vdupq_n_s32(SkFractionalIntToFixed(fx));
327 wide_fx = vsetq_lane_s32(SkFractionalIntToFixed(fx+dx), wide_fx, 1);
328 wide_fx = vsetq_lane_s32(SkFractionalIntToFixed(fx+dx+dx), wide_fx, 2);
329 wide_fx = vsetq_lane_s32(SkFractionalIntToFixed(fx+dx+dx+dx), wide_fx, 3);
330
331 while (count >= 4) {
332 int32x4_t res;
333
334 res = PACK_FILTER_X4_NAME(wide_fx, maxX, one PREAMBLE_ARG_X);
335
336 vst1q_u32(xy, vreinterpretq_u32_s32(res));
337
338 wide_fx += vdupq_n_s32(SkFractionalIntToFixed(dx+dx+dx+dx));
339 fx += dx+dx+dx+dx;
340 xy += 4;
341 count -= 4;
342 }
343 }
344
345 while (--count >= 0) {
346 *xy++ = PACK_FILTER_X_NAME(SkFractionalIntToFixed(fx), maxX, one PREAMBLE_ARG_X);
347 fx += dx;
348 }
349
350 }
351 }
352
353 static void AFFINE_FILTER_NAME(const SkBitmapProcState& s,
354 uint32_t xy[], int count, int x, int y) {
355 SkASSERT(s.fInvType & SkMatrix::kAffine_Mask);
356 SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
357 SkMatrix::kScale_Mask |
358 SkMatrix::kAffine_Mask)) == 0);
359
360 PREAMBLE(s);
361 SkPoint srcPt;
362 s.fInvProc(s.fInvMatrix,
363 SkIntToScalar(x) + SK_ScalarHalf,
364 SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
365
366 SkFixed oneX = s.fFilterOneX;
367 SkFixed oneY = s.fFilterOneY;
368 SkFixed fx = SkScalarToFixed(srcPt.fX) - (oneX >> 1);
369 SkFixed fy = SkScalarToFixed(srcPt.fY) - (oneY >> 1);
370 SkFixed dx = s.fInvSx;
371 SkFixed dy = s.fInvKy;
372 unsigned maxX = s.fBitmap->width() - 1;
373 unsigned maxY = s.fBitmap->height() - 1;
374
375 if (count >= 4) {
376 int32x4_t wide_fy, wide_fx;
377
378 wide_fx = vdupq_n_s32(fx);
379 wide_fx = vsetq_lane_s32(fx+dx, wide_fx, 1);
380 wide_fx = vsetq_lane_s32(fx+dx+dx, wide_fx, 2);
381 wide_fx = vsetq_lane_s32(fx+dx+dx+dx, wide_fx, 3);
382
383 wide_fy = vdupq_n_s32(fy);
384 wide_fy = vsetq_lane_s32(fy+dy, wide_fy, 1);
385 wide_fy = vsetq_lane_s32(fy+dy+dy, wide_fy, 2);
386 wide_fy = vsetq_lane_s32(fy+dy+dy+dy, wide_fy, 3);
387
388 while (count >= 4) {
389 int32x4x2_t vxy;
390
391 // do the X side, then the Y side, then interleave them
392 vxy.val[0] = PACK_FILTER_Y4_NAME(wide_fy, maxY, oneY PREAMBLE_ARG_Y);
393 vxy.val[1] = PACK_FILTER_X4_NAME(wide_fx, maxX, oneX PREAMBLE_ARG_X);
394
395 // interleave as YXYXYXYX as part of the storing
396 vst2q_s32((int32_t*)xy, vxy);
397
398 // prepare next iteration
399 wide_fx += vdupq_n_s32(dx+dx+dx+dx);
400 fx += dx + dx + dx + dx;
401 wide_fy += vdupq_n_s32(dy+dy+dy+dy);
402 fy += dy+dy+dy+dy;
403 xy += 8; // 4 x's, 4 y's
404 count -= 4;
405 }
406 }
407
408 while (--count >= 0) {
409 // NB: writing Y/X
410 *xy++ = PACK_FILTER_Y_NAME(fy, maxY, oneY PREAMBLE_ARG_Y);
411 fy += dy;
412 *xy++ = PACK_FILTER_X_NAME(fx, maxX, oneX PREAMBLE_ARG_X);
413 fx += dx;
414 }
415 }
416
417 static void PERSP_FILTER_NAME(const SkBitmapProcState& s,
418 uint32_t* SK_RESTRICT xy, int count,
419 int x, int y) {
420 SkASSERT(s.fInvType & SkMatrix::kPerspective_Mask);
421
422 PREAMBLE(s);
423 unsigned maxX = s.fBitmap->width() - 1;
424 unsigned maxY = s.fBitmap->height() - 1;
425 SkFixed oneX = s.fFilterOneX;
426 SkFixed oneY = s.fFilterOneY;
427
428 SkPerspIter iter(s.fInvMatrix,
429 SkIntToScalar(x) + SK_ScalarHalf,
430 SkIntToScalar(y) + SK_ScalarHalf, count);
431
432 while ((count = iter.next()) != 0) {
433 const SkFixed* SK_RESTRICT srcXY = iter.getXY();
434
435 while (count >= 4) {
436 int32x4_t wide_x, wide_y;
437 int32x4x2_t vxy, vresyx;
438
439 // load src: x-y-x-y-x-y-x-y
440 vxy = vld2q_s32(srcXY);
441
442 // do the X side, then the Y side, then interleave them
443 wide_x = vsubq_s32(vxy.val[0], vdupq_n_s32(oneX>>1));
444 wide_y = vsubq_s32(vxy.val[1], vdupq_n_s32(oneY>>1));
445
446 vresyx.val[0] = PACK_FILTER_Y4_NAME(wide_y, maxY, oneY PREAMBLE_ARG_Y);
447 vresyx.val[1] = PACK_FILTER_X4_NAME(wide_x, maxX, oneX PREAMBLE_ARG_X);
448
449 // store interleaved as y-x-y-x-y-x-y-x (NB != read order)
450 vst2q_s32((int32_t*)xy, vresyx);
451
452 // on to the next iteration
453 srcXY += 2*4;
454 count -= 4;
455 xy += 2*4;
456 }
457
458 while (--count >= 0) {
459 // NB: we read x/y, we write y/x
460 *xy++ = PACK_FILTER_Y_NAME(srcXY[1] - (oneY >> 1), maxY,
461 oneY PREAMBLE_ARG_Y);
462 *xy++ = PACK_FILTER_X_NAME(srcXY[0] - (oneX >> 1), maxX,
463 oneX PREAMBLE_ARG_X);
464 srcXY += 2;
465 }
466 }
467 }
468
469 const SkBitmapProcState::MatrixProc MAKENAME(_Procs)[] = {
470 SCALE_NOFILTER_NAME,
471 SCALE_FILTER_NAME,
472 AFFINE_NOFILTER_NAME,
473 AFFINE_FILTER_NAME,
474 PERSP_NOFILTER_NAME,
475 PERSP_FILTER_NAME
476 };
477
478 #undef TILEX_PROCF_NEON8
479 #undef TILEY_PROCF_NEON8
480 #undef TILEX_PROCF_NEON4
481 #undef TILEY_PROCF_NEON4
482 #undef TILEX_LOW_BITS_NEON4
483 #undef TILEY_LOW_BITS_NEON4
484
485 #undef MAKENAME
486 #undef TILEX_PROCF
487 #undef TILEY_PROCF
488 #ifdef CHECK_FOR_DECAL
489 #undef CHECK_FOR_DECAL
490 #endif
491
492 #undef SCALE_NOFILTER_NAME
493 #undef SCALE_FILTER_NAME
494 #undef AFFINE_NOFILTER_NAME
495 #undef AFFINE_FILTER_NAME
496 #undef PERSP_NOFILTER_NAME
497 #undef PERSP_FILTER_NAME
498
499 #undef PREAMBLE
500 #undef PREAMBLE_PARAM_X
501 #undef PREAMBLE_PARAM_Y
502 #undef PREAMBLE_ARG_X
503 #undef PREAMBLE_ARG_Y
504
505 #undef TILEX_LOW_BITS
506 #undef TILEY_LOW_BITS

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial