1 /*
2 * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #ifndef LoopMacros_h_Included
27 #define LoopMacros_h_Included
28
29 #include "j2d_md.h"
30
31 #include "LineUtils.h"
32
33 /*
34 * This file contains macros to aid in defining native graphics
35 * primitive functions.
36 *
37 * A number of useful building block macros are defined, but the
38 * vast majority of primitives are defined completely by a single
39 * macro expansion which uses macro names in the argument list to
40 * choose not only from a small number of strategies but also to
41 * choose macro packages specific to the source and destination
42 * pixel formats - greatly simplifying all aspects of creating
43 * a new loop.
44 *
45 * See the following macros which define entire functions with
46 * just one or two surface names and sometimes a strategy name:
47 * DEFINE_ISOCOPY_BLIT(ANYTYPE)
48 * DEFINE_ISOXOR_BLIT(ANYTYPE)
49 * DEFINE_CONVERT_BLIT(SRC, DST, CONV_METHOD)
50 * DEFINE_CONVERT_BLIT_LUT(SRC, DST, LUT_STRATEGY)
51 * DEFINE_XPAR_CONVERT_BLIT_LUT(SRC, DST, LUT_STRATEGY)
52 * DEFINE_XPAR_BLITBG_LUT(SRC, DST, LUT_STRATEGY)
53 * DEFINE_SOLID_FILLRECT(DST)
54 * DEFINE_SOLID_FILLSPANS(DST)
55 * DEFINE_SOLID_DRAWLINE(DST)
56 *
57 * Many of these loop macros take the name of a SurfaceType as
58 * an argument and use the ANSI CPP token concatenation operator
59 * "##" to reference macro and type definitions that are specific
60 * to that type of surface.
61 *
62 * A description of the various surface specific macro utilities
63 * that are used by these loop macros appears at the end of the
64 * file. The definitions of these surface-specific macros will
65 * usually appear in a header file named after the SurfaceType
66 * name (i.e. IntArgb.h, ByteGray.h, etc.).
67 */
68
69 /*
70 * This loop is the standard "while (--height > 0)" loop used by
71 * some of the blits below.
72 */
73 #define BlitLoopHeight(SRCTYPE, SRCPTR, SRCBASE, SRCINFO, \
74 DSTTYPE, DSTPTR, DSTBASE, DSTINFO, DSTPREFIX, \
75 HEIGHT, BODY) \
76 do { \
77 SRCTYPE ## DataType *SRCPTR = (SRCTYPE ## DataType *) (SRCBASE); \
78 DSTTYPE ## DataType *DSTPTR = (DSTTYPE ## DataType *) (DSTBASE); \
79 jint srcScan = (SRCINFO)->scanStride; \
80 jint dstScan = (DSTINFO)->scanStride; \
81 Init ## DSTTYPE ## StoreVarsY(DSTPREFIX, DSTINFO); \
82 do { \
83 BODY; \
84 SRCPTR = PtrAddBytes(SRCPTR, srcScan); \
85 DSTPTR = PtrAddBytes(DSTPTR, dstScan); \
86 Next ## DSTTYPE ## StoreVarsY(DSTPREFIX); \
87 } while (--HEIGHT > 0); \
88 } while (0)
89
90 /*
91 * This loop is the standard nested "while (--width/height > 0)" loop
92 * used by most of the basic blits below.
93 */
94 #define BlitLoopWidthHeight(SRCTYPE, SRCPTR, SRCBASE, SRCINFO, \
95 DSTTYPE, DSTPTR, DSTBASE, DSTINFO, DSTPREFIX, \
96 WIDTH, HEIGHT, BODY) \
97 do { \
98 SRCTYPE ## DataType *SRCPTR = (SRCTYPE ## DataType *) (SRCBASE); \
99 DSTTYPE ## DataType *DSTPTR = (DSTTYPE ## DataType *) (DSTBASE); \
100 jint srcScan = (SRCINFO)->scanStride; \
101 jint dstScan = (DSTINFO)->scanStride; \
102 Init ## DSTTYPE ## StoreVarsY(DSTPREFIX, DSTINFO); \
103 srcScan -= (WIDTH) * SRCTYPE ## PixelStride; \
104 dstScan -= (WIDTH) * DSTTYPE ## PixelStride; \
105 do { \
106 juint w = WIDTH; \
107 Init ## DSTTYPE ## StoreVarsX(DSTPREFIX, DSTINFO); \
108 do { \
109 BODY; \
110 SRCPTR = PtrAddBytes(SRCPTR, SRCTYPE ## PixelStride); \
111 DSTPTR = PtrAddBytes(DSTPTR, DSTTYPE ## PixelStride); \
112 Next ## DSTTYPE ## StoreVarsX(DSTPREFIX); \
113 } while (--w > 0); \
114 SRCPTR = PtrAddBytes(SRCPTR, srcScan); \
115 DSTPTR = PtrAddBytes(DSTPTR, dstScan); \
116 Next ## DSTTYPE ## StoreVarsY(DSTPREFIX); \
117 } while (--HEIGHT > 0); \
118 } while (0)
119
120 /*
121 * This loop is the standard nested "while (--width/height > 0)" loop
122 * used by most of the scaled blits below. It calculates the proper
123 * X source variable
124 */
125 #define BlitLoopScaleWidthHeight(SRCTYPE, SRCPTR, SRCBASE, SRCINFO, \
126 DSTTYPE, DSTPTR, DSTBASE, DSTINFO, DSTPREFIX, \
127 XVAR, WIDTH, HEIGHT, \
128 SXLOC, SYLOC, SXINC, SYINC, SHIFT, \
129 BODY) \
130 do { \
131 SRCTYPE ## DataType *SRCPTR; \
132 DSTTYPE ## DataType *DSTPTR = (DSTTYPE ## DataType *) (DSTBASE); \
133 jint srcScan = (SRCINFO)->scanStride; \
134 jint dstScan = (DSTINFO)->scanStride; \
135 Init ## DSTTYPE ## StoreVarsY(DSTPREFIX, DSTINFO); \
136 dstScan -= (WIDTH) * DSTTYPE ## PixelStride; \
137 do { \
138 juint w = WIDTH; \
139 jint tmpsxloc = SXLOC; \
140 SRCPTR = PtrAddBytes(SRCBASE, ((SYLOC >> SHIFT) * srcScan)); \
141 Init ## DSTTYPE ## StoreVarsX(DSTPREFIX, DSTINFO); \
142 do { \
143 jint XVAR = (tmpsxloc >> SHIFT); \
144 BODY; \
145 DSTPTR = PtrAddBytes(DSTPTR, DSTTYPE ## PixelStride); \
146 Next ## DSTTYPE ## StoreVarsX(DSTPREFIX); \
147 tmpsxloc += SXINC; \
148 } while (--w > 0); \
149 DSTPTR = PtrAddBytes(DSTPTR, dstScan); \
150 Next ## DSTTYPE ## StoreVarsY(DSTPREFIX); \
151 SYLOC += SYINC; \
152 } while (--HEIGHT > 0); \
153 } while (0)
154
155 /*
156 * This loop is a standard horizontal loop iterating with a "relative"
157 * X coordinate (0 <= X < WIDTH) used primarily by the LUT conversion
158 * preprocessing loops below.
159 */
160 #define BlitLoopXRel(DSTTYPE, DSTINFO, DSTPREFIX, \
161 XVAR, WIDTH, BODY) \
162 do { \
163 juint XVAR = 0; \
164 Init ## DSTTYPE ## StoreVarsX(DSTPREFIX, DSTINFO); \
165 do { \
166 BODY; \
167 Next ## DSTTYPE ## StoreVarsX(DSTPREFIX); \
168 } while (++XVAR < WIDTH); \
169 } while (0)
170
171 /*
172 * This is a "conversion strategy" for use with the DEFINE_CONVERT_BLIT
173 * macros. It converts from the source pixel format to the destination
174 * via an intermediate "jint rgb" format.
175 */
176 #define ConvertVia1IntRgb(SRCPTR, SRCTYPE, SRCPREFIX, \
177 DSTPTR, DSTTYPE, DSTPREFIX, \
178 SXVAR, DXVAR) \
179 do { \
180 int rgb; \
181 Load ## SRCTYPE ## To1IntRgb(SRCPTR, SRCPREFIX, SXVAR, rgb); \
182 Store ## DSTTYPE ## From1IntRgb(DSTPTR, DSTPREFIX, DXVAR, rgb); \
183 } while (0)
184
185 /*
186 * This is a "conversion strategy" for use with the DEFINE_CONVERT_BLIT
187 * macros. It converts from the source pixel format to the destination
188 * via an intermediate "jint argb" format.
189 */
190 #define ConvertVia1IntArgb(SRCPTR, SRCTYPE, SRCPREFIX, \
191 DSTPTR, DSTTYPE, DSTPREFIX, \
192 SXVAR, DXVAR) \
193 do { \
194 int argb; \
195 Load ## SRCTYPE ## To1IntArgb(SRCPTR, SRCPREFIX, SXVAR, argb); \
196 Store ## DSTTYPE ## From1IntArgb(DSTPTR, DSTPREFIX, DXVAR, argb); \
197 } while (0)
198
199 /*
200 * This is a "conversion strategy" for use with the DEFINE_CONVERT_BLIT
201 * macros. It converts from the source pixel format to the destination
202 * via an intermediate set of 3 component variables "jint r, g, b".
203 */
204 #define ConvertVia3ByteRgb(SRCPTR, SRCTYPE, SRCPREFIX, \
205 DSTPTR, DSTTYPE, DSTPREFIX, \
206 SXVAR, DXVAR) \
207 do { \
208 jint r, g, b; \
209 Load ## SRCTYPE ## To3ByteRgb(SRCPTR, SRCPREFIX, SXVAR, r, g, b); \
210 Store ## DSTTYPE ## From3ByteRgb(DSTPTR, DSTPREFIX, DXVAR, r, g, b); \
211 } while (0)
212
213 /*
214 * This is a "conversion strategy" for use with the DEFINE_CONVERT_BLIT
215 * macros. It converts from the source pixel format to the destination
216 * via an intermediate set of 4 component variables "jint a, r, g, b".
217 */
218 #define ConvertVia4ByteArgb(SRCPTR, SRCTYPE, SRCPREFIX, \
219 DSTPTR, DSTTYPE, DSTPREFIX, \
220 SXVAR, DXVAR) \
221 do { \
222 jint a, r, g, b; \
223 Load ## SRCTYPE ## To4ByteArgb(SRCPTR, SRCPREFIX, SXVAR, a, r, g, b); \
224 Store ## DSTTYPE ## From4ByteArgb(DSTPTR, DSTPREFIX, DXVAR, \
225 a, r, g, b); \
226 } while (0)
227
228 /*
229 * This is a "conversion strategy" for use with the DEFINE_CONVERT_BLIT
230 * macros. It converts from the source pixel format to the destination
231 * via an intermediate "jint gray" format.
232 */
233 #define ConvertVia1ByteGray(SRCPTR, SRCTYPE, SRCPREFIX, \
234 DSTPTR, DSTTYPE, DSTPREFIX, \
235 SXVAR, DXVAR) \
236 do { \
237 jint gray; \
238 Load ## SRCTYPE ## To1ByteGray(SRCPTR, SRCPREFIX, SXVAR, gray); \
239 Store ## DSTTYPE ## From1ByteGray(DSTPTR, DSTPREFIX, DXVAR, gray); \
240 } while (0)
241
242 /*
243 * This is a "conversion strategy" for use with the DEFINE_XPAR_CONVERT_BLIT
244 * macros. It converts from the source pixel format to the destination
245 * via the specified intermediate format while testing for transparent pixels.
246 */
247 #define ConvertXparVia1IntRgb(SRCPTR, SRCTYPE, SRCPREFIX, \
248 DSTPTR, DSTTYPE, DSTPREFIX, \
249 SXVAR, DXVAR) \
250 do { \
251 Declare ## SRCTYPE ## Data(XparLoad); \
252 Load ## SRCTYPE ## Data(SRCPTR, SRCPREFIX, SXVAR, XparLoad); \
253 if (! (Is ## SRCTYPE ## DataTransparent(XparLoad))) { \
254 int rgb; \
255 Convert ## SRCTYPE ## DataTo1IntRgb(XparLoad, rgb); \
256 Store ## DSTTYPE ## From1IntRgb(DSTPTR, DSTPREFIX, DXVAR, rgb); \
257 } \
258 } while (0)
259
260 /*
261 * This is a "conversion strategy" for use with the DEFINE_XPAR_BLITBG
262 * macros. It converts from the source pixel format to the destination
263 * via the specified intermediate format while substituting the specified
264 * bgcolor for transparent pixels.
265 */
266 #define BgCopyXparVia1IntRgb(SRCPTR, SRCTYPE, SRCPREFIX, \
267 DSTPTR, DSTTYPE, DSTPREFIX, \
268 SXVAR, DXVAR, BGPIXEL, BGPREFIX) \
269 do { \
270 Declare ## SRCTYPE ## Data(XparLoad); \
271 Load ## SRCTYPE ## Data(SRCPTR, SRCPREFIX, SXVAR, XparLoad); \
272 if (Is ## SRCTYPE ## DataTransparent(XparLoad)) { \
273 Store ## DSTTYPE ## PixelData(DSTPTR, DXVAR, BGPIXEL, BGPREFIX); \
274 } else { \
275 int rgb; \
276 Convert ## SRCTYPE ## DataTo1IntRgb(XparLoad, rgb); \
277 Store ## DSTTYPE ## From1IntRgb(DSTPTR, DSTPREFIX, DXVAR, rgb); \
278 } \
279 } while (0)
280
281 /*
282 * This macro determines whether or not the given pixel is considered
283 * "transparent" for XOR purposes. The ARGB pixel is considered
284 * "transparent" if the alpha value is < 0.5.
285 */
286 #define IsArgbTransparent(pixel) \
287 (((jint) pixel) >= 0)
288
289 /*
290 * This is a "conversion strategy" for use with the DEFINE_XOR_BLIT macro. It
291 * converts the source pixel to an intermediate ARGB value and then converts
292 * the ARGB value to the pixel representation for the destination surface. It
293 * then XORs the srcpixel, xorpixel, and destination pixel together and stores
294 * the result in the destination surface.
295 */
296 #define XorVia1IntArgb(SRCPTR, SRCTYPE, SRCPREFIX, \
297 DSTPTR, DSTTYPE, DSTANYTYPE, \
298 XVAR, XORPIXEL, XORPREFIX, \
299 MASK, MASKPREFIX, DSTINFOPTR) \
300 do { \
301 jint srcpixel; \
302 Declare ## DSTANYTYPE ## PixelData(pix) \
303 Load ## SRCTYPE ## To1IntArgb(SRCPTR, SRCPREFIX, XVAR, srcpixel); \
304 \
305 if (IsArgbTransparent(srcpixel)) { \
306 break; \
307 } \
308 \
309 DSTTYPE ## PixelFromArgb(srcpixel, srcpixel, DSTINFOPTR); \
310 \
311 Extract ## DSTANYTYPE ## PixelData(srcpixel, pix); \
312 Xor ## DSTANYTYPE ## PixelData(srcpixel, pix, DSTPTR, XVAR, \
313 XORPIXEL, XORPREFIX, \
314 MASK, MASKPREFIX); \
315 } while (0)
316
317 /*
318 * "LUT_STRATEGY" macro sets.
319 *
320 * There are 2 major strategies for dealing with luts and 3
321 * implementations of those strategies.
322 *
323 * The 2 strategies are "PreProcessLut" and "ConvertOnTheFly".
324 *
325 * For the "PreProcessLut" strategy, the raw ARGB lut supplied
326 * by the SD_LOCK_LUT flag is converted at the beginning into a
327 * form that is more suited for storing into the destination
328 * pixel format. The inner loop consists of a series of table
329 * lookups with very little conversion from that intermediate
330 * pixel format.
331 *
332 * For the "ConvertOnTheFly" strategy, the raw ARGB values are
333 * converted on a pixel by pixel basis in the inner loop itself.
334 * This strategy is most useful for formats which tend to use
335 * the ARGB color format as their pixel format also.
336 *
337 * Each of these strategies has 3 implementations which are needed
338 * for the special cases:
339 * - straight conversion (invoked from DEFINE_CONVERT_BLIT_LUT)
340 * - straight conversion with transparency handling (invoked from
341 * DEFINE_XPAR_CONVERT_BLIT_LUT)
342 * - straight conversion with a bgcolor for the transparent pixels
343 * (invoked from DEFINE_XPAR_BLITBG_LUT)
344 */
345
346 /***
347 * Start of PreProcessLut strategy macros, CONVERT_BLIT implementation.
348 */
349 #define LutSize(TYPE) \
350 (1 << TYPE ## BitsPerPixel)
351
352 #define DeclarePreProcessLutLut(SRC, DST, PIXLUT) \
353 DST ## PixelType PIXLUT[LutSize(SRC)];
354
355 #define SetupPreProcessLutLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO) \
356 do { \
357 jint *srcLut = (SRCINFO)->lutBase; \
358 juint lutSize = (SRCINFO)->lutSize; \
359 Declare ## DST ## StoreVars(PreLut) \
360 Init ## DST ## StoreVarsY(PreLut, DSTINFO); \
361 if (lutSize >= LutSize(SRC)) { \
362 lutSize = LutSize(SRC); \
363 } else { \
364 DST ## PixelType *pPIXLUT = &PIXLUT[lutSize]; \
365 do { \
366 Store ## DST ## From1IntArgb(pPIXLUT, PreLut, 0, 0); \
367 } while (++pPIXLUT < &PIXLUT[LutSize(SRC)]); \
368 } \
369 BlitLoopXRel(DST, DSTINFO, PreLut, x, lutSize, \
370 do { \
371 jint argb = srcLut[x]; \
372 Store ## DST ## From1IntArgb(PIXLUT, PreLut, x, argb); \
373 } while (0)); \
374 } while (0)
375
376 #define BodyPreProcessLutLut(SRCPTR, SRCTYPE, PIXLUT, \
377 DSTPTR, DSTTYPE, DSTPREFIX, \
378 SXVAR, DXVAR) \
379 DSTPTR[DXVAR] = PIXLUT[SRCPTR[SXVAR]]
380
381 /*
382 * End of PreProcessLut/CONVERT_BLIT macros.
383 ***/
384
385 /***
386 * Start of ConvertOnTheFly strategy macros, CONVERT_BLIT implementation.
387 */
388 #define DeclareConvertOnTheFlyLut(SRC, DST, PIXLUT) \
389 Declare ## SRC ## LoadVars(PIXLUT)
390
391 #define SetupConvertOnTheFlyLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO) \
392 Init ## SRC ## LoadVars(PIXLUT, SRCINFO)
393
394 #define BodyConvertOnTheFlyLut(SRCPTR, SRCTYPE, PIXLUT, \
395 DSTPTR, DSTTYPE, DSTPREFIX, \
396 SXVAR, DXVAR) \
397 ConvertVia1IntArgb(SRCPTR, SRCTYPE, PIXLUT, \
398 DSTPTR, DSTTYPE, DSTPREFIX, \
399 SXVAR, DXVAR)
400
401 /*
402 * End of ConvertOnTheFly/CONVERT_BLIT macros.
403 ***/
404
405 /***
406 * Start of PreProcessLut strategy macros, XPAR_CONVERT_BLIT implementation.
407 */
408 #define DeclarePreProcessLutXparLut(SRC, DST, PIXLUT) \
409 jint PIXLUT[LutSize(SRC)];
410
411 #define SetupPreProcessLutXparLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO) \
412 do { \
413 jint *srcLut = (SRCINFO)->lutBase; \
414 juint lutSize = (SRCINFO)->lutSize; \
415 Declare ## DST ## StoreVars(PreLut) \
416 Init ## DST ## StoreVarsY(PreLut, DSTINFO); \
417 if (lutSize >= LutSize(SRC)) { \
418 lutSize = LutSize(SRC); \
419 } else { \
420 jint *pPIXLUT = &PIXLUT[lutSize]; \
421 do { \
422 pPIXLUT[0] = DST ## XparLutEntry; \
423 } while (++pPIXLUT < &PIXLUT[LutSize(SRC)]); \
424 } \
425 BlitLoopXRel(DST, DSTINFO, PreLut, x, lutSize, \
426 do { \
427 jint argb = srcLut[x]; \
428 if (argb < 0) { \
429 Store ## DST ## NonXparFromArgb \
430 (PIXLUT, PreLut, x, argb); \
431 } else { \
432 PIXLUT[x] = DST ## XparLutEntry; \
433 } \
434 } while (0)); \
435 } while (0)
436
437 #define BodyPreProcessLutXparLut(SRCPTR, SRCTYPE, PIXLUT, \
438 DSTPTR, DSTTYPE, DSTPREFIX, \
439 SXVAR, DXVAR) \
440 do { \
441 jint pix = PIXLUT[SRCPTR[SXVAR]]; \
442 if (! DSTTYPE ## IsXparLutEntry(pix)) { \
443 DSTPTR[DXVAR] = (DSTTYPE ## PixelType) pix; \
444 } \
445 } while (0)
446
447 /*
448 * End of PreProcessLut/XPAR_CONVERT_BLIT macros.
449 ***/
450
451 /***
452 * Start of ConvertOnTheFly strategy macros, CONVERT_BLIT implementation.
453 */
454 #define DeclareConvertOnTheFlyXparLut(SRC, DST, PIXLUT) \
455 Declare ## SRC ## LoadVars(PIXLUT)
456
457 #define SetupConvertOnTheFlyXparLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO) \
458 Init ## SRC ## LoadVars(PIXLUT, SRCINFO)
459
460 #define BodyConvertOnTheFlyXparLut(SRCPTR, SRCTYPE, PIXLUT, \
461 DSTPTR, DSTTYPE, DSTPREFIX, \
462 SXVAR, DXVAR) \
463 do { \
464 jint argb; \
465 Load ## SRCTYPE ## To1IntArgb(SRCPTR, PIXLUT, SXVAR, argb); \
466 if (argb < 0) { \
467 Store ## DSTTYPE ## From1IntArgb(DSTPTR, DSTPREFIX, DXVAR, argb); \
468 } \
469 } while (0)
470
471 /*
472 * End of ConvertOnTheFly/CONVERT_BLIT macros.
473 ***/
474
475 /***
476 * Start of PreProcessLut strategy macros, BLITBG implementation.
477 */
478 #define DeclarePreProcessLutBgLut(SRC, DST, PIXLUT) \
479 jint PIXLUT[LutSize(SRC)];
480
481 #define SetupPreProcessLutBgLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO, BGPIXEL) \
482 do { \
483 jint *srcLut = (SRCINFO)->lutBase; \
484 juint lutSize = (SRCINFO)->lutSize; \
485 Declare ## DST ## StoreVars(PreLut) \
486 Init ## DST ## StoreVarsY(PreLut, DSTINFO); \
487 if (lutSize >= LutSize(SRC)) { \
488 lutSize = LutSize(SRC); \
489 } else { \
490 jint *pPIXLUT = &PIXLUT[lutSize]; \
491 do { \
492 pPIXLUT[0] = BGPIXEL; \
493 } while (++pPIXLUT < &PIXLUT[LutSize(SRC)]); \
494 } \
495 BlitLoopXRel(DST, DSTINFO, PreLut, x, lutSize, \
496 do { \
497 jint argb = srcLut[x]; \
498 if (argb < 0) { \
499 Store ## DST ## From1IntArgb(PIXLUT, PreLut, \
500 x, argb); \
501 } else { \
502 PIXLUT[x] = BGPIXEL; \
503 } \
504 } while (0)); \
505 } while (0)
506
507 #define BodyPreProcessLutBgLut(SRCPTR, SRCTYPE, PIXLUT, \
508 DSTPTR, DSTTYPE, DSTPREFIX, \
509 SXVAR, DXVAR, BGPIXEL) \
510 do { \
511 jint pix = PIXLUT[SRCPTR[SXVAR]]; \
512 Store ## DSTTYPE ## Pixel(DSTPTR, DXVAR, pix); \
513 } while (0)
514
515 /*
516 * End of PreProcessLut/BLITBG implementation.
517 ***/
518
519 /***
520 * Start of ConvertOnTheFly strategy macros, BLITBG implementation.
521 */
522 #define DeclareConvertOnTheFlyBgLut(SRC, DST, PIXLUT) \
523 Declare ## SRC ## LoadVars(PIXLUT) \
524 Declare ## DST ## PixelData(bgpix);
525
526 #define SetupConvertOnTheFlyBgLut(SRC, DST, PIXLUT, SRCINFO, DSTINFO, BGPIXEL) \
527 do { \
528 Init ## SRC ## LoadVars(PIXLUT, SRCINFO); \
529 Extract ## DST ## PixelData(BGPIXEL, bgpix); \
530 } while (0)
531
532 #define BodyConvertOnTheFlyBgLut(SRCPTR, SRCTYPE, PIXLUT, \
533 DSTPTR, DSTTYPE, DSTPREFIX, \
534 SXVAR, DXVAR, BGPIXEL) \
535 do { \
536 jint argb; \
537 Load ## SRCTYPE ## To1IntArgb(SRCPTR, PIXLUT, SXVAR, argb); \
538 if (argb < 0) { \
539 Store ## DSTTYPE ## From1IntArgb(DSTPTR, DSTPREFIX, DXVAR, argb); \
540 } else { \
541 Store ## DSTTYPE ## PixelData(DSTPTR, DXVAR, BGPIXEL, bgpix); \
542 } \
543 } while (0)
544
545 /*
546 * End of ConvertOnTheFly/BLITBG macros.
547 ***/
548
549 /*
550 * These macros provide consistent naming conventions for the
551 * various types of native primitive inner loop functions.
552 * The names are mechanically constructed from the SurfaceType names.
553 */
554 #define NAME_CONVERT_BLIT(SRC, DST) SRC ## To ## DST ## Convert
555
556 #define NAME_SCALE_BLIT(SRC, DST) SRC ## To ## DST ## ScaleConvert
557
558 #define NAME_XPAR_CONVERT_BLIT(SRC, DST) SRC ## To ## DST ## XparOver
559
560 #define NAME_XPAR_SCALE_BLIT(SRC, DST) SRC ## To ## DST ## ScaleXparOver
561
562 #define NAME_XPAR_BLITBG(SRC, DST) SRC ## To ## DST ## XparBgCopy
563
564 #define NAME_XOR_BLIT(SRC, DST) SRC ## To ## DST ## XorBlit
565
566 #define NAME_ISOCOPY_BLIT(ANYTYPE) ANYTYPE ## IsomorphicCopy
567
568 #define NAME_ISOSCALE_BLIT(ANYTYPE) ANYTYPE ## IsomorphicScaleCopy
569
570 #define NAME_ISOXOR_BLIT(ANYTYPE) ANYTYPE ## IsomorphicXorCopy
571
572 #define NAME_SOLID_FILLRECT(TYPE) TYPE ## SetRect
573
574 #define NAME_SOLID_FILLSPANS(TYPE) TYPE ## SetSpans
575
576 #define NAME_SOLID_DRAWLINE(TYPE) TYPE ## SetLine
577
578 #define NAME_XOR_FILLRECT(TYPE) TYPE ## XorRect
579
580 #define NAME_XOR_FILLSPANS(TYPE) TYPE ## XorSpans
581
582 #define NAME_XOR_DRAWLINE(TYPE) TYPE ## XorLine
583
584 #define NAME_SRC_MASKFILL(TYPE) TYPE ## SrcMaskFill
585
586 #define NAME_SRCOVER_MASKFILL(TYPE) TYPE ## SrcOverMaskFill
587
588 #define NAME_ALPHA_MASKFILL(TYPE) TYPE ## AlphaMaskFill
589
590 #define NAME_SRCOVER_MASKBLIT(SRC, DST) SRC ## To ## DST ## SrcOverMaskBlit
591
592 #define NAME_ALPHA_MASKBLIT(SRC, DST) SRC ## To ## DST ## AlphaMaskBlit
593
594 #define NAME_SOLID_DRAWGLYPHLIST(TYPE) TYPE ## DrawGlyphList
595
596 #define NAME_SOLID_DRAWGLYPHLISTAA(TYPE) TYPE ## DrawGlyphListAA
597
598 #define NAME_SOLID_DRAWGLYPHLISTLCD(TYPE) TYPE ## DrawGlyphListLCD
599
600 #define NAME_XOR_DRAWGLYPHLIST(TYPE) TYPE ## DrawGlyphListXor
601
602 #define NAME_TRANSFORMHELPER(TYPE, MODE) TYPE ## MODE ## TransformHelper
603
604 #define NAME_TRANSFORMHELPER_NN(TYPE) NAME_TRANSFORMHELPER(TYPE, NrstNbr)
605 #define NAME_TRANSFORMHELPER_BL(TYPE) NAME_TRANSFORMHELPER(TYPE, Bilinear)
606 #define NAME_TRANSFORMHELPER_BC(TYPE) NAME_TRANSFORMHELPER(TYPE, Bicubic)
607
608 #define NAME_TRANSFORMHELPER_FUNCS(TYPE) TYPE ## TransformHelperFuncs
609
610 #define NAME_SOLID_FILLPGRAM(TYPE) TYPE ## SetParallelogram
611 #define NAME_SOLID_PGRAM_FUNCS(TYPE) TYPE ## SetParallelogramFuncs
612
613 #define NAME_XOR_FILLPGRAM(TYPE) TYPE ## XorParallelogram
614 #define NAME_XOR_PGRAM_FUNCS(TYPE) TYPE ## XorParallelogramFuncs
615
616 /*
617 * These macros conveniently name and declare the indicated native
618 * primitive loop function for forward referencing.
619 */
620 #define DECLARE_CONVERT_BLIT(SRC, DST) \
621 BlitFunc NAME_CONVERT_BLIT(SRC, DST)
622
623 #define DECLARE_SCALE_BLIT(SRC, DST) \
624 ScaleBlitFunc NAME_SCALE_BLIT(SRC, DST)
625
626 #define DECLARE_XPAR_CONVERT_BLIT(SRC, DST) \
627 BlitFunc NAME_XPAR_CONVERT_BLIT(SRC, DST)
628
629 #define DECLARE_XPAR_SCALE_BLIT(SRC, DST) \
630 ScaleBlitFunc NAME_XPAR_SCALE_BLIT(SRC, DST)
631
632 #define DECLARE_XPAR_BLITBG(SRC, DST) \
633 BlitBgFunc NAME_XPAR_BLITBG(SRC, DST)
634
635 #define DECLARE_XOR_BLIT(SRC, DST) \
636 BlitFunc NAME_XOR_BLIT(SRC, DST)
637
638 #define DECLARE_ISOCOPY_BLIT(ANYTYPE) \
639 BlitFunc NAME_ISOCOPY_BLIT(ANYTYPE)
640
641 #define DECLARE_ISOSCALE_BLIT(ANYTYPE) \
642 ScaleBlitFunc NAME_ISOSCALE_BLIT(ANYTYPE)
643
644 #define DECLARE_ISOXOR_BLIT(ANYTYPE) \
645 BlitFunc NAME_ISOXOR_BLIT(ANYTYPE)
646
647 #define DECLARE_SOLID_FILLRECT(TYPE) \
648 FillRectFunc NAME_SOLID_FILLRECT(TYPE)
649
650 #define DECLARE_SOLID_FILLSPANS(TYPE) \
651 FillSpansFunc NAME_SOLID_FILLSPANS(TYPE)
652
653 #define DECLARE_SOLID_DRAWLINE(TYPE) \
654 DrawLineFunc NAME_SOLID_DRAWLINE(TYPE)
655
656 #define DECLARE_XOR_FILLRECT(TYPE) \
657 FillRectFunc NAME_XOR_FILLRECT(TYPE)
658
659 #define DECLARE_XOR_FILLSPANS(TYPE) \
660 FillSpansFunc NAME_XOR_FILLSPANS(TYPE)
661
662 #define DECLARE_XOR_DRAWLINE(TYPE) \
663 DrawLineFunc NAME_XOR_DRAWLINE(TYPE)
664
665 #define DECLARE_ALPHA_MASKFILL(TYPE) \
666 MaskFillFunc NAME_ALPHA_MASKFILL(TYPE)
667
668 #define DECLARE_SRC_MASKFILL(TYPE) \
669 MaskFillFunc NAME_SRC_MASKFILL(TYPE)
670
671 #define DECLARE_SRCOVER_MASKFILL(TYPE) \
672 MaskFillFunc NAME_SRCOVER_MASKFILL(TYPE)
673
674 #define DECLARE_SRCOVER_MASKBLIT(SRC, DST) \
675 MaskBlitFunc NAME_SRCOVER_MASKBLIT(SRC, DST)
676
677 #define DECLARE_ALPHA_MASKBLIT(SRC, DST) \
678 MaskBlitFunc NAME_ALPHA_MASKBLIT(SRC, DST)
679
680 #define DECLARE_SOLID_DRAWGLYPHLIST(TYPE) \
681 DrawGlyphListFunc NAME_SOLID_DRAWGLYPHLIST(TYPE)
682
683 #define DECLARE_SOLID_DRAWGLYPHLISTAA(TYPE) \
684 DrawGlyphListAAFunc NAME_SOLID_DRAWGLYPHLISTAA(TYPE)
685
686 #define DECLARE_SOLID_DRAWGLYPHLISTLCD(TYPE) \
687 DrawGlyphListLCDFunc NAME_SOLID_DRAWGLYPHLISTLCD(TYPE)
688
689 #define DECLARE_XOR_DRAWGLYPHLIST(TYPE) \
690 DrawGlyphListFunc NAME_XOR_DRAWGLYPHLIST(TYPE)
691
692 #define DECLARE_TRANSFORMHELPER_FUNCS(TYPE) \
693 TransformHelperFunc NAME_TRANSFORMHELPER_NN(TYPE); \
694 TransformHelperFunc NAME_TRANSFORMHELPER_BL(TYPE); \
695 TransformHelperFunc NAME_TRANSFORMHELPER_BC(TYPE); \
696 TransformHelperFuncs NAME_TRANSFORMHELPER_FUNCS(TYPE)
697
698 #define DECLARE_SOLID_PARALLELOGRAM(TYPE) \
699 FillParallelogramFunc NAME_SOLID_FILLPGRAM(TYPE); \
700 DECLARE_SOLID_DRAWLINE(TYPE); \
701 DrawParallelogramFuncs NAME_SOLID_PGRAM_FUNCS(TYPE)
702
703 #define DECLARE_XOR_PARALLELOGRAM(TYPE) \
704 FillParallelogramFunc NAME_XOR_FILLPGRAM(TYPE); \
705 DECLARE_XOR_DRAWLINE(TYPE); \
706 DrawParallelogramFuncs NAME_XOR_PGRAM_FUNCS(TYPE)
707
708 /*
709 * These macros construct the necessary NativePrimitive structure
710 * for the indicated native primitive loop function which will be
711 * declared somewhere prior and defined elsewhere (usually after).
712 */
713 #define REGISTER_CONVERT_BLIT(SRC, DST) \
714 REGISTER_BLIT(SRC, SrcNoEa, DST, NAME_CONVERT_BLIT(SRC, DST))
715
716 #define REGISTER_CONVERT_BLIT_FLAGS(SRC, DST, SFLAGS, DFLAGS) \
717 REGISTER_BLIT_FLAGS(SRC, SrcNoEa, DST, NAME_CONVERT_BLIT(SRC, DST), \
718 SFLAGS, DFLAGS)
719
720 #define REGISTER_CONVERT_BLIT_EQUIV(SRC, DST, FUNC) \
721 REGISTER_BLIT(SRC, SrcNoEa, DST, FUNC)
722
723 #define REGISTER_SCALE_BLIT(SRC, DST) \
724 REGISTER_SCALEBLIT(SRC, SrcNoEa, DST, NAME_SCALE_BLIT(SRC, DST))
725
726 #define REGISTER_SCALE_BLIT_FLAGS(SRC, DST, SFLAGS, DFLAGS) \
727 REGISTER_SCALEBLIT_FLAGS(SRC, SrcNoEa, DST, NAME_SCALE_BLIT(SRC, DST), \
728 SFLAGS, DFLAGS)
729
730 #define REGISTER_SCALE_BLIT_EQUIV(SRC, DST, FUNC) \
731 REGISTER_SCALEBLIT(SRC, SrcNoEa, DST, FUNC)
732
733 #define REGISTER_XPAR_CONVERT_BLIT(SRC, DST) \
734 REGISTER_BLIT(SRC, SrcOverBmNoEa, DST, NAME_XPAR_CONVERT_BLIT(SRC, DST))
735
736 #define REGISTER_XPAR_CONVERT_BLIT_EQUIV(SRC, DST, FUNC) \
737 REGISTER_BLIT(SRC, SrcOverBmNoEa, DST, FUNC)
738
739 #define REGISTER_XPAR_SCALE_BLIT(SRC, DST) \
740 REGISTER_SCALEBLIT(SRC, SrcOverBmNoEa, DST, NAME_XPAR_SCALE_BLIT(SRC, DST))
741
742 #define REGISTER_XPAR_SCALE_BLIT_EQUIV(SRC, DST, FUNC) \
743 REGISTER_SCALEBLIT(SRC, SrcOverBmNoEa, DST, FUNC)
744
745 #define REGISTER_XPAR_BLITBG(SRC, DST) \
746 REGISTER_BLITBG(SRC, SrcNoEa, DST, NAME_XPAR_BLITBG(SRC, DST))
747
748 #define REGISTER_XPAR_BLITBG_EQUIV(SRC, DST, FUNC) \
749 REGISTER_BLITBG(SRC, SrcNoEa, DST, FUNC)
750
751 #define REGISTER_XOR_BLIT(SRC, DST) \
752 REGISTER_BLIT(SRC, Xor, DST, NAME_XOR_BLIT(SRC, DST))
753
754 #define REGISTER_ISOCOPY_BLIT(THISTYPE, ANYTYPE) \
755 REGISTER_BLIT(THISTYPE, SrcNoEa, THISTYPE, NAME_ISOCOPY_BLIT(ANYTYPE))
756
757 #define REGISTER_ISOSCALE_BLIT(THISTYPE, ANYTYPE) \
758 REGISTER_SCALEBLIT(THISTYPE, SrcNoEa, THISTYPE, NAME_ISOSCALE_BLIT(ANYTYPE))
759
760 #define REGISTER_ISOXOR_BLIT(THISTYPE, ANYTYPE) \
761 REGISTER_BLIT(THISTYPE, Xor, THISTYPE, NAME_ISOXOR_BLIT(ANYTYPE))
762
763 #define REGISTER_SOLID_FILLRECT(TYPE) \
764 REGISTER_FILLRECT(AnyColor, SrcNoEa, TYPE, NAME_SOLID_FILLRECT(TYPE))
765
766 #define REGISTER_SOLID_FILLSPANS(TYPE) \
767 REGISTER_FILLSPANS(AnyColor, SrcNoEa, TYPE, NAME_SOLID_FILLSPANS(TYPE))
768
769 #define REGISTER_SOLID_LINE_PRIMITIVES(TYPE) \
770 REGISTER_LINE_PRIMITIVES(AnyColor, SrcNoEa, TYPE, \
771 NAME_SOLID_DRAWLINE(TYPE))
772
773 #define REGISTER_XOR_FILLRECT(TYPE) \
774 REGISTER_FILLRECT(AnyColor, Xor, TYPE, NAME_XOR_FILLRECT(TYPE))
775
776 #define REGISTER_XOR_FILLSPANS(TYPE) \
777 REGISTER_FILLSPANS(AnyColor, Xor, TYPE, NAME_XOR_FILLSPANS(TYPE))
778
779 #define REGISTER_XOR_LINE_PRIMITIVES(TYPE) \
780 REGISTER_LINE_PRIMITIVES(AnyColor, Xor, TYPE, NAME_XOR_DRAWLINE(TYPE))
781
782 #define REGISTER_ALPHA_MASKFILL(TYPE) \
783 REGISTER_MASKFILL(AnyColor, AnyAlpha, TYPE, NAME_ALPHA_MASKFILL(TYPE))
784
785 #define REGISTER_SRC_MASKFILL(TYPE) \
786 REGISTER_MASKFILL(AnyColor, Src, TYPE, NAME_SRC_MASKFILL(TYPE))
787
788 #define REGISTER_SRCOVER_MASKFILL(TYPE) \
789 REGISTER_MASKFILL(AnyColor, SrcOver, TYPE, NAME_SRCOVER_MASKFILL(TYPE))
790
791 #define REGISTER_SRCOVER_MASKBLIT(SRC, DST) \
792 REGISTER_MASKBLIT(SRC, SrcOver, DST, NAME_SRCOVER_MASKBLIT(SRC, DST))
793
794 #define REGISTER_ALPHA_MASKBLIT(SRC, DST) \
795 REGISTER_MASKBLIT(SRC, AnyAlpha, DST, NAME_ALPHA_MASKBLIT(SRC, DST))
796
797 #define REGISTER_SOLID_DRAWGLYPHLIST(TYPE) \
798 REGISTER_DRAWGLYPHLIST(AnyColor, SrcNoEa, TYPE, \
799 NAME_SOLID_DRAWGLYPHLIST(TYPE))
800
801 #define REGISTER_SOLID_DRAWGLYPHLISTAA(TYPE) \
802 REGISTER_DRAWGLYPHLISTAA(AnyColor, SrcNoEa, TYPE, \
803 NAME_SOLID_DRAWGLYPHLISTAA(TYPE))
804
805 #define REGISTER_SOLID_DRAWGLYPHLISTLCD(TYPE) \
806 REGISTER_DRAWGLYPHLISTLCD(AnyColor, SrcNoEa, TYPE, \
807 NAME_SOLID_DRAWGLYPHLISTLCD(TYPE))
808
809 #define REGISTER_XOR_DRAWGLYPHLIST(TYPE) \
810 REGISTER_DRAWGLYPHLIST(AnyColor, Xor, TYPE, \
811 NAME_XOR_DRAWGLYPHLIST(TYPE)), \
812 REGISTER_DRAWGLYPHLISTAA(AnyColor, Xor, TYPE, \
813 NAME_XOR_DRAWGLYPHLIST(TYPE))
814
815 #define REGISTER_TRANSFORMHELPER_FUNCS(TYPE) \
816 REGISTER_PRIMITIVE(TransformHelper, TYPE, SrcNoEa, IntArgbPre, \
817 (AnyFunc *) &NAME_TRANSFORMHELPER_FUNCS(TYPE))
818
819 #define REGISTER_SOLID_PARALLELOGRAM(TYPE) \
820 REGISTER_PRIMITIVE(FillParallelogram, AnyColor, SrcNoEa, TYPE, \
821 NAME_SOLID_FILLPGRAM(TYPE)), \
822 REGISTER_PRIMITIVE(DrawParallelogram, AnyColor, SrcNoEa, TYPE, \
823 (AnyFunc *) &NAME_SOLID_PGRAM_FUNCS(TYPE))
824
825 #define REGISTER_XOR_PARALLELOGRAM(TYPE) \
826 REGISTER_PRIMITIVE(FillParallelogram, AnyColor, Xor, TYPE, \
827 NAME_XOR_FILLPGRAM(TYPE)), \
828 REGISTER_PRIMITIVE(DrawParallelogram, AnyColor, Xor, TYPE, \
829 (AnyFunc *) &NAME_XOR_PGRAM_FUNCS(TYPE))
830
831 /*
832 * This macro defines an entire function to implement a Blit inner loop
833 * for copying pixels of a common type from one buffer to another.
834 */
835 #define DEFINE_ISOCOPY_BLIT(ANYTYPE) \
836 void NAME_ISOCOPY_BLIT(ANYTYPE)(void *srcBase, void *dstBase, \
837 juint width, juint height, \
838 SurfaceDataRasInfo *pSrcInfo, \
839 SurfaceDataRasInfo *pDstInfo, \
840 NativePrimitive *pPrim, \
841 CompositeInfo *pCompInfo) \
842 { \
843 Declare ## ANYTYPE ## StoreVars(DstWrite) \
844 BlitLoopHeight(ANYTYPE, pSrc, srcBase, pSrcInfo, \
845 ANYTYPE, pDst, dstBase, pDstInfo, DstWrite, \
846 height, \
847 memcpy(pDst, pSrc, width * ANYTYPE ## PixelStride)); \
848 }
849
850 /*
851 * This macro defines an entire function to implement a ScaleBlit inner loop
852 * for scaling pixels of a common type from one buffer to another.
853 */
854 #define DEFINE_ISOSCALE_BLIT(ANYTYPE) \
855 void NAME_ISOSCALE_BLIT(ANYTYPE)(void *srcBase, void *dstBase, \
856 juint width, juint height, \
857 jint sxloc, jint syloc, \
858 jint sxinc, jint syinc, jint shift, \
859 SurfaceDataRasInfo *pSrcInfo, \
860 SurfaceDataRasInfo *pDstInfo, \
861 NativePrimitive *pPrim, \
862 CompositeInfo *pCompInfo) \
863 { \
864 Declare ## ANYTYPE ## StoreVars(DstWrite) \
865 BlitLoopScaleWidthHeight(ANYTYPE, pSrc, srcBase, pSrcInfo, \
866 ANYTYPE, pDst, dstBase, pDstInfo, DstWrite, \
867 x, width, height, \
868 sxloc, syloc, sxinc, syinc, shift, \
869 Copy ## ANYTYPE ## PixelData(pSrc, x, pDst, 0)); \
870 }
871
872 /*
873 * This macro defines an entire function to implement a Blit inner loop
874 * for XORing pixels of a common type from one buffer into another.
875 */
876 #define DEFINE_ISOXOR_BLIT(ANYTYPE) \
877 void NAME_ISOXOR_BLIT(ANYTYPE)(void *srcBase, void *dstBase, \
878 juint width, juint height, \
879 SurfaceDataRasInfo *pSrcInfo, \
880 SurfaceDataRasInfo *pDstInfo, \
881 NativePrimitive *pPrim, \
882 CompositeInfo *pCompInfo) \
883 { \
884 jint xorpixel = pCompInfo->details.xorPixel; \
885 Declare ## ANYTYPE ## PixelData(xor) \
886 Declare ## ANYTYPE ## StoreVars(DstWrite) \
887 \
888 Extract ## ANYTYPE ## PixelData(xorpixel, xor); \
889 \
890 BlitLoopWidthHeight(ANYTYPE, pSrc, srcBase, pSrcInfo, \
891 ANYTYPE, pDst, dstBase, pDstInfo, DstWrite, \
892 width, height, \
893 XorCopy ## ANYTYPE ## PixelData(pSrc, pDst, 0, \
894 xorpixel, xor)); \
895 }
896
897 /*
898 * This macro defines an entire function to implement a Blit inner loop
899 * for converting pixels from a buffer of one type into a buffer of
900 * another type. No blending is done of the pixels.
901 */
902 #define DEFINE_CONVERT_BLIT(SRC, DST, STRATEGY) \
903 void NAME_CONVERT_BLIT(SRC, DST)(void *srcBase, void *dstBase, \
904 juint width, juint height, \
905 SurfaceDataRasInfo *pSrcInfo, \
906 SurfaceDataRasInfo *pDstInfo, \
907 NativePrimitive *pPrim, \
908 CompositeInfo *pCompInfo) \
909 { \
910 Declare ## SRC ## LoadVars(SrcRead) \
911 Declare ## DST ## StoreVars(DstWrite) \
912 \
913 Init ## SRC ## LoadVars(SrcRead, pSrcInfo); \
914 BlitLoopWidthHeight(SRC, pSrc, srcBase, pSrcInfo, \
915 DST, pDst, dstBase, pDstInfo, DstWrite, \
916 width, height, \
917 ConvertVia ## STRATEGY(pSrc, SRC, SrcRead, \
918 pDst, DST, DstWrite, \
919 0, 0)); \
920 }
921
922 /*
923 * This macro defines an entire function to implement a Blit inner loop
924 * for converting pixels from a buffer of byte pixels with a lookup
925 * table into a buffer of another type. No blending is done of the pixels.
926 */
927 #define DEFINE_CONVERT_BLIT_LUT(SRC, DST, LUT_STRATEGY) \
928 void NAME_CONVERT_BLIT(SRC, DST)(void *srcBase, void *dstBase, \
929 juint width, juint height, \
930 SurfaceDataRasInfo *pSrcInfo, \
931 SurfaceDataRasInfo *pDstInfo, \
932 NativePrimitive *pPrim, \
933 CompositeInfo *pCompInfo) \
934 { \
935 Declare ## DST ## StoreVars(DstWrite) \
936 Declare ## LUT_STRATEGY ## Lut(SRC, DST, pixLut) \
937 \
938 Setup ## LUT_STRATEGY ## Lut(SRC, DST, pixLut,\
939 pSrcInfo, pDstInfo); \
940 BlitLoopWidthHeight(SRC, pSrc, srcBase, pSrcInfo, \
941 DST, pDst, dstBase, pDstInfo, DstWrite, \
942 width, height, \
943 Body ## LUT_STRATEGY ## Lut(pSrc, SRC, \
944 pixLut, \
945 pDst, DST, \
946 DstWrite, 0, 0));\
947 }
948 #define DEFINE_CONVERT_BLIT_LUT8(SRC, DST, LUT_STRATEGY) \
949 DEFINE_CONVERT_BLIT_LUT(SRC, DST, LUT_STRATEGY)
950
951 /*
952 * This macro defines an entire function to implement a ScaleBlit inner
953 * loop for scaling and converting pixels from a buffer of one type into
954 * a buffer of another type. No blending is done of the pixels.
955 */
956 #define DEFINE_SCALE_BLIT(SRC, DST, STRATEGY) \
957 void NAME_SCALE_BLIT(SRC, DST)(void *srcBase, void *dstBase, \
958 juint width, juint height, \
959 jint sxloc, jint syloc, \
960 jint sxinc, jint syinc, jint shift, \
961 SurfaceDataRasInfo *pSrcInfo, \
962 SurfaceDataRasInfo *pDstInfo, \
963 NativePrimitive *pPrim, \
964 CompositeInfo *pCompInfo) \
965 { \
966 Declare ## SRC ## LoadVars(SrcRead) \
967 Declare ## DST ## StoreVars(DstWrite) \
968 \
969 Init ## SRC ## LoadVars(SrcRead, pSrcInfo); \
970 BlitLoopScaleWidthHeight(SRC, pSrc, srcBase, pSrcInfo, \
971 DST, pDst, dstBase, pDstInfo, DstWrite, \
972 x, width, height, \
973 sxloc, syloc, sxinc, syinc, shift, \
974 ConvertVia ## STRATEGY(pSrc, SRC, SrcRead, \
975 pDst, DST, DstWrite, \
976 x, 0)); \
977 }
978
979 /*
980 * This macro defines an entire function to implement a ScaleBlit inner
981 * loop for scaling and converting pixels from a buffer of byte pixels
982 * with a lookup table into a buffer of another type. No blending is
983 * done of the pixels.
984 */
985 #define DEFINE_SCALE_BLIT_LUT(SRC, DST, LUT_STRATEGY) \
986 void NAME_SCALE_BLIT(SRC, DST)(void *srcBase, void *dstBase, \
987 juint width, juint height, \
988 jint sxloc, jint syloc, \
989 jint sxinc, jint syinc, jint shift, \
990 SurfaceDataRasInfo *pSrcInfo, \
991 SurfaceDataRasInfo *pDstInfo, \
992 NativePrimitive *pPrim, \
993 CompositeInfo *pCompInfo) \
994 { \
995 Declare ## DST ## StoreVars(DstWrite) \
996 Declare ## LUT_STRATEGY ## Lut(SRC, DST, pixLut) \
997 \
998 Setup ## LUT_STRATEGY ## Lut(SRC, DST, pixLut, pSrcInfo, pDstInfo); \
999 BlitLoopScaleWidthHeight(SRC, pSrc, srcBase, pSrcInfo, \
1000 DST, pDst, dstBase, pDstInfo, DstWrite, \
1001 x, width, height, \
1002 sxloc, syloc, sxinc, syinc, shift, \
1003 Body ## LUT_STRATEGY ## Lut(pSrc, SRC, pixLut, \
1004 pDst, DST, \
1005 DstWrite, x, 0));\
1006 }
1007 #define DEFINE_SCALE_BLIT_LUT8(SRC, DST, LUT_STRATEGY) \
1008 DEFINE_SCALE_BLIT_LUT(SRC, DST, LUT_STRATEGY)
1009
1010 /*
1011 * This macro defines an entire function to implement a Blit inner loop
1012 * for drawing opaque pixels from a buffer of one type onto a buffer of
1013 * another type, ignoring the transparent pixels in the source buffer.
1014 * No blending is done of the pixels - the converted pixel value is
1015 * either copied or the destination is left untouched.
1016 */
1017 #define DEFINE_XPAR_CONVERT_BLIT(SRC, DST, STRATEGY) \
1018 void NAME_XPAR_CONVERT_BLIT(SRC, DST)(void *srcBase, void *dstBase, \
1019 juint width, juint height, \
1020 SurfaceDataRasInfo *pSrcInfo, \
1021 SurfaceDataRasInfo *pDstInfo, \
1022 NativePrimitive *pPrim, \
1023 CompositeInfo *pCompInfo) \
1024 { \
1025 Declare ## SRC ## LoadVars(SrcRead) \
1026 Declare ## DST ## StoreVars(DstWrite) \
1027 \
1028 Init ## SRC ## LoadVars(SrcRead, pSrcInfo); \
1029 BlitLoopWidthHeight(SRC, pSrc, srcBase, pSrcInfo, \
1030 DST, pDst, dstBase, pDstInfo, DstWrite, \
1031 width, height, \
1032 ConvertXparVia ## STRATEGY(pSrc, SRC, SrcRead, \
1033 pDst, DST, DstWrite, \
1034 0, 0)); \
1035 }
1036
1037 /*
1038 * This macro defines an entire function to implement a Blit inner loop
1039 * for converting pixels from a buffer of byte pixels with a lookup
1040 * table containing transparent pixels into a buffer of another type.
1041 * No blending is done of the pixels - the converted pixel value is
1042 * either copied or the destination is left untouched.
1043 */
1044 #define DEFINE_XPAR_CONVERT_BLIT_LUT(SRC, DST, LUT_STRATEGY) \
1045 void NAME_XPAR_CONVERT_BLIT(SRC, DST)(void *srcBase, void *dstBase, \
1046 juint width, juint height, \
1047 SurfaceDataRasInfo *pSrcInfo, \
1048 SurfaceDataRasInfo *pDstInfo, \
1049 NativePrimitive *pPrim, \
1050 CompositeInfo *pCompInfo) \
1051 { \
1052 Declare ## DST ## StoreVars(DstWrite) \
1053 Declare ## LUT_STRATEGY ## XparLut(SRC, DST, pixLut) \
1054 \
1055 Setup ## LUT_STRATEGY ## XparLut(SRC, DST, pixLut, pSrcInfo, pDstInfo); \
1056 BlitLoopWidthHeight(SRC, pSrc, srcBase, pSrcInfo, \
1057 DST, pDst, dstBase, pDstInfo, DstWrite, \
1058 width, height, \
1059 Body ## LUT_STRATEGY ## XparLut(pSrc, SRC, pixLut, \
1060 pDst, DST, \
1061 DstWrite, 0, 0)); \
1062 }
1063 #define DEFINE_XPAR_CONVERT_BLIT_LUT8(SRC, DST, LUT_STRATEGY) \
1064 DEFINE_XPAR_CONVERT_BLIT_LUT(SRC, DST, LUT_STRATEGY)
1065
1066 /*
1067 * This macro defines an entire function to implement a ScaleBlit inner
1068 * loop for scaling and converting pixels from a buffer of byte pixels
1069 * with a lookup table containing transparent pixels into a buffer of
1070 * another type.
1071 * No blending is done of the pixels - the converted pixel value is
1072 * either copied or the destination is left untouched.
1073 */
1074 #define DEFINE_XPAR_SCALE_BLIT_LUT(SRC, DST, LUT_STRATEGY) \
1075 void NAME_XPAR_SCALE_BLIT(SRC, DST)(void *srcBase, void *dstBase, \
1076 juint width, juint height, \
1077 jint sxloc, jint syloc, \
1078 jint sxinc, jint syinc, jint shift, \
1079 SurfaceDataRasInfo *pSrcInfo, \
1080 SurfaceDataRasInfo *pDstInfo, \
1081 NativePrimitive *pPrim, \
1082 CompositeInfo *pCompInfo) \
1083 { \
1084 Declare ## DST ## StoreVars(DstWrite) \
1085 Declare ## LUT_STRATEGY ## XparLut(SRC, DST, pixLut) \
1086 \
1087 Setup ## LUT_STRATEGY ## XparLut(SRC, DST, pixLut, pSrcInfo, pDstInfo); \
1088 BlitLoopScaleWidthHeight(SRC, pSrc, srcBase, pSrcInfo, \
1089 DST, pDst, dstBase, pDstInfo, DstWrite, \
1090 x, width, height, \
1091 sxloc, syloc, sxinc, syinc, shift, \
1092 Body ## LUT_STRATEGY ## XparLut(pSrc, SRC, pixLut, \
1093 pDst, DST, \
1094 DstWrite, \
1095 x, 0)); \
1096 }
1097 #define DEFINE_XPAR_SCALE_BLIT_LUT8(SRC, DST, LUT_STRATEGY) \
1098 DEFINE_XPAR_SCALE_BLIT_LUT(SRC, DST, LUT_STRATEGY)
1099
1100 /*
1101 * This macro defines an entire function to implement a ScaleBlit inner
1102 * loop for scaling and converting pixels from a buffer of one type
1103 * containing transparent pixels into a buffer of another type.
1104 *
1105 * No blending is done of the pixels - the converted pixel value is
1106 * either copied or the destination is left untouched.
1107 */
1108 #define DEFINE_XPAR_SCALE_BLIT(SRC, DST, STRATEGY) \
1109 void NAME_XPAR_SCALE_BLIT(SRC, DST)(void *srcBase, void *dstBase, \
1110 juint width, juint height, \
1111 jint sxloc, jint syloc, \
1112 jint sxinc, jint syinc, jint shift, \
1113 SurfaceDataRasInfo *pSrcInfo, \
1114 SurfaceDataRasInfo *pDstInfo, \
1115 NativePrimitive *pPrim, \
1116 CompositeInfo *pCompInfo) \
1117 { \
1118 Declare ## SRC ## LoadVars(SrcRead) \
1119 Declare ## DST ## StoreVars(DstWrite) \
1120 \
1121 Init ## SRC ## LoadVars(SrcRead, pSrcInfo); \
1122 BlitLoopScaleWidthHeight(SRC, pSrc, srcBase, pSrcInfo, \
1123 DST, pDst, dstBase, pDstInfo, DstWrite, \
1124 x, width, height, \
1125 sxloc, syloc, sxinc, syinc, shift, \
1126 ConvertXparVia ## STRATEGY(pSrc, SRC, SrcRead, \
1127 pDst, DST, DstWrite, \
1128 x, 0)); \
1129 }
1130
1131 /*
1132 * This macro defines an entire function to implement a BlitBg inner loop
1133 * for converting pixels from a buffer of one type containing transparent
1134 * pixels into a buffer of another type with a specified bgcolor for the
1135 * transparent pixels.
1136 * No blending is done of the pixels other than to substitute the
1137 * bgcolor for any transparent pixels.
1138 */
1139 #define DEFINE_XPAR_BLITBG(SRC, DST, STRATEGY) \
1140 void NAME_XPAR_BLITBG(SRC, DST)(void *srcBase, void *dstBase, \
1141 juint width, juint height, \
1142 jint bgpixel, \
1143 SurfaceDataRasInfo *pSrcInfo, \
1144 SurfaceDataRasInfo *pDstInfo, \
1145 NativePrimitive *pPrim, \
1146 CompositeInfo *pCompInfo) \
1147 { \
1148 Declare ## SRC ## LoadVars(SrcRead) \
1149 Declare ## DST ## StoreVars(DstWrite) \
1150 Declare ## DST ## PixelData(bgdata) \
1151 \
1152 Extract ## DST ## PixelData(bgpixel, bgdata); \
1153 BlitLoopWidthHeight(SRC, pSrc, srcBase, pSrcInfo, \
1154 DST, pDst, dstBase, pDstInfo, DstWrite, \
1155 width, height, \
1156 BgCopyXparVia ## STRATEGY(pSrc, SRC, SrcRead, \
1157 pDst, DST, DstWrite, \
1158 0, 0, bgpixel, bgdata)); \
1159 }
1160
1161 /*
1162 * This macro defines an entire function to implement a BlitBg inner loop
1163 * for converting pixels from a buffer of byte pixels with a lookup
1164 * table containing transparent pixels into a buffer of another type
1165 * with a specified bgcolor for the transparent pixels.
1166 * No blending is done of the pixels other than to substitute the
1167 * bgcolor for any transparent pixels.
1168 */
1169 #define DEFINE_XPAR_BLITBG_LUT(SRC, DST, LUT_STRATEGY) \
1170 void NAME_XPAR_BLITBG(SRC, DST)(void *srcBase, void *dstBase, \
1171 juint width, juint height, \
1172 jint bgpixel, \
1173 SurfaceDataRasInfo *pSrcInfo, \
1174 SurfaceDataRasInfo *pDstInfo, \
1175 NativePrimitive *pPrim, \
1176 CompositeInfo *pCompInfo) \
1177 { \
1178 Declare ## DST ## StoreVars(DstWrite) \
1179 Declare ## LUT_STRATEGY ## BgLut(SRC, DST, pixLut) \
1180 \
1181 Setup ## LUT_STRATEGY ## BgLut(SRC, DST, pixLut, pSrcInfo, pDstInfo, \
1182 bgpixel); \
1183 BlitLoopWidthHeight(SRC, pSrc, srcBase, pSrcInfo, \
1184 DST, pDst, dstBase, pDstInfo, DstWrite, \
1185 width, height, \
1186 Body ## LUT_STRATEGY ## BgLut(pSrc, SRC, pixLut, \
1187 pDst, DST, \
1188 DstWrite, 0, 0, \
1189 bgpixel)); \
1190 }
1191 #define DEFINE_XPAR_BLITBG_LUT8(SRC, DST, LUT_STRATEGY) \
1192 DEFINE_XPAR_BLITBG_LUT(SRC, DST, LUT_STRATEGY)
1193
1194 /*
1195 * This macro defines an entire function to implement a Blit inner loop
1196 * for converting pixels from a buffer of one type into a buffer of
1197 * another type. Each source pixel is XORed with the current XOR color value.
1198 * That result is then XORed with the destination pixel and the final
1199 * result is stored in the destination surface.
1200 */
1201 #define DEFINE_XOR_BLIT(SRC, DST, DSTANYTYPE) \
1202 void NAME_XOR_BLIT(SRC, DST)(void *srcBase, void *dstBase, \
1203 juint width, juint height, \
1204 SurfaceDataRasInfo *pSrcInfo, \
1205 SurfaceDataRasInfo *pDstInfo, \
1206 NativePrimitive *pPrim, \
1207 CompositeInfo *pCompInfo) \
1208 { \
1209 jint xorpixel = pCompInfo->details.xorPixel; \
1210 juint alphamask = pCompInfo->alphaMask; \
1211 Declare ## DSTANYTYPE ## PixelData(xor) \
1212 Declare ## DSTANYTYPE ## PixelData(mask) \
1213 Declare ## SRC ## LoadVars(SrcRead) \
1214 Declare ## DST ## StoreVars(DstWrite) \
1215 \
1216 Extract ## DSTANYTYPE ## PixelData(xorpixel, xor); \
1217 Extract ## DSTANYTYPE ## PixelData(alphamask, mask); \
1218 \
1219 Init ## SRC ## LoadVars(SrcRead, pSrcInfo); \
1220 BlitLoopWidthHeight(SRC, pSrc, srcBase, pSrcInfo, \
1221 DST, pDst, dstBase, pDstInfo, DstWrite, \
1222 width, height, \
1223 XorVia1IntArgb(pSrc, SRC, SrcRead, \
1224 pDst, DST, DSTANYTYPE, \
1225 0, xorpixel, xor, \
1226 alphamask, mask, pDstInfo)); \
1227 }
1228
1229 /*
1230 * This macro defines an entire function to implement a FillRect inner loop
1231 * for setting a rectangular region of pixels to a specific pixel value.
1232 * No blending of the fill color is done with the pixels.
1233 */
1234 #define DEFINE_SOLID_FILLRECT(DST) \
1235 void NAME_SOLID_FILLRECT(DST)(SurfaceDataRasInfo *pRasInfo, \
1236 jint lox, jint loy, \
1237 jint hix, jint hiy, \
1238 jint pixel, \
1239 NativePrimitive *pPrim, \
1240 CompositeInfo *pCompInfo) \
1241 { \
1242 Declare ## DST ## PixelData(pix) \
1243 DST ## DataType *pPix; \
1244 jint scan = pRasInfo->scanStride; \
1245 juint height = hiy - loy; \
1246 juint width = hix - lox; \
1247 \
1248 pPix = PtrCoord(pRasInfo->rasBase, lox, DST ## PixelStride, loy, scan); \
1249 Extract ## DST ## PixelData(pixel, pix); \
1250 do { \
1251 juint x = 0; \
1252 do { \
1253 Store ## DST ## PixelData(pPix, x, pixel, pix); \
1254 } while (++x < width); \
1255 pPix = PtrAddBytes(pPix, scan); \
1256 } while (--height > 0); \
1257 }
1258
1259 /*
1260 * This macro defines an entire function to implement a FillSpans inner loop
1261 * for iterating through a list of spans and setting those regions of pixels
1262 * to a specific pixel value. No blending of the fill color is done with
1263 * the pixels.
1264 */
1265 #define DEFINE_SOLID_FILLSPANS(DST) \
1266 void NAME_SOLID_FILLSPANS(DST)(SurfaceDataRasInfo *pRasInfo, \
1267 SpanIteratorFuncs *pSpanFuncs, void *siData, \
1268 jint pixel, NativePrimitive *pPrim, \
1269 CompositeInfo *pCompInfo) \
1270 { \
1271 void *pBase = pRasInfo->rasBase; \
1272 Declare ## DST ## PixelData(pix) \
1273 jint scan = pRasInfo->scanStride; \
1274 jint bbox[4]; \
1275 \
1276 Extract ## DST ## PixelData(pixel, pix); \
1277 while ((*pSpanFuncs->nextSpan)(siData, bbox)) { \
1278 jint x = bbox[0]; \
1279 jint y = bbox[1]; \
1280 juint w = bbox[2] - x; \
1281 juint h = bbox[3] - y; \
1282 DST ## DataType *pPix = PtrCoord(pBase, \
1283 x, DST ## PixelStride, \
1284 y, scan); \
1285 do { \
1286 juint relx; \
1287 for (relx = 0; relx < w; relx++) { \
1288 Store ## DST ## PixelData(pPix, relx, pixel, pix); \
1289 } \
1290 pPix = PtrAddBytes(pPix, scan); \
1291 } while (--h > 0); \
1292 } \
1293 }
1294
1295 /*
1296 * This macro defines an entire function to implement a FillParallelogram
1297 * inner loop for tracing 2 diagonal edges (left and right) and setting
1298 * those regions of pixels between them to a specific pixel value.
1299 * No blending of the fill color is done with the pixels.
1300 */
1301 #define DEFINE_SOLID_FILLPGRAM(DST) \
1302 void NAME_SOLID_FILLPGRAM(DST)(SurfaceDataRasInfo *pRasInfo, \
1303 jint lox, jint loy, jint hix, jint hiy, \
1304 jlong leftx, jlong dleftx, \
1305 jlong rightx, jlong drightx, \
1306 jint pixel, struct _NativePrimitive *pPrim, \
1307 CompositeInfo *pCompInfo) \
1308 { \
1309 Declare ## DST ## PixelData(pix) \
1310 jint scan = pRasInfo->scanStride; \
1311 DST ## DataType *pPix = PtrCoord(pRasInfo->rasBase, 0, 0, loy, scan); \
1312 \
1313 Extract ## DST ## PixelData(pixel, pix); \
1314 while (loy < hiy) { \
1315 jint lx = WholeOfLong(leftx); \
1316 jint rx = WholeOfLong(rightx); \
1317 if (lx < lox) lx = lox; \
1318 if (rx > hix) rx = hix; \
1319 while (lx < rx) { \
1320 Store ## DST ## PixelData(pPix, lx, pixel, pix); \
1321 lx++; \
1322 } \
1323 pPix = PtrAddBytes(pPix, scan); \
1324 leftx += dleftx; \
1325 rightx += drightx; \
1326 loy++; \
1327 } \
1328 }
1329
1330 #define DEFINE_SOLID_DRAWPARALLELOGRAM_FUNCS(DST) \
1331 DrawParallelogramFuncs NAME_SOLID_PGRAM_FUNCS(DST) = { \
1332 NAME_SOLID_FILLPGRAM(DST), \
1333 NAME_SOLID_DRAWLINE(DST), \
1334 };
1335
1336 #define DEFINE_SOLID_PARALLELOGRAM(DST) \
1337 DEFINE_SOLID_FILLPGRAM(DST) \
1338 DEFINE_SOLID_DRAWPARALLELOGRAM_FUNCS(DST)
1339
1340 /*
1341 * This macro declares the bumpmajor and bumpminor variables used for the
1342 * DrawLine functions.
1343 */
1344 #define DeclareBumps(BUMPMAJOR, BUMPMINOR) \
1345 jint BUMPMAJOR, BUMPMINOR;
1346
1347 /*
1348 * This macro extracts "instructions" from the bumpmajor and bumpminor masks
1349 * that determine the initial bumpmajor and bumpminor values. The bumpmajor
1350 * and bumpminor masks are laid out in the following format:
1351 *
1352 * bumpmajormask: bumpminormask:
1353 * bit0: bumpmajor = pixelStride bit0: bumpminor = pixelStride
1354 * bit1: bumpmajor = -pixelStride bit1: bumpminor = -pixelStride
1355 * bit2: bumpmajor = scanStride bit2: bumpminor = scanStride
1356 * bit3: bumpmajor = -scanStride bit3: bumpminor = -scanStride
1357 */
1358 #define InitBumps(BUMPMAJOR, BUMPMINOR, \
1359 BUMPMAJORMASK, BUMPMINORMASK, \
1360 PIXELSTRIDE, SCANSTRIDE) \
1361 BUMPMAJOR = (BUMPMAJORMASK & BUMP_POS_PIXEL) ? PIXELSTRIDE : \
1362 (BUMPMAJORMASK & BUMP_NEG_PIXEL) ? -PIXELSTRIDE : \
1363 (BUMPMAJORMASK & BUMP_POS_SCAN) ? SCANSTRIDE : \
1364 -SCANSTRIDE; \
1365 BUMPMINOR = (BUMPMINORMASK & BUMP_POS_PIXEL) ? PIXELSTRIDE : \
1366 (BUMPMINORMASK & BUMP_NEG_PIXEL) ? -PIXELSTRIDE : \
1367 (BUMPMINORMASK & BUMP_POS_SCAN) ? SCANSTRIDE : \
1368 (BUMPMINORMASK & BUMP_NEG_SCAN) ? -SCANSTRIDE : \
1369 0; \
1370 BUMPMINOR += BUMPMAJOR;
1371
1372 /*
1373 * This macro defines an entire function to implement a DrawLine inner loop
1374 * for iterating along a horizontal or vertical line and setting the pixels
1375 * on that line to a specific pixel value. No blending of the fill color
1376 * is done with the pixels.
1377 */
1378 #define DEFINE_SOLID_DRAWLINE(DST) \
1379 void NAME_SOLID_DRAWLINE(DST)(SurfaceDataRasInfo *pRasInfo, \
1380 jint x1, jint y1, jint pixel, \
1381 jint steps, jint error, \
1382 jint bumpmajormask, jint errmajor, \
1383 jint bumpminormask, jint errminor, \
1384 NativePrimitive *pPrim, \
1385 CompositeInfo *pCompInfo) \
1386 { \
1387 Declare ## DST ## PixelData(pix) \
1388 jint scan = pRasInfo->scanStride; \
1389 DST ## DataType *pPix = PtrCoord(pRasInfo->rasBase, \
1390 x1, DST ## PixelStride, \
1391 y1, scan); \
1392 DeclareBumps(bumpmajor, bumpminor) \
1393 \
1394 InitBumps(bumpmajor, bumpminor, bumpmajormask, bumpminormask, \
1395 DST ## PixelStride, scan); \
1396 Extract ## DST ## PixelData(pixel, pix); \
1397 if (errmajor == 0) { \
1398 do { \
1399 Store ## DST ## PixelData(pPix, 0, pixel, pix); \
1400 pPix = PtrAddBytes(pPix, bumpmajor); \
1401 } while (--steps > 0); \
1402 } else { \
1403 do { \
1404 Store ## DST ## PixelData(pPix, 0, pixel, pix); \
1405 if (error < 0) { \
1406 pPix = PtrAddBytes(pPix, bumpmajor); \
1407 error += errmajor; \
1408 } else { \
1409 pPix = PtrAddBytes(pPix, bumpminor); \
1410 error -= errminor; \
1411 } \
1412 } while (--steps > 0); \
1413 } \
1414 }
1415
1416 /*
1417 * This macro defines an entire function to implement a FillRect inner loop
1418 * for setting a rectangular region of pixels to a specific pixel value.
1419 * Each destination pixel is XORed with the current XOR mode color as well as
1420 * the current fill color.
1421 */
1422 #define DEFINE_XOR_FILLRECT(DST) \
1423 void NAME_XOR_FILLRECT(DST)(SurfaceDataRasInfo *pRasInfo, \
1424 jint lox, jint loy, \
1425 jint hix, jint hiy, \
1426 jint pixel, \
1427 NativePrimitive *pPrim, \
1428 CompositeInfo *pCompInfo) \
1429 { \
1430 jint xorpixel = pCompInfo->details.xorPixel; \
1431 juint alphamask = pCompInfo->alphaMask; \
1432 Declare ## DST ## PixelData(xor) \
1433 Declare ## DST ## PixelData(pix) \
1434 Declare ## DST ## PixelData(mask) \
1435 DST ## DataType *pPix; \
1436 jint scan = pRasInfo->scanStride; \
1437 juint height = hiy - loy; \
1438 juint width = hix - lox; \
1439 \
1440 pPix = PtrCoord(pRasInfo->rasBase, lox, DST ## PixelStride, loy, scan); \
1441 Extract ## DST ## PixelData(xorpixel, xor); \
1442 Extract ## DST ## PixelData(pixel, pix); \
1443 Extract ## DST ## PixelData(alphamask, mask); \
1444 \
1445 do { \
1446 juint x = 0; \
1447 do { \
1448 Xor ## DST ## PixelData(pixel, pix, pPix, x, \
1449 xorpixel, xor, alphamask, mask); \
1450 } while (++x < width); \
1451 pPix = PtrAddBytes(pPix, scan); \
1452 } while (--height > 0); \
1453 }
1454
1455 /*
1456 * This macro defines an entire function to implement a FillSpans inner loop
1457 * for iterating through a list of spans and setting those regions of pixels
1458 * to a specific pixel value. Each destination pixel is XORed with the
1459 * current XOR mode color as well as the current fill color.
1460 */
1461 #define DEFINE_XOR_FILLSPANS(DST) \
1462 void NAME_XOR_FILLSPANS(DST)(SurfaceDataRasInfo *pRasInfo, \
1463 SpanIteratorFuncs *pSpanFuncs, \
1464 void *siData, jint pixel, \
1465 NativePrimitive *pPrim, \
1466 CompositeInfo *pCompInfo) \
1467 { \
1468 void *pBase = pRasInfo->rasBase; \
1469 jint xorpixel = pCompInfo->details.xorPixel; \
1470 juint alphamask = pCompInfo->alphaMask; \
1471 Declare ## DST ## PixelData(xor) \
1472 Declare ## DST ## PixelData(pix) \
1473 Declare ## DST ## PixelData(mask) \
1474 jint scan = pRasInfo->scanStride; \
1475 jint bbox[4]; \
1476 \
1477 Extract ## DST ## PixelData(xorpixel, xor); \
1478 Extract ## DST ## PixelData(pixel, pix); \
1479 Extract ## DST ## PixelData(alphamask, mask); \
1480 \
1481 while ((*pSpanFuncs->nextSpan)(siData, bbox)) { \
1482 jint x = bbox[0]; \
1483 jint y = bbox[1]; \
1484 juint w = bbox[2] - x; \
1485 juint h = bbox[3] - y; \
1486 DST ## DataType *pPix = PtrCoord(pBase, \
1487 x, DST ## PixelStride, \
1488 y, scan); \
1489 do { \
1490 juint relx; \
1491 for (relx = 0; relx < w; relx++) { \
1492 Xor ## DST ## PixelData(pixel, pix, pPix, relx, \
1493 xorpixel, xor, alphamask, mask); \
1494 } \
1495 pPix = PtrAddBytes(pPix, scan); \
1496 } while (--h > 0); \
1497 } \
1498 }
1499
1500 /*
1501 * This macro defines an entire function to implement a DrawLine inner loop
1502 * for iterating along a horizontal or vertical line and setting the pixels
1503 * on that line to a specific pixel value. Each destination pixel is XORed
1504 * with the current XOR mode color as well as the current draw color.
1505 */
1506 #define DEFINE_XOR_DRAWLINE(DST) \
1507 void NAME_XOR_DRAWLINE(DST)(SurfaceDataRasInfo *pRasInfo, \
1508 jint x1, jint y1, jint pixel, \
1509 jint steps, jint error, \
1510 jint bumpmajormask, jint errmajor, \
1511 jint bumpminormask, jint errminor, \
1512 NativePrimitive *pPrim, \
1513 CompositeInfo *pCompInfo) \
1514 { \
1515 jint xorpixel = pCompInfo->details.xorPixel; \
1516 juint alphamask = pCompInfo->alphaMask; \
1517 Declare ## DST ## PixelData(xor) \
1518 Declare ## DST ## PixelData(pix) \
1519 Declare ## DST ## PixelData(mask) \
1520 jint scan = pRasInfo->scanStride; \
1521 DST ## DataType *pPix = PtrCoord(pRasInfo->rasBase, \
1522 x1, DST ## PixelStride, \
1523 y1, scan); \
1524 DeclareBumps(bumpmajor, bumpminor) \
1525 \
1526 InitBumps(bumpmajor, bumpminor, bumpmajormask, bumpminormask, \
1527 DST ## PixelStride, scan); \
1528 Extract ## DST ## PixelData(xorpixel, xor); \
1529 Extract ## DST ## PixelData(pixel, pix); \
1530 Extract ## DST ## PixelData(alphamask, mask); \
1531 \
1532 if (errmajor == 0) { \
1533 do { \
1534 Xor ## DST ## PixelData(pixel, pix, pPix, 0, \
1535 xorpixel, xor, alphamask, mask); \
1536 pPix = PtrAddBytes(pPix, bumpmajor); \
1537 } while (--steps > 0); \
1538 } else { \
1539 do { \
1540 Xor ## DST ## PixelData(pixel, pix, pPix, 0, \
1541 xorpixel, xor, alphamask, mask); \
1542 if (error < 0) { \
1543 pPix = PtrAddBytes(pPix, bumpmajor); \
1544 error += errmajor; \
1545 } else { \
1546 pPix = PtrAddBytes(pPix, bumpminor); \
1547 error -= errminor; \
1548 } \
1549 } while (--steps > 0); \
1550 } \
1551 }
1552
1553 /*
1554 * This macro is used to declare the variables needed by the glyph clipping
1555 * macro.
1556 */
1557 #define DeclareDrawGlyphListClipVars(PIXELS, ROWBYTES, WIDTH, HEIGHT, \
1558 LEFT, TOP, RIGHT, BOTTOM) \
1559 const jubyte * PIXELS; \
1560 int ROWBYTES; \
1561 int LEFT, TOP; \
1562 int WIDTH, HEIGHT; \
1563 int RIGHT, BOTTOM;
1564
1565 /*
1566 * This macro represents the glyph clipping code used in the various
1567 * DRAWGLYPHLIST macros. This macro is typically used within a loop. Note
1568 * that the body of this macro is NOT wrapped in a do..while block due to
1569 * the use of continue statements within the block (those continue statements
1570 * are intended skip the outer loop, not the do..while loop). To combat this
1571 * problem, pass in the code (typically a continue statement) that should be
1572 * executed when a null glyph is encountered.
1573 */
1574 #define ClipDrawGlyphList(DST, PIXELS, BYTESPERPIXEL, ROWBYTES, WIDTH, HEIGHT,\
1575 LEFT, TOP, RIGHT, BOTTOM, \
1576 CLIPLEFT, CLIPTOP, CLIPRIGHT, CLIPBOTTOM, \
1577 GLYPHS, GLYPHCOUNTER, NULLGLYPHCODE) \
1578 PIXELS = (const jubyte *)GLYPHS[GLYPHCOUNTER].pixels; \
1579 if (!PIXELS) { \
1580 NULLGLYPHCODE; \
1581 } \
1582 ROWBYTES = GLYPHS[GLYPHCOUNTER].rowBytes; \
1583 LEFT = GLYPHS[GLYPHCOUNTER].x; \
1584 TOP = GLYPHS[GLYPHCOUNTER].y; \
1585 WIDTH = GLYPHS[GLYPHCOUNTER].width; \
1586 HEIGHT = GLYPHS[GLYPHCOUNTER].height; \
1587 \
1588 /* if any clipping required, modify parameters now */ \
1589 RIGHT = LEFT + WIDTH; \
1590 BOTTOM = TOP + HEIGHT; \
1591 if (LEFT < CLIPLEFT) { \
1592 /* Multiply needed for LCD text as PIXELS is really BYTES */ \
1593 PIXELS += (CLIPLEFT - LEFT) * BYTESPERPIXEL ; \
1594 LEFT = CLIPLEFT; \
1595 } \
1596 if (TOP < CLIPTOP) { \
1597 PIXELS += (CLIPTOP - TOP) * ROWBYTES; \
1598 TOP = CLIPTOP; \
1599 } \
1600 if (RIGHT > CLIPRIGHT) { \
1601 RIGHT = CLIPRIGHT; \
1602 } \
1603 if (BOTTOM > CLIPBOTTOM) { \
1604 BOTTOM = CLIPBOTTOM; \
1605 } \
1606 if (RIGHT <= LEFT || BOTTOM <= TOP) { \
1607 NULLGLYPHCODE; \
1608 } \
1609 WIDTH = RIGHT - LEFT; \
1610 HEIGHT = BOTTOM - TOP;
1611
1612 #define DEFINE_SOLID_DRAWGLYPHLIST(DST) \
1613 void NAME_SOLID_DRAWGLYPHLIST(DST)(SurfaceDataRasInfo *pRasInfo, \
1614 ImageRef *glyphs, \
1615 jint totalGlyphs, jint fgpixel, \
1616 jint argbcolor, \
1617 jint clipLeft, jint clipTop, \
1618 jint clipRight, jint clipBottom, \
1619 NativePrimitive *pPrim, \
1620 CompositeInfo *pCompInfo) \
1621 { \
1622 jint glyphCounter; \
1623 jint scan = pRasInfo->scanStride; \
1624 Declare ## DST ## PixelData(pix) \
1625 DST ## DataType *pPix; \
1626 \
1627 Extract ## DST ## PixelData(fgpixel, pix); \
1628 for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) { \
1629 DeclareDrawGlyphListClipVars(pixels, rowBytes, width, height, \
1630 left, top, right, bottom) \
1631 ClipDrawGlyphList(DST, pixels, 1, rowBytes, width, height, \
1632 left, top, right, bottom, \
1633 clipLeft, clipTop, clipRight, clipBottom, \
1634 glyphs, glyphCounter, continue) \
1635 pPix = PtrCoord(pRasInfo->rasBase,left,DST ## PixelStride,top,scan); \
1636 \
1637 do { \
1638 int x = 0; \
1639 do { \
1640 if (pixels[x]) { \
1641 Store ## DST ## PixelData(pPix, x, fgpixel, pix); \
1642 } \
1643 } while (++x < width); \
1644 pPix = PtrAddBytes(pPix, scan); \
1645 pixels += rowBytes; \
1646 } while (--height > 0); \
1647 } \
1648 }
1649
1650 #define GlyphListAABlend3ByteRgb(DST, GLYPH_PIXELS, PIXEL_INDEX, DST_PTR, \
1651 FG_PIXEL, PREFIX, SRC_PREFIX) \
1652 do { \
1653 DeclareCompVarsFor3ByteRgb(dst) \
1654 jint mixValSrc = GLYPH_PIXELS[PIXEL_INDEX]; \
1655 if (mixValSrc) { \
1656 if (mixValSrc < 255) { \
1657 jint mixValDst = 255 - mixValSrc; \
1658 Load ## DST ## To3ByteRgb(DST_PTR, pix, PIXEL_INDEX, \
1659 dstR, dstG, dstB); \
1660 MultMultAddAndStore3ByteRgbComps(dst, mixValDst, dst, \
1661 mixValSrc, SRC_PREFIX); \
1662 Store ## DST ## From3ByteRgb(DST_PTR, pix, PIXEL_INDEX, \
1663 dstR, dstG, dstB); \
1664 } else { \
1665 Store ## DST ## PixelData(DST_PTR, PIXEL_INDEX, \
1666 FG_PIXEL, PREFIX); \
1667 } \
1668 } \
1669 } while (0);
1670
1671 #define GlyphListAABlend4ByteArgb(DST, GLYPH_PIXELS, PIXEL_INDEX, DST_PTR, \
1672 FG_PIXEL, PREFIX, SRC_PREFIX) \
1673 do { \
1674 DeclareAlphaVarFor4ByteArgb(dstA) \
1675 DeclareCompVarsFor4ByteArgb(dst) \
1676 jint mixValSrc = GLYPH_PIXELS[PIXEL_INDEX]; \
1677 if (mixValSrc) { \
1678 if (mixValSrc < 255) { \
1679 jint mixValDst = 255 - mixValSrc; \
1680 Load ## DST ## To4ByteArgb(DST_PTR, pix, PIXEL_INDEX, \
1681 dstA, dstR, dstG, dstB); \
1682 dstA = MUL8(dstA, mixValDst) + \
1683 MUL8(SRC_PREFIX ## A, mixValSrc); \
1684 MultMultAddAndStore4ByteArgbComps(dst, mixValDst, dst, \
1685 mixValSrc, SRC_PREFIX); \
1686 if (!(DST ## IsOpaque) && \
1687 !(DST ## IsPremultiplied) && dstA && dstA < 255) { \
1688 DivideAndStore4ByteArgbComps(dst, dst, dstA); \
1689 } \
1690 Store ## DST ## From4ByteArgbComps(DST_PTR, pix, \
1691 PIXEL_INDEX, dst); \
1692 } else { \
1693 Store ## DST ## PixelData(DST_PTR, PIXEL_INDEX, \
1694 FG_PIXEL, PREFIX); \
1695 } \
1696 } \
1697 } while (0);
1698
1699 #define GlyphListAABlend1ByteGray(DST, GLYPH_PIXELS, PIXEL_INDEX, DST_PTR, \
1700 FG_PIXEL, PREFIX, SRC_PREFIX) \
1701 do { \
1702 DeclareCompVarsFor1ByteGray(dst) \
1703 jint mixValSrc = GLYPH_PIXELS[PIXEL_INDEX]; \
1704 if (mixValSrc) { \
1705 if (mixValSrc < 255) { \
1706 jint mixValDst = 255 - mixValSrc; \
1707 Load ## DST ## To1ByteGray(DST_PTR, pix, PIXEL_INDEX, \
1708 dstG); \
1709 MultMultAddAndStore1ByteGrayComps(dst, mixValDst, dst, \
1710 mixValSrc, SRC_PREFIX); \
1711 Store ## DST ## From1ByteGray(DST_PTR, pix, PIXEL_INDEX, \
1712 dstG); \
1713 } else { \
1714 Store ## DST ## PixelData(DST_PTR, PIXEL_INDEX, \
1715 FG_PIXEL, PREFIX); \
1716 } \
1717 } \
1718 } while (0);
1719
1720 #define GlyphListAABlend1ShortGray(DST, GLYPH_PIXELS, PIXEL_INDEX, DST_PTR, \
1721 FG_PIXEL, PREFIX, SRC_PREFIX) \
1722 do { \
1723 DeclareCompVarsFor1ShortGray(dst) \
1724 juint mixValSrc = GLYPH_PIXELS[PIXEL_INDEX]; \
1725 if (mixValSrc) { \
1726 if (mixValSrc < 255) { \
1727 juint mixValDst; \
1728 PromoteByteAlphaFor1ShortGray(mixValSrc); \
1729 mixValDst = 0xffff - mixValSrc; \
1730 Load ## DST ## To1ShortGray(DST_PTR, pix, PIXEL_INDEX, \
1731 dstG); \
1732 MultMultAddAndStore1ShortGrayComps(dst, mixValDst, dst, \
1733 mixValSrc, SRC_PREFIX); \
1734 Store ## DST ## From1ShortGray(DST_PTR, pix, PIXEL_INDEX, \
1735 dstG); \
1736 } else { \
1737 Store ## DST ## PixelData(DST_PTR, PIXEL_INDEX, \
1738 FG_PIXEL, PREFIX); \
1739 } \
1740 } \
1741 } while (0);
1742
1743 #define DEFINE_SOLID_DRAWGLYPHLISTAA(DST, STRATEGY) \
1744 void NAME_SOLID_DRAWGLYPHLISTAA(DST)(SurfaceDataRasInfo *pRasInfo, \
1745 ImageRef *glyphs, \
1746 jint totalGlyphs, jint fgpixel, \
1747 jint argbcolor, \
1748 jint clipLeft, jint clipTop, \
1749 jint clipRight, jint clipBottom, \
1750 NativePrimitive *pPrim, \
1751 CompositeInfo *pCompInfo) \
1752 { \
1753 jint glyphCounter; \
1754 jint scan = pRasInfo->scanStride; \
1755 DST ## DataType *pPix; \
1756 Declare ## DST ## PixelData(solidpix) \
1757 DeclareAlphaVarFor ## STRATEGY(srcA) \
1758 DeclareCompVarsFor ## STRATEGY(src) \
1759 \
1760 Declare ## DST ## LoadVars(pix) \
1761 Declare ## DST ## StoreVars(pix) \
1762 \
1763 Init ## DST ## LoadVars(pix, pRasInfo); \
1764 Init ## DST ## StoreVarsY(pix, pRasInfo); \
1765 Init ## DST ## StoreVarsX(pix, pRasInfo); \
1766 Extract ## STRATEGY ## CompsAndAlphaFromArgb(argbcolor, src); \
1767 Extract ## DST ## PixelData(fgpixel, solidpix); \
1768 \
1769 for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) { \
1770 DeclareDrawGlyphListClipVars(pixels, rowBytes, width, height, \
1771 left, top, right, bottom) \
1772 ClipDrawGlyphList(DST, pixels, 1, rowBytes, width, height, \
1773 left, top, right, bottom, \
1774 clipLeft, clipTop, clipRight, clipBottom, \
1775 glyphs, glyphCounter, continue) \
1776 pPix = PtrCoord(pRasInfo->rasBase,left,DST ## PixelStride,top,scan); \
1777 \
1778 Set ## DST ## StoreVarsYPos(pix, pRasInfo, top); \
1779 do { \
1780 int x = 0; \
1781 Set ## DST ## StoreVarsXPos(pix, pRasInfo, left); \
1782 do { \
1783 GlyphListAABlend ## STRATEGY(DST, pixels, x, pPix, \
1784 fgpixel, solidpix, src); \
1785 Next ## DST ## StoreVarsX(pix); \
1786 } while (++x < width); \
1787 pPix = PtrAddBytes(pPix, scan); \
1788 pixels += rowBytes; \
1789 Next ## DST ## StoreVarsY(pix); \
1790 } while (--height > 0); \
1791 } \
1792 }
1793
1794
1795 #define GlyphListLCDBlend3ByteRgb(DST, GLYPH_PIXELS, PIXEL_INDEX, DST_PTR, \
1796 FG_PIXEL, PREFIX, SRC_PREFIX) \
1797 do { \
1798 DeclareCompVarsFor3ByteRgb(dst) \
1799 jint mixValSrcG = GLYPH_PIXELS[PIXEL_INDEX*3+1]; \
1800 jint mixValSrcR, mixValSrcB; \
1801 if (rgbOrder) { \
1802 mixValSrcR = GLYPH_PIXELS[PIXEL_INDEX*3]; \
1803 mixValSrcB = GLYPH_PIXELS[PIXEL_INDEX*3+2]; \
1804 } else { \
1805 mixValSrcR = GLYPH_PIXELS[PIXEL_INDEX*3+2]; \
1806 mixValSrcB = GLYPH_PIXELS[PIXEL_INDEX*3]; \
1807 } \
1808 if ((mixValSrcR | mixValSrcG | mixValSrcB) != 0) { \
1809 if ((mixValSrcR & mixValSrcG & mixValSrcB) < 255) { \
1810 jint mixValDstR = 255 - mixValSrcR; \
1811 jint mixValDstG = 255 - mixValSrcG; \
1812 jint mixValDstB = 255 - mixValSrcB; \
1813 Load ## DST ## To3ByteRgb(DST_PTR, pix, PIXEL_INDEX, \
1814 dstR, dstG, dstB); \
1815 dstR = invGammaLut[dstR]; \
1816 dstG = invGammaLut[dstG]; \
1817 dstB = invGammaLut[dstB]; \
1818 MultMultAddAndStoreLCD3ByteRgbComps(dst, mixValDst, dst, \
1819 mixValSrc, SRC_PREFIX); \
1820 dstR = gammaLut[dstR]; \
1821 dstG = gammaLut[dstG]; \
1822 dstB = gammaLut[dstB]; \
1823 Store ## DST ## From3ByteRgb(DST_PTR, pix, PIXEL_INDEX, \
1824 dstR, dstG, dstB); \
1825 } else { \
1826 Store ## DST ## PixelData(DST_PTR, PIXEL_INDEX, \
1827 FG_PIXEL, PREFIX); \
1828 } \
1829 } \
1830 } while (0)
1831
1832
1833 /* There is no alpha channel in the glyph data with which to interpolate
1834 * between the src and dst alphas, but a reasonable approximation is to
1835 * sum the coverage alphas of the colour channels and divide by 3.
1836 * We can approximate division by 3 using mult and shift. See
1837 * sun/font/scalerMethods.c for a detailed explanation of why "21931"
1838 */
1839 #define GlyphListLCDBlend4ByteArgb(DST, GLYPH_PIXELS, PIXEL_INDEX, DST_PTR, \
1840 FG_PIXEL, PREFIX, SRC_PREFIX) \
1841 do { \
1842 DeclareAlphaVarFor4ByteArgb(dstA) \
1843 DeclareCompVarsFor4ByteArgb(dst) \
1844 jint mixValSrcG = GLYPH_PIXELS[PIXEL_INDEX*3+1]; \
1845 jint mixValSrcR, mixValSrcB; \
1846 if (rgbOrder) { \
1847 mixValSrcR = GLYPH_PIXELS[PIXEL_INDEX*3]; \
1848 mixValSrcB = GLYPH_PIXELS[PIXEL_INDEX*3+2]; \
1849 } else { \
1850 mixValSrcR = GLYPH_PIXELS[PIXEL_INDEX*3+2]; \
1851 mixValSrcB = GLYPH_PIXELS[PIXEL_INDEX*3]; \
1852 } \
1853 if ((mixValSrcR | mixValSrcG | mixValSrcB) != 0) { \
1854 if ((mixValSrcR & mixValSrcG & mixValSrcB) < 255) { \
1855 jint mixValDstR = 255 - mixValSrcR; \
1856 jint mixValDstG = 255 - mixValSrcG; \
1857 jint mixValDstB = 255 - mixValSrcB; \
1858 jint mixValSrcA = ((mixValSrcR + mixValSrcG + mixValSrcB) \
1859 * 21931) >> 16;\
1860 jint mixValDstA = 255 - mixValSrcA; \
1861 Load ## DST ## To4ByteArgb(DST_PTR, pix, PIXEL_INDEX, \
1862 dstA, dstR, dstG, dstB); \
1863 dstR = invGammaLut[dstR]; \
1864 dstG = invGammaLut[dstG]; \
1865 dstB = invGammaLut[dstB]; \
1866 dstA = MUL8(dstA, mixValDstA) + \
1867 MUL8(SRC_PREFIX ## A, mixValSrcA); \
1868 MultMultAddAndStoreLCD4ByteArgbComps(dst, mixValDst, dst, \
1869 mixValSrc, SRC_PREFIX); \
1870 dstR = gammaLut[dstR]; \
1871 dstG = gammaLut[dstG]; \
1872 dstB = gammaLut[dstB]; \
1873 if (!(DST ## IsOpaque) && \
1874 !(DST ## IsPremultiplied) && dstA && dstA < 255) { \
1875 DivideAndStore4ByteArgbComps(dst, dst, dstA); \
1876 } \
1877 Store ## DST ## From4ByteArgbComps(DST_PTR, pix, \
1878 PIXEL_INDEX, dst); \
1879 } else { \
1880 Store ## DST ## PixelData(DST_PTR, PIXEL_INDEX, \
1881 FG_PIXEL, PREFIX); \
1882 } \
1883 } \
1884 } while (0);
1885
1886 #define DEFINE_SOLID_DRAWGLYPHLISTLCD(DST, STRATEGY) \
1887 void NAME_SOLID_DRAWGLYPHLISTLCD(DST)(SurfaceDataRasInfo *pRasInfo, \
1888 ImageRef *glyphs, \
1889 jint totalGlyphs, jint fgpixel, \
1890 jint argbcolor, \
1891 jint clipLeft, jint clipTop, \
1892 jint clipRight, jint clipBottom, \
1893 jint rgbOrder, \
1894 unsigned char *gammaLut, \
1895 unsigned char * invGammaLut, \
1896 NativePrimitive *pPrim, \
1897 CompositeInfo *pCompInfo) \
1898 { \
1899 jint glyphCounter, bpp; \
1900 jint scan = pRasInfo->scanStride; \
1901 DST ## DataType *pPix; \
1902 Declare ## DST ## PixelData(solidpix) \
1903 DeclareAlphaVarFor ## STRATEGY(srcA) \
1904 DeclareCompVarsFor ## STRATEGY(src) \
1905 \
1906 Declare ## DST ## LoadVars(pix) \
1907 Declare ## DST ## StoreVars(pix) \
1908 \
1909 Init ## DST ## LoadVars(pix, pRasInfo); \
1910 Init ## DST ## StoreVarsY(pix, pRasInfo); \
1911 Init ## DST ## StoreVarsX(pix, pRasInfo); \
1912 Extract ## STRATEGY ## CompsAndAlphaFromArgb(argbcolor, src); \
1913 Extract ## DST ## PixelData(fgpixel, solidpix); \
1914 srcR = invGammaLut[srcR]; \
1915 srcG = invGammaLut[srcG]; \
1916 srcB = invGammaLut[srcB]; \
1917 \
1918 for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) { \
1919 DeclareDrawGlyphListClipVars(pixels, rowBytes, width, height, \
1920 left, top, right, bottom) \
1921 bpp = \
1922 (glyphs[glyphCounter].rowBytes == glyphs[glyphCounter].width) ? 1 : 3;\
1923 ClipDrawGlyphList(DST, pixels, bpp, rowBytes, width, height, \
1924 left, top, right, bottom, \
1925 clipLeft, clipTop, clipRight, clipBottom, \
1926 glyphs, glyphCounter, continue) \
1927 pPix = PtrCoord(pRasInfo->rasBase,left,DST ## PixelStride,top,scan); \
1928 \
1929 Set ## DST ## StoreVarsYPos(pix, pRasInfo, top); \
1930 if (bpp!=1) { \
1931 /* subpixel positioning adjustment */ \
1932 pixels += glyphs[glyphCounter].rowBytesOffset; \
1933 } \
1934 do { \
1935 int x = 0; \
1936 Set ## DST ## StoreVarsXPos(pix, pRasInfo, left); \
1937 if (bpp==1) { \
1938 do { \
1939 if (pixels[x]) { \
1940 Store ## DST ## PixelData(pPix, x, fgpixel, solidpix);\
1941 } \
1942 } while (++x < width); \
1943 } else { \
1944 do { \
1945 GlyphListLCDBlend ## STRATEGY(DST, pixels, x, pPix, \
1946 fgpixel, solidpix, src); \
1947 Next ## DST ## StoreVarsX(pix); \
1948 } while (++x < width); \
1949 } \
1950 pPix = PtrAddBytes(pPix, scan); \
1951 pixels += rowBytes; \
1952 Next ## DST ## StoreVarsY(pix); \
1953 } while (--height > 0); \
1954 } \
1955 }
1956
1957 #define DEFINE_XOR_DRAWGLYPHLIST(DST) \
1958 void NAME_XOR_DRAWGLYPHLIST(DST)(SurfaceDataRasInfo *pRasInfo, \
1959 ImageRef *glyphs, \
1960 jint totalGlyphs, jint fgpixel, \
1961 jint argbcolor, \
1962 jint clipLeft, jint clipTop, \
1963 jint clipRight, jint clipBottom, \
1964 NativePrimitive *pPrim, \
1965 CompositeInfo *pCompInfo) \
1966 { \
1967 jint glyphCounter; \
1968 jint scan = pRasInfo->scanStride; \
1969 jint xorpixel = pCompInfo->details.xorPixel; \
1970 juint alphamask = pCompInfo->alphaMask; \
1971 Declare ## DST ## PixelData(xor) \
1972 Declare ## DST ## PixelData(pix) \
1973 Declare ## DST ## PixelData(mask) \
1974 DST ## DataType *pPix; \
1975 \
1976 Extract ## DST ## PixelData(xorpixel, xor); \
1977 Extract ## DST ## PixelData(fgpixel, pix); \
1978 Extract ## DST ## PixelData(alphamask, mask); \
1979 for (glyphCounter = 0; glyphCounter < totalGlyphs; glyphCounter++) { \
1980 DeclareDrawGlyphListClipVars(pixels, rowBytes, width, height, \
1981 left, top, right, bottom) \
1982 ClipDrawGlyphList(DST, pixels, 1, rowBytes, width, height, \
1983 left, top, right, bottom, \
1984 clipLeft, clipTop, clipRight, clipBottom, \
1985 glyphs, glyphCounter, continue) \
1986 pPix = PtrCoord(pRasInfo->rasBase,left,DST ## PixelStride,top,scan); \
1987 \
1988 do { \
1989 int x = 0; \
1990 do { \
1991 if (pixels[x]) { \
1992 Xor ## DST ## PixelData(fgpixel, pix, pPix, x, \
1993 xorpixel, xor, alphamask, mask); \
1994 } \
1995 } while (++x < width); \
1996 pPix = PtrAddBytes(pPix, scan); \
1997 pixels += rowBytes; \
1998 } while (--height > 0); \
1999 } \
2000 }
2001
2002 #define DEFINE_TRANSFORMHELPER_NN(SRC) \
2003 void NAME_TRANSFORMHELPER_NN(SRC)(SurfaceDataRasInfo *pSrcInfo, \
2004 jint *pRGB, jint numpix, \
2005 jlong xlong, jlong dxlong, \
2006 jlong ylong, jlong dylong) \
2007 { \
2008 Declare ## SRC ## LoadVars(SrcRead) \
2009 SRC ## DataType *pBase = pSrcInfo->rasBase; \
2010 jint scan = pSrcInfo->scanStride; \
2011 jint *pEnd = pRGB + numpix; \
2012 \
2013 xlong += IntToLong(pSrcInfo->bounds.x1); \
2014 ylong += IntToLong(pSrcInfo->bounds.y1); \
2015 \
2016 Init ## SRC ## LoadVars(SrcRead, pSrcInfo); \
2017 while (pRGB < pEnd) { \
2018 SRC ## DataType *pRow = PtrAddBytes(pBase, WholeOfLong(ylong) * scan); \
2019 Copy ## SRC ## ToIntArgbPre(pRGB, 0, \
2020 SrcRead, pRow, WholeOfLong(xlong)); \
2021 pRGB++; \
2022 xlong += dxlong; \
2023 ylong += dylong; \
2024 } \
2025 }
2026
2027 #define DEFINE_TRANSFORMHELPER_BL(SRC) \
2028 void NAME_TRANSFORMHELPER_BL(SRC)(SurfaceDataRasInfo *pSrcInfo, \
2029 jint *pRGB, jint numpix, \
2030 jlong xlong, jlong dxlong, \
2031 jlong ylong, jlong dylong) \
2032 { \
2033 Declare ## SRC ## LoadVars(SrcRead) \
2034 jint scan = pSrcInfo->scanStride; \
2035 jint cx, cy, cw, ch; \
2036 jint *pEnd = pRGB + numpix*4; \
2037 \
2038 cx = pSrcInfo->bounds.x1; \
2039 cw = pSrcInfo->bounds.x2-cx; \
2040 \
2041 cy = pSrcInfo->bounds.y1; \
2042 ch = pSrcInfo->bounds.y2-cy; \
2043 \
2044 xlong -= LongOneHalf; \
2045 ylong -= LongOneHalf; \
2046 \
2047 Init ## SRC ## LoadVars(SrcRead, pSrcInfo); \
2048 while (pRGB < pEnd) { \
2049 jint xwhole = WholeOfLong(xlong); \
2050 jint ywhole = WholeOfLong(ylong); \
2051 jint xdelta, ydelta, isneg; \
2052 SRC ## DataType *pRow; \
2053 \
2054 xdelta = ((juint) (xwhole + 1 - cw)) >> 31; \
2055 isneg = xwhole >> 31; \
2056 xwhole -= isneg; \
2057 xdelta += isneg; \
2058 \
2059 ydelta = ((ywhole + 1 - ch) >> 31); \
2060 isneg = ywhole >> 31; \
2061 ywhole -= isneg; \
2062 ydelta -= isneg; \
2063 ydelta &= scan; \
2064 \
2065 xwhole += cx; \
2066 pRow = PtrAddBytes(pSrcInfo->rasBase, (ywhole + cy) * scan); \
2067 Copy ## SRC ## ToIntArgbPre(pRGB, 0, SrcRead, pRow, xwhole); \
2068 Copy ## SRC ## ToIntArgbPre(pRGB, 1, SrcRead, pRow, xwhole+xdelta); \
2069 pRow = PtrAddBytes(pRow, ydelta); \
2070 Copy ## SRC ## ToIntArgbPre(pRGB, 2, SrcRead, pRow, xwhole); \
2071 Copy ## SRC ## ToIntArgbPre(pRGB, 3, SrcRead, pRow, xwhole+xdelta); \
2072 \
2073 pRGB += 4; \
2074 xlong += dxlong; \
2075 ylong += dylong; \
2076 } \
2077 }
2078
2079 #define DEFINE_TRANSFORMHELPER_BC(SRC) \
2080 void NAME_TRANSFORMHELPER_BC(SRC)(SurfaceDataRasInfo *pSrcInfo, \
2081 jint *pRGB, jint numpix, \
2082 jlong xlong, jlong dxlong, \
2083 jlong ylong, jlong dylong) \
2084 { \
2085 Declare ## SRC ## LoadVars(SrcRead) \
2086 jint scan = pSrcInfo->scanStride; \
2087 jint cx, cy, cw, ch; \
2088 jint *pEnd = pRGB + numpix*16; \
2089 \
2090 cx = pSrcInfo->bounds.x1; \
2091 cw = pSrcInfo->bounds.x2-cx; \
2092 \
2093 cy = pSrcInfo->bounds.y1; \
2094 ch = pSrcInfo->bounds.y2-cy; \
2095 \
2096 xlong -= LongOneHalf; \
2097 ylong -= LongOneHalf; \
2098 \
2099 Init ## SRC ## LoadVars(SrcRead, pSrcInfo); \
2100 while (pRGB < pEnd) { \
2101 jint xwhole = WholeOfLong(xlong); \
2102 jint ywhole = WholeOfLong(ylong); \
2103 jint xdelta0, xdelta1, xdelta2; \
2104 jint ydelta0, ydelta1, ydelta2; \
2105 jint isneg; \
2106 SRC ## DataType *pRow; \
2107 \
2108 xdelta0 = (-xwhole) >> 31; \
2109 xdelta1 = ((juint) (xwhole + 1 - cw)) >> 31; \
2110 xdelta2 = ((juint) (xwhole + 2 - cw)) >> 31; \
2111 isneg = xwhole >> 31; \
2112 xwhole -= isneg; \
2113 xdelta1 += isneg; \
2114 xdelta2 += xdelta1; \
2115 \
2116 ydelta0 = ((-ywhole) >> 31) & (-scan); \
2117 ydelta1 = ((ywhole + 1 - ch) >> 31) & scan; \
2118 ydelta2 = ((ywhole + 2 - ch) >> 31) & scan; \
2119 isneg = ywhole >> 31; \
2120 ywhole -= isneg; \
2121 ydelta1 += (isneg & -scan); \
2122 \
2123 xwhole += cx; \
2124 pRow = PtrAddBytes(pSrcInfo->rasBase, (ywhole + cy) * scan); \
2125 pRow = PtrAddBytes(pRow, ydelta0); \
2126 Copy ## SRC ## ToIntArgbPre(pRGB, 0, SrcRead, pRow, xwhole+xdelta0); \
2127 Copy ## SRC ## ToIntArgbPre(pRGB, 1, SrcRead, pRow, xwhole ); \
2128 Copy ## SRC ## ToIntArgbPre(pRGB, 2, SrcRead, pRow, xwhole+xdelta1); \
2129 Copy ## SRC ## ToIntArgbPre(pRGB, 3, SrcRead, pRow, xwhole+xdelta2); \
2130 pRow = PtrAddBytes(pRow, -ydelta0); \
2131 Copy ## SRC ## ToIntArgbPre(pRGB, 4, SrcRead, pRow, xwhole+xdelta0); \
2132 Copy ## SRC ## ToIntArgbPre(pRGB, 5, SrcRead, pRow, xwhole ); \
2133 Copy ## SRC ## ToIntArgbPre(pRGB, 6, SrcRead, pRow, xwhole+xdelta1); \
2134 Copy ## SRC ## ToIntArgbPre(pRGB, 7, SrcRead, pRow, xwhole+xdelta2); \
2135 pRow = PtrAddBytes(pRow, ydelta1); \
2136 Copy ## SRC ## ToIntArgbPre(pRGB, 8, SrcRead, pRow, xwhole+xdelta0); \
2137 Copy ## SRC ## ToIntArgbPre(pRGB, 9, SrcRead, pRow, xwhole ); \
2138 Copy ## SRC ## ToIntArgbPre(pRGB, 10, SrcRead, pRow, xwhole+xdelta1); \
2139 Copy ## SRC ## ToIntArgbPre(pRGB, 11, SrcRead, pRow, xwhole+xdelta2); \
2140 pRow = PtrAddBytes(pRow, ydelta2); \
2141 Copy ## SRC ## ToIntArgbPre(pRGB, 12, SrcRead, pRow, xwhole+xdelta0); \
2142 Copy ## SRC ## ToIntArgbPre(pRGB, 13, SrcRead, pRow, xwhole ); \
2143 Copy ## SRC ## ToIntArgbPre(pRGB, 14, SrcRead, pRow, xwhole+xdelta1); \
2144 Copy ## SRC ## ToIntArgbPre(pRGB, 15, SrcRead, pRow, xwhole+xdelta2); \
2145 \
2146 pRGB += 16; \
2147 xlong += dxlong; \
2148 ylong += dylong; \
2149 } \
2150 }
2151
2152 #define DEFINE_TRANSFORMHELPER_FUNCS(SRC) \
2153 TransformHelperFuncs NAME_TRANSFORMHELPER_FUNCS(SRC) = { \
2154 NAME_TRANSFORMHELPER_NN(SRC), \
2155 NAME_TRANSFORMHELPER_BL(SRC), \
2156 NAME_TRANSFORMHELPER_BC(SRC), \
2157 };
2158
2159 #define DEFINE_TRANSFORMHELPERS(SRC) \
2160 DEFINE_TRANSFORMHELPER_NN(SRC) \
2161 DEFINE_TRANSFORMHELPER_BL(SRC) \
2162 DEFINE_TRANSFORMHELPER_BC(SRC) \
2163 DEFINE_TRANSFORMHELPER_FUNCS(SRC)
2164
2165 /*
2166 * The macros defined above use the following macro definitions supplied
2167 * for the various surface types to manipulate pixels and pixel data.
2168 * The surface-specific macros are typically supplied by header files
2169 * named after the SurfaceType name (i.e. IntArgb.h, ByteGray.h, etc.).
2170 *
2171 * In the macro names in the following definitions, the string <stype>
2172 * is used as a place holder for the SurfaceType name (i.e. IntArgb).
2173 * The macros above access these type specific macros using the ANSI
2174 * CPP token concatenation operator "##".
2175 *
2176 * <stype>DataType A typedef for the type of the pointer
2177 * that is used to access the raster data
2178 * for the given surface type.
2179 * <stype>PixelStride Pixel stride for the surface type.
2180 *
2181 * Declare<stype>LoadVars Declare the variables needed to control
2182 * loading color information from an stype
2183 * raster (i.e. lookup tables).
2184 * Init<stype>LoadVars Init the lookup table variables.
2185 * Declare<stype>StoreVars Declare the storage variables needed to
2186 * control storing pixel data based on the
2187 * pixel coordinate (i.e. dithering variables).
2188 * Init<stype>StoreVarsY Init the dither variables for starting Y.
2189 * Next<stype>StoreVarsY Increment the dither variables for next Y.
2190 * Init<stype>StoreVarsX Init the dither variables for starting X.
2191 * Next<stype>StoreVarsX Increment the dither variables for next X.
2192 *
2193 * Load<stype>To1IntRgb Load a pixel and form an INT_RGB integer.
2194 * Store<stype>From1IntRgb Store a pixel from an INT_RGB integer.
2195 * Load<stype>To1IntArgb Load a pixel and form an INT_ARGB integer.
2196 * Store<stype>From1IntArgb Store a pixel from an INT_ARGB integer.
2197 * Load<stype>To3ByteRgb Load a pixel into R, G, and B components.
2198 * Store<stype>From3ByteRgb Store a pixel from R, G, and B components.
2199 * Load<stype>To4ByteArgb Load a pixel into A, R, G, and B components.
2200 * Store<stype>From4ByteArgb Store a pixel from A, R, G, and B components.
2201 * Load<stype>To1ByteGray Load a pixel and form a BYTE_GRAY byte.
2202 * Store<stype>From1ByteGray Store a pixel from a BYTE_GRAY byte.
2203 *
2204 * <stype>PixelType Typedef for a "single quantity pixel" (SQP)
2205 * that can hold the data for one stype pixel.
2206 * <stype>XparLutEntry An SQP that can be used to represent a
2207 * transparent pixel for stype.
2208 * Store<stype>NonXparFromArgb Store an SQP from an INT_ARGB integer in
2209 * such a way that it would not be confused
2210 * with the XparLutEntry value for stype.
2211 * <stype>IsXparLutEntry Test an SQP for the XparLutEntry value.
2212 * Store<stype>Pixel Store the pixel data from an SQP.
2213 * <stype>PixelFromArgb Converts an INT_ARGB value into the specific
2214 * pixel representation for the surface type.
2215 *
2216 * Declare<stype>PixelData Declare the pixel data variables (PDV) needed
2217 * to hold the elements of pixel data ready to
2218 * store into an stype raster (may be empty for
2219 * stypes whose SQP format is their data format).
2220 * Extract<stype>PixelData Extract an SQP value into the PDVs.
2221 * Store<stype>PixelData Store the PDVs into an stype raster.
2222 * XorCopy<stype>PixelData Xor the PDVs into an stype raster.
2223 */
2224 #endif /* LoopMacros_h_Included */