1 /* NEON optimized code (C) COPYRIGHT 2009 Motorola
2 *
3 * Use of this source code is governed by a BSD-style license that can be
4 * found in the LICENSE file.
5 */
6
7 /*
8 * Modifications done in-house at Motorola
9 *
10 * this is a clone of SkBitmapProcState_matrix.h
11 * and has been tuned to work with the NEON unit.
12 *
13 * Still going back and forth between whether this approach
14 * (clone the entire SkBitmapProcState_matrix.h file or
15 * if I should put just the modified routines in here and
16 * then use a construct like #define DONT_DO_THIS_FUNCTION or
17 * something like that...
18 *
19 * This is for the RepeatX_RepeatY part of the world
20 */
21
22
23 #if !defined(__ARM_HAVE_NEON)
24 #error this file can be used only when the NEON unit is enabled
25 #endif
26
27 #include <arm_neon.h>
28
29 /*
30 * This has been modified on the knowledge that (at the time)
31 * we had the following macro definitions in the parent file
32 *
33 * #define MAKENAME(suffix) RepeatX_RepeatY ## suffix
34 * #define TILEX_PROCF(fx, max) (((fx) & 0xFFFF) * ((max) + 1) >> 16)
35 * #define TILEY_PROCF(fy, max) (((fy) & 0xFFFF) * ((max) + 1) >> 16)
36 * #define TILEX_LOW_BITS(fx, max) ((((fx) & 0xFFFF) * ((max) + 1) >> 12) & 0xF)
37 * #define TILEY_LOW_BITS(fy, max) ((((fy) & 0xFFFF) * ((max) + 1) >> 12) & 0xF)
38 */
39
40 /* SkClampMax(val,max) -- bound to 0..max */
41
42 #define SCALE_NOFILTER_NAME MAKENAME(_nofilter_scale_neon)
43 #define SCALE_FILTER_NAME MAKENAME(_filter_scale)
44 #define AFFINE_NOFILTER_NAME MAKENAME(_nofilter_affine_neon)
45 #define AFFINE_FILTER_NAME MAKENAME(_filter_affine)
46 #define PERSP_NOFILTER_NAME MAKENAME(_nofilter_persp_neon)
47 #define PERSP_FILTER_NAME MAKENAME(_filter_persp)
48
49 #define PACK_FILTER_X_NAME MAKENAME(_pack_filter_x)
50 #define PACK_FILTER_Y_NAME MAKENAME(_pack_filter_y)
51
52 #ifndef PREAMBLE
53 #define PREAMBLE(state)
54 #define PREAMBLE_PARAM_X
55 #define PREAMBLE_PARAM_Y
56 #define PREAMBLE_ARG_X
57 #define PREAMBLE_ARG_Y
58 #endif
59
SCALE_NOFILTER_NAME(const SkBitmapProcState & s,uint32_t xy[],int count,int x,int y)60 static void SCALE_NOFILTER_NAME(const SkBitmapProcState& s,
61 uint32_t xy[], int count, int x, int y) {
62 SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
63 SkMatrix::kScale_Mask)) == 0);
64
65 PREAMBLE(s);
66 // we store y, x, x, x, x, x
67
68 const unsigned maxX = s.fBitmap->width() - 1;
69 SkFixed fx;
70 {
71 SkPoint pt;
72 s.fInvProc(*s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
73 SkIntToScalar(y) + SK_ScalarHalf, &pt);
74 fx = SkScalarToFixed(pt.fY);
75 const unsigned maxY = s.fBitmap->height() - 1;
76 *xy++ = TILEY_PROCF(fx, maxY);
77 fx = SkScalarToFixed(pt.fX);
78 }
79
80 if (0 == maxX) {
81 // all of the following X values must be 0
82 memset(xy, 0, count * sizeof(uint16_t));
83 return;
84 }
85
86 const SkFixed dx = s.fInvSx;
87
88 #ifdef CHECK_FOR_DECAL
89 // test if we don't need to apply the tile proc
90 if ((unsigned)(fx >> 16) <= maxX &&
91 (unsigned)((fx + dx * (count - 1)) >> 16) <= maxX) {
92 decal_nofilter_scale(xy, fx, dx, count);
93 } else
94 #endif
95 {
96 int i;
97
98 #if defined(__ARM_HAVE_NEON)
99 /* RBE: very much like done in decal_nofilter ,
100 * but some processing of the 'fx' information
101 * TILEX_PROCF(fx, max) (((fx) & 0xFFFF) * ((max) + 1) >> 16)
102 */
103 if (count >= 8) {
104 /* SkFixed is 16.16 fixed point */
105 SkFixed dx2 = dx+dx;
106 SkFixed dx4 = dx2+dx2;
107 SkFixed dx8 = dx4+dx4;
108
109 /* now build fx/fx+dx/fx+2dx/fx+3dx */
110 SkFixed fx1, fx2, fx3;
111 int32x2_t lower, upper;
112 int32x4_t lbase, hbase;
113 int16_t *dst16 = (int16_t *)xy;
114
115 fx1 = fx+dx;
116 fx2 = fx1+dx;
117 fx3 = fx2+dx;
118
119 lbase = vdupq_n_s32(fx);
120 lbase = vsetq_lane_s32(fx1, lbase, 1);
121 lbase = vsetq_lane_s32(fx2, lbase, 2);
122 lbase = vsetq_lane_s32(fx3, lbase, 3);
123 hbase = vaddq_s32(lbase, vdupq_n_s32(dx4));
124
125 /* store & bump */
126 do
127 {
128 int32x4_t lout;
129 int32x4_t hout;
130 int16x8_t hi16;
131
132 /* TILEX_PROCF(fx, max) (((fx)&0xFFFF)*((max)+1)>> 16) */
133 /* mask to low 16 [would like to use uzp tricks) */
134 lout = vandq_s32(lbase, vdupq_n_s32(0xffff));
135 hout = vandq_s32(hbase, vdupq_n_s32(0xffff));
136 /* bare multiplication, not SkFixedMul */
137 lout = vmulq_s32(lout, vdupq_n_s32(maxX+1));
138 hout = vmulq_s32(hout, vdupq_n_s32(maxX+1));
139
140 /* extraction, using uzp */
141 /* this is ok -- we want all hi(lout)s then all hi(hout)s */
142 asm ("vuzpq.16 %q0, %q1" : "+w" (lout), "+w" (hout));
143 hi16 = vreinterpretq_s16_s32(hout);
144 vst1q_s16(dst16, hi16);
145
146 /* bump our base on to the next */
147 lbase = vaddq_s32 (lbase, vdupq_n_s32(dx8));
148 hbase = vaddq_s32 (hbase, vdupq_n_s32(dx8));
149 dst16 += 8;
150 count -= 8;
151 fx += dx8;
152 } while (count >= 8);
153 xy = (uint32_t *) dst16;
154 }
155 #else
156 /* simple, portable way of looking at 4 at a crack;
157 * so gets some loop unrolling, but not full SIMD speed
158 */
159 for (i = (count >> 2); i > 0; --i) {
160 unsigned a, b;
161 a = TILEX_PROCF(fx, maxX); fx += dx;
162 b = TILEX_PROCF(fx, maxX); fx += dx;
163 #ifdef SK_CPU_BENDIAN
164 *xy++ = (a << 16) | b;
165 #else
166 *xy++ = (b << 16) | a;
167 #endif
168 a = TILEX_PROCF(fx, maxX); fx += dx;
169 b = TILEX_PROCF(fx, maxX); fx += dx;
170 #ifdef SK_CPU_BENDIAN
171 *xy++ = (a << 16) | b;
172 #else
173 *xy++ = (b << 16) | a;
174 #endif
175 }
176 /* loop doesn't adjust count */
177 count -= (count>>2);
178 #endif
179 uint16_t* xx = (uint16_t*)xy;
180 for (i = count; i > 0; --i) {
181 *xx++ = TILEX_PROCF(fx, maxX); fx += dx;
182 }
183 }
184 }
185
186 // note: we could special-case on a matrix which is skewed in X but not Y.
187 // this would require a more general setup thatn SCALE does, but could use
188 // SCALE's inner loop that only looks at dx
189
190
AFFINE_NOFILTER_NAME(const SkBitmapProcState & s,uint32_t xy[],int count,int x,int y)191 static void AFFINE_NOFILTER_NAME(const SkBitmapProcState& s,
192 uint32_t xy[], int count, int x, int y) {
193 SkASSERT(s.fInvType & SkMatrix::kAffine_Mask);
194 SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
195 SkMatrix::kScale_Mask |
196 SkMatrix::kAffine_Mask)) == 0);
197
198 PREAMBLE(s);
199 SkPoint srcPt;
200 s.fInvProc(*s.fInvMatrix,
201 SkIntToScalar(x) + SK_ScalarHalf,
202 SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
203
204 SkFixed fx = SkScalarToFixed(srcPt.fX);
205 SkFixed fy = SkScalarToFixed(srcPt.fY);
206 SkFixed dx = s.fInvSx;
207 SkFixed dy = s.fInvKy;
208 int maxX = s.fBitmap->width() - 1;
209 int maxY = s.fBitmap->height() - 1;
210
211 #if 1
212 int ocount = count;
213 uint32_t *oxy = xy;
214 SkFixed bfx = fx, bfy=fy, bdx=dx, bdy=dy;
215 #endif
216
217 #if defined(__ARM_HAVE_NEON)
218
219 if (0) { extern void rbe(void); rbe(); }
220
221 /* RBE: benchmarks show this eats up time; can we neonize it? */
222 /* RBE: very much like done in decal_nofilter ,
223 * but some processing of the 'fx' information
224 * TILEX_PROCF(fx, max) (((fx) & 0xFFFF) * ((max) + 1) >> 16)
225 */
226 if (count >= 4) {
227 /* SkFixed is 16.16 fixed point */
228 SkFixed dx4 = dx*4;
229 SkFixed dy4 = dy*4;
230
231 /* now build fx/fx+dx/fx+2dx/fx+3dx */
232 int32x2_t lower, upper;
233 int32x4_t xbase, ybase;
234 int16_t *dst16 = (int16_t *)xy;
235
236 /* synthesize 4x for both X and Y */
237 xbase = vdupq_n_s32(fx);
238 xbase = vsetq_lane_s32(fx+dx, xbase, 1);
239 xbase = vsetq_lane_s32(fx+dx+dx, xbase, 2);
240 xbase = vsetq_lane_s32(fx+dx+dx+dx, xbase, 3);
241
242 ybase = vdupq_n_s32(fy);
243 ybase = vsetq_lane_s32(fy+dy, ybase, 1);
244 ybase = vsetq_lane_s32(fy+dy+dy, ybase, 2);
245 ybase = vsetq_lane_s32(fy+dy+dy+dy, ybase, 3);
246
247 /* store & bump */
248 do {
249 int32x4_t xout;
250 int32x4_t yout;
251 int16x8_t hi16;
252
253 /* TILEX_PROCF(fx, max) (((fx)&0xFFFF)*((max)+1)>> 16) */
254 /* mask to low 16 [would like to use uzp tricks) */
255 xout = vandq_s32(xbase, vdupq_n_s32(0xffff));
256 yout = vandq_s32(ybase, vdupq_n_s32(0xffff));
257 /* bare multiplication, not SkFixedMul */
258 xout = vmulq_s32(xout, vdupq_n_s32(maxX+1));
259 yout = vmulq_s32(yout, vdupq_n_s32(maxY+1));
260
261 /* put hi16 from xout over low16 from yout */
262 yout = vsriq_n_s32(yout, xout, 16);
263
264 /* and then yout has the interleaved upper 16's */
265 hi16 = vreinterpretq_s16_s32(yout);
266 vst1q_s16(dst16, hi16);
267
268 /* bump preserved base & on to the next */
269 xbase = vaddq_s32 (xbase, vdupq_n_s32(dx4));
270 ybase = vaddq_s32 (ybase, vdupq_n_s32(dy4));
271 dst16 += 8; /* 8 x16 aka 4x32 */
272 count -= 4;
273 fx += dx4;
274 fy += dy4;
275 } while (count >= 4);
276 xy = (uint32_t *) dst16;
277 }
278
279 #if 0
280 /* diagnostics... see whether we agree with the NEON code */
281 int bad = 0;
282 uint32_t *myxy = oxy;
283 int myi = (-1);
284 SkFixed ofx = bfx, ofy= bfy, odx= bdx, ody= bdy;
285 for (myi = ocount; myi > 0; --myi) {
286 uint32_t val = (TILEY_PROCF(ofy, maxY) << 16) | TILEX_PROCF(ofx, maxX);
287 if (val != *myxy++) {
288 bad++;
289 break;
290 }
291 ofx += odx; ofy += ody;
292 }
293 if (bad) {
294 SkDebugf("repeat-nofilter-affine fails\n");
295 SkDebugf("count %d myi %d\n", ocount, myi);
296 SkDebugf(" bfx %08x, bdx %08x, bfy %08x bdy %08x\n",
297 bfx, bdx, bfy, bdy);
298 SkDebugf("maxX %08x maxY %08x\n", maxX, maxY);
299 }
300 #endif
301 #endif
302
303 for (int i = count; i > 0; --i) {
304 /* fx, fy, dx, dy are all 32 bit 16.16 fixed point */
305 /* (((fx) & 0xFFFF) * ((max) + 1) >> 16) */
306 *xy++ = (TILEY_PROCF(fy, maxY) << 16) | TILEX_PROCF(fx, maxX);
307 fx += dx; fy += dy;
308 }
309 }
310
PERSP_NOFILTER_NAME(const SkBitmapProcState & s,uint32_t * SK_RESTRICT xy,int count,int x,int y)311 static void PERSP_NOFILTER_NAME(const SkBitmapProcState& s,
312 uint32_t* SK_RESTRICT xy,
313 int count, int x, int y) {
314 SkASSERT(s.fInvType & SkMatrix::kPerspective_Mask);
315
316 PREAMBLE(s);
317 int maxX = s.fBitmap->width() - 1;
318 int maxY = s.fBitmap->height() - 1;
319
320 SkPerspIter iter(*s.fInvMatrix,
321 SkIntToScalar(x) + SK_ScalarHalf,
322 SkIntToScalar(y) + SK_ScalarHalf, count);
323
324 while ((count = iter.next()) != 0) {
325 const SkFixed* SK_RESTRICT srcXY = iter.getXY();
326
327 #if defined(__ARM_HAVE_NEON)
328 /* RBE: */
329 /* TILEX_PROCF(fx, max) (((fx) & 0xFFFF) * ((max) + 1) >> 16) */
330 /* it's a little more complicated than what I did for the
331 * clamp case -- where I could immediately snip to the top
332 * 16 bits and do my min/max games there.
333 * ... might only be able to get 4x unrolling here
334 */
335
336 /* vld2 to get a set of 32x4's ... */
337 /* do the tile[xy]_procf operations */
338 /* which includes doing vuzp to get hi16's */
339 /* store it */
340 /* -- inner loop (other than vld2) can be had from above */
341
342 /* srcXY is a batch of 32 bit numbers X0,Y0,X1,Y1...
343 * but we immediately discard the low 16 bits...
344 * so what we're going to do is vld4, which will give us
345 * xlo,xhi,ylo,yhi distribution and we can ignore the 'lo'
346 * parts....
347 */
348 if (0) { extern void rbe(void); rbe(); }
349 if (count >= 8) {
350 int32_t *mysrc = (int32_t *) srcXY;
351 int16_t *mydst = (int16_t *) xy;
352 do {
353 int32x4_t x, y, x2, y2;
354 int16x8_t hi, hi2;
355
356 /* read array of x,y,x,y,x,y */
357 /* vld2 does the de-interleaving for us */
358 /* isolate reg-bound scopes; gcc will minimize register
359 * motion if possible; this ensures that we don't lose
360 * a register across a debugging call because it happens
361 * to be bound into a call-clobbered register
362 */
363 {
364 register int32x4_t q0 asm("q0");
365 register int32x4_t q1 asm("q1");
366 asm ("vld2.32 {q0-q1},[%2] /* x=%q0 y=%q1 */"
367 : "=w" (q0), "=w" (q1)
368 : "r" (mysrc)
369 );
370 x = q0; y = q1;
371 }
372
373 /* offset == 256 bits == 32 bytes == 8 longs */
374 {
375 register int32x4_t q2 asm("q2");
376 register int32x4_t q3 asm("q3");
377 asm ("vld2.32 {q2-q3},[%2] /* x=%q0 y=%q1 */"
378 : "=w" (q2), "=w" (q3)
379 : "r" (mysrc+8)
380 );
381 x2 = q2; y2 = q3;
382 }
383
384 /* TILEX_PROCF(fx, max) (((fx)&0xFFFF)*((max)+1)>> 16) */
385 /* mask to low 16 [would like to use uzp tricks) */
386 /* bare multiplication, not SkFixedMul */
387 x = vandq_s32(x, vdupq_n_s32(0xffff));
388 x = vmulq_s32(x, vdupq_n_s32(maxX+1));
389 y = vandq_s32(y, vdupq_n_s32(0xffff));
390 y = vmulq_s32(y, vdupq_n_s32(maxY+1));
391
392 x2 = vandq_s32(x2, vdupq_n_s32(0xffff));
393 x2 = vmulq_s32(x2, vdupq_n_s32(maxX+1));
394 y2 = vandq_s32(y2, vdupq_n_s32(0xffff));
395 y2 = vmulq_s32(y2, vdupq_n_s32(maxY+1));
396
397 /* now collect interleaved high 16's */
398 /* (hi-x, hi-y)4 (hi-x2; hi-y2)4 */
399
400 /* extraction, using uzp, leaves hi16's in y */
401 y = vsriq_n_s32(y, x, 16);
402 hi = vreinterpretq_s16_s32(y);
403 vst1q_s16(mydst, hi);
404
405 /* and likewise for the second 8 entries */
406 y2 = vsriq_n_s32(y2, x2, 16);
407 hi2 = vreinterpretq_s16_s32(y2);
408 vst1q_s16(mydst+8, hi2);
409
410 /* XXX: gcc isn't interleaving these with the NEON ops
411 * but i think that all the scoreboarding works out */
412 count -= 8; /* 8 iterations */
413 mysrc += 16; /* 16 longs */
414 mydst += 16; /* 16 shorts, aka 8 longs */
415 } while (count >= 8);
416 /* get xy and srcXY fixed up */
417 srcXY = (const SkFixed *) mysrc;
418 xy = (uint32_t *) mydst;
419 }
420 #endif
421 while (--count >= 0) {
422 *xy++ = (TILEY_PROCF(srcXY[1], maxY) << 16) |
423 TILEX_PROCF(srcXY[0], maxX);
424 srcXY += 2;
425 }
426 }
427 }
428
429 //////////////////////////////////////////////////////////////////////////////
430
PACK_FILTER_Y_NAME(SkFixed f,unsigned max,SkFixed one PREAMBLE_PARAM_Y)431 static inline uint32_t PACK_FILTER_Y_NAME(SkFixed f, unsigned max,
432 SkFixed one PREAMBLE_PARAM_Y) {
433 unsigned i = TILEY_PROCF(f, max);
434 i = (i << 4) | TILEY_LOW_BITS(f, max);
435 return (i << 14) | (TILEY_PROCF((f + one), max));
436 }
437
PACK_FILTER_X_NAME(SkFixed f,unsigned max,SkFixed one PREAMBLE_PARAM_X)438 static inline uint32_t PACK_FILTER_X_NAME(SkFixed f, unsigned max,
439 SkFixed one PREAMBLE_PARAM_X) {
440 unsigned i = TILEX_PROCF(f, max);
441 i = (i << 4) | TILEX_LOW_BITS(f, max);
442 return (i << 14) | (TILEX_PROCF((f + one), max));
443 }
444
SCALE_FILTER_NAME(const SkBitmapProcState & s,uint32_t xy[],int count,int x,int y)445 static void SCALE_FILTER_NAME(const SkBitmapProcState& s,
446 uint32_t xy[], int count, int x, int y) {
447 SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
448 SkMatrix::kScale_Mask)) == 0);
449 SkASSERT(s.fInvKy == 0);
450
451 PREAMBLE(s);
452
453 const unsigned maxX = s.fBitmap->width() - 1;
454 const SkFixed one = s.fFilterOneX;
455 const SkFixed dx = s.fInvSx;
456 SkFixed fx;
457
458 {
459 SkPoint pt;
460 s.fInvProc(*s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
461 SkIntToScalar(y) + SK_ScalarHalf, &pt);
462 const SkFixed fy = SkScalarToFixed(pt.fY) - (s.fFilterOneY >> 1);
463 const unsigned maxY = s.fBitmap->height() - 1;
464 // compute our two Y values up front
465 *xy++ = PACK_FILTER_Y_NAME(fy, maxY, s.fFilterOneY PREAMBLE_ARG_Y);
466 // now initialize fx
467 fx = SkScalarToFixed(pt.fX) - (one >> 1);
468 }
469
470 #ifdef CHECK_FOR_DECAL
471 // test if we don't need to apply the tile proc
472 if (dx > 0 &&
473 (unsigned)(fx >> 16) <= maxX &&
474 (unsigned)((fx + dx * (count - 1)) >> 16) < maxX) {
475 decal_filter_scale(xy, fx, dx, count);
476 } else
477 #endif
478 {
479 do {
480 *xy++ = PACK_FILTER_X_NAME(fx, maxX, one PREAMBLE_ARG_X);
481 fx += dx;
482 } while (--count != 0);
483 }
484 }
485
AFFINE_FILTER_NAME(const SkBitmapProcState & s,uint32_t xy[],int count,int x,int y)486 static void AFFINE_FILTER_NAME(const SkBitmapProcState& s,
487 uint32_t xy[], int count, int x, int y) {
488 SkASSERT(s.fInvType & SkMatrix::kAffine_Mask);
489 SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
490 SkMatrix::kScale_Mask |
491 SkMatrix::kAffine_Mask)) == 0);
492
493 PREAMBLE(s);
494 SkPoint srcPt;
495 s.fInvProc(*s.fInvMatrix,
496 SkIntToScalar(x) + SK_ScalarHalf,
497 SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
498
499 SkFixed oneX = s.fFilterOneX;
500 SkFixed oneY = s.fFilterOneY;
501 SkFixed fx = SkScalarToFixed(srcPt.fX) - (oneX >> 1);
502 SkFixed fy = SkScalarToFixed(srcPt.fY) - (oneY >> 1);
503 SkFixed dx = s.fInvSx;
504 SkFixed dy = s.fInvKy;
505 unsigned maxX = s.fBitmap->width() - 1;
506 unsigned maxY = s.fBitmap->height() - 1;
507
508 do {
509 *xy++ = PACK_FILTER_Y_NAME(fy, maxY, oneY PREAMBLE_ARG_Y);
510 fy += dy;
511 *xy++ = PACK_FILTER_X_NAME(fx, maxX, oneX PREAMBLE_ARG_X);
512 fx += dx;
513 } while (--count != 0);
514 }
515
PERSP_FILTER_NAME(const SkBitmapProcState & s,uint32_t * SK_RESTRICT xy,int count,int x,int y)516 static void PERSP_FILTER_NAME(const SkBitmapProcState& s,
517 uint32_t* SK_RESTRICT xy, int count,
518 int x, int y) {
519 SkASSERT(s.fInvType & SkMatrix::kPerspective_Mask);
520
521 extern void rbe(void);
522
523 PREAMBLE(s);
524 unsigned maxX = s.fBitmap->width() - 1;
525 unsigned maxY = s.fBitmap->height() - 1;
526 SkFixed oneX = s.fFilterOneX;
527 SkFixed oneY = s.fFilterOneY;
528
529
530
531 SkPerspIter iter(*s.fInvMatrix,
532 SkIntToScalar(x) + SK_ScalarHalf,
533 SkIntToScalar(y) + SK_ScalarHalf, count);
534
535 while ((count = iter.next()) != 0) {
536 const SkFixed* SK_RESTRICT srcXY = iter.getXY();
537 do {
538 *xy++ = PACK_FILTER_Y_NAME(srcXY[1] - (oneY >> 1), maxY,
539 oneY PREAMBLE_ARG_Y);
540 *xy++ = PACK_FILTER_X_NAME(srcXY[0] - (oneX >> 1), maxX,
541 oneX PREAMBLE_ARG_X);
542 srcXY += 2;
543 } while (--count != 0);
544 }
545 }
546
547 static SkBitmapProcState::MatrixProc MAKENAME(_Procs)[] = {
548 SCALE_NOFILTER_NAME,
549 SCALE_FILTER_NAME,
550 AFFINE_NOFILTER_NAME,
551 AFFINE_FILTER_NAME,
552 PERSP_NOFILTER_NAME,
553 PERSP_FILTER_NAME
554 };
555
556 #undef MAKENAME
557 #undef TILEX_PROCF
558 #undef TILEY_PROCF
559 #ifdef CHECK_FOR_DECAL
560 #undef CHECK_FOR_DECAL
561 #endif
562
563 #undef SCALE_NOFILTER_NAME
564 #undef SCALE_FILTER_NAME
565 #undef AFFINE_NOFILTER_NAME
566 #undef AFFINE_FILTER_NAME
567 #undef PERSP_NOFILTER_NAME
568 #undef PERSP_FILTER_NAME
569
570 #undef PREAMBLE
571 #undef PREAMBLE_PARAM_X
572 #undef PREAMBLE_PARAM_Y
573 #undef PREAMBLE_ARG_X
574 #undef PREAMBLE_ARG_Y
575
576 #undef TILEX_LOW_BITS
577 #undef TILEY_LOW_BITS
578