1 /************************************************************
2 Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
3 
4                     All Rights Reserved
5 
6 Permission  to  use,  copy,  modify,  and  distribute   this
7 software  and  its documentation for any purpose and without
8 fee is hereby granted, provided that the above copyright no-
9 tice  appear  in all copies and that both that copyright no-
10 tice and this permission notice appear in  supporting  docu-
11 mentation,  and  that the names of Sun or X Consortium
12 not be used in advertising or publicity pertaining to
13 distribution  of  the software  without specific prior
14 written permission. Sun and X Consortium make no
15 representations about the suitability of this software for
16 any purpose. It is provided "as is" without any express or
17 implied warranty.
18 
19 SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO  THIS  SOFTWARE,
20 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
21 NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE  LI-
22 ABLE  FOR  ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
23 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,  DATA  OR
24 PROFITS,  WHETHER  IN  AN  ACTION OF CONTRACT, NEGLIGENCE OR
25 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
26 THE USE OR PERFORMANCE OF THIS SOFTWARE.
27 
28 ********************************************************/
29 
30 /* $XConsortium: cfbmskbits.c,v 4.13 94/07/28 12:30:41 dpw Exp $ */
31 /* $XFree86: xc/programs/Xserver/cfb/cfbmskbits.c,v 3.0 1996/06/29 09:05:41 dawes Exp $ */
32 
33 /*
34  * ==========================================================================
35  * Converted to Color Frame Buffer by smarks@sun, April-May 1987.  The "bit
36  * numbering" in the doc below really means "byte numbering" now.
37  * ==========================================================================
38  */
39 
40 /*
41    these tables are used by several macros in the cfb code.
42 
43    the vax numbers everything left to right, so bit indices on the
44 screen match bit indices in longwords.  the pc-rt and Sun number
45 bits on the screen the way they would be written on paper,
46 (i.e. msb to the left), and so a bit index n on the screen is
47 bit index 32-n in a longword
48 
49    see also cfbmskbits.h
50 */
51 #include	<X.h>
52 #include	<Xmd.h>
53 #include	<servermd.h>
54 #include	"cfb.h"
55 #include	"cfbmskbits.h"
56 
57 #define _cfbBits(a) (PixelGroup)(a)
58 
59 #if	(BITMAP_BIT_ORDER == MSBFirst)
60 #define cfbBits(v)	_cfbBits(v)
61 #else /* BITMAP_BIT_ORDER == LSBFirst */
62 #define cfbFlip2(a)	((((a) & 0x1) << 1) | (((a) & 0x2) >> 1))
63 #define cfbFlip4(a)	((cfbFlip2(a) << 2) | cfbFlip2(a >> 2))
64 #define cfbFlip8(a)	((cfbFlip4(a) << 4) | cfbFlip4(a >> 4))
65 #define cfbFlip16(a)	((cfbFlip8(a) << 8) | cfbFlip8(a >> 8))
66 #define cfbFlip32(a)	((cfbFlip16(a) << 16) | cfbFlip16(a >> 16))
67 #if PGSZ == 32
68 #define cfbBits(a)	cfbFlip32(_cfbBits(a))
69 #else /* PGSZ == 64 */
70 #define cfbFlip64(a)	((cfbFlip32(a) << 32) | cfbFlip32(a >> 32))
71 #define cfbBits(a)	cfbFlip64(_cfbBits(a))
72 #endif /* PGSZ */
73 #endif /* BITMAP_BIT_ORDER */
74 
75 /* NOTE:
76 the first element in starttab could be 0xffffffff.  making it 0
77 lets us deal with a full first word in the middle loop, rather
78 than having to do the multiple reads and masks that we'd
79 have to do if we thought it was partial.
80 */
81 #if PSZ == 4
82 #if PGSZ == 32
83 PixelGroup cfbstarttab[] =
84     {
85 	cfbBits(0x00000000),
86 	cfbBits(0x0FFFFFFF),
87 	cfbBits(0x00FFFFFF),
88 	cfbBits(0x000FFFFF),
89 	cfbBits(0x0000FFFF),
90 	cfbBits(0x00000FFF),
91 	cfbBits(0x000000FF),
92 	cfbBits(0x0000000F)
93     };
94 PixelGroup cfbendtab[] =
95     {
96 	cfbBits(0x00000000),
97 	cfbBits(0xF0000000),
98 	cfbBits(0xFF000000),
99 	cfbBits(0xFFF00000),
100 	cfbBits(0xFFFF0000),
101 	cfbBits(0xFFFFF000),
102 	cfbBits(0xFFFFFF00),
103 	cfbBits(0xFFFFFFF0)
104     };
105 #else /* PGSZ == 64 */
106 PixelGroup cfbstarttab[] =
107     {
108 	cfbBits(0x0000000000000000),
109 	cfbBits(0x0FFFFFFFFFFFFFFF),
110 	cfbBits(0x00FFFFFFFFFFFFFF),
111 	cfbBits(0x000FFFFFFFFFFFFF),
112 	cfbBits(0x0000FFFFFFFFFFFF),
113 	cfbBits(0x00000FFFFFFFFFFF),
114 	cfbBits(0x000000FFFFFFFFFF),
115 	cfbBits(0x0000000FFFFFFFFF),
116 	cfbBits(0x00000000FFFFFFFF),
117 	cfbBits(0x000000000FFFFFFF),
118 	cfbBits(0x0000000000FFFFFF),
119 	cfbBits(0x00000000000FFFFF),
120 	cfbBits(0x000000000000FFFF),
121 	cfbBits(0x0000000000000FFF),
122 	cfbBits(0x00000000000000FF),
123 	cfbBits(0x000000000000000F),
124     };
125 PixelGroup cfbendtab[] =
126     {
127 	cfbBits(0x0000000000000000),
128 	cfbBits(0xF000000000000000),
129 	cfbBits(0xFF00000000000000),
130 	cfbBits(0xFFF0000000000000),
131 	cfbBits(0xFFFF000000000000),
132 	cfbBits(0xFFFFF00000000000),
133 	cfbBits(0xFFFFFF0000000000),
134 	cfbBits(0xFFFFFFF000000000),
135 	cfbBits(0xFFFFFFFF00000000),
136 	cfbBits(0xFFFFFFFFF0000000),
137 	cfbBits(0xFFFFFFFFFF000000),
138 	cfbBits(0xFFFFFFFFFFF00000),
139 	cfbBits(0xFFFFFFFFFFFF0000),
140 	cfbBits(0xFFFFFFFFFFFFF000),
141 	cfbBits(0xFFFFFFFFFFFFFF00),
142 	cfbBits(0xFFFFFFFFFFFFFFF0),
143     };
144 #endif /* PGSZ */
145 #endif /* PSZ == 4 */
146 
147 #if PSZ == 8
148 #if PGSZ == 32
149 PixelGroup cfbstarttab[] =
150     {
151 	cfbBits(0x00000000),
152 	cfbBits(0x00FFFFFF),
153 	cfbBits(0x0000FFFF),
154 	cfbBits(0x000000FF)
155     };
156 PixelGroup cfbendtab[] =
157     {
158 	cfbBits(0x00000000),
159 	cfbBits(0xFF000000),
160 	cfbBits(0xFFFF0000),
161 	cfbBits(0xFFFFFF00)
162     };
163 #else /* PGSZ == 64 */
164 PixelGroup cfbstarttab[] =
165     {
166 	cfbBits(0x0000000000000000),
167 	cfbBits(0x00FFFFFFFFFFFFFF),
168 	cfbBits(0x0000FFFFFFFFFFFF),
169 	cfbBits(0x000000FFFFFFFFFF),
170 	cfbBits(0x00000000FFFFFFFF),
171 	cfbBits(0x0000000000FFFFFF),
172 	cfbBits(0x000000000000FFFF),
173 	cfbBits(0x00000000000000FF)
174     };
175 PixelGroup cfbendtab[] =
176     {
177 	cfbBits(0x0000000000000000),
178 	cfbBits(0xFF00000000000000),
179 	cfbBits(0xFFFF000000000000),
180 	cfbBits(0xFFFFFF0000000000),
181 	cfbBits(0xFFFFFFFF00000000),
182 	cfbBits(0xFFFFFFFFFF000000),
183 	cfbBits(0xFFFFFFFFFFFF0000),
184 	cfbBits(0xFFFFFFFFFFFFFF00)
185     };
186 #endif /* PGSZ */
187 #endif /* PSZ == 8 */
188 
189 #if PSZ == 16
190 #if PGSZ == 32
191 PixelGroup cfbstarttab[] =
192     {
193 	cfbBits(0x00000000),
194 	cfbBits(0x0000FFFF),
195     };
196 PixelGroup cfbendtab[] =
197     {
198 	cfbBits(0x00000000),
199 	cfbBits(0xFFFF0000),
200     };
201 #else /* PGSZ == 64 */
202 PixelGroup cfbstarttab[] =
203     {
204 	cfbBits(0x0000000000000000),
205 	cfbBits(0x0000FFFFFFFFFFFF),
206 	cfbBits(0x00000000FFFFFFFF),
207 	cfbBits(0x000000000000FFFF),
208     };
209 PixelGroup cfbendtab[] =
210     {
211 	cfbBits(0x0000000000000000),
212 	cfbBits(0xFFFF000000000000),
213 	cfbBits(0xFFFFFFFF00000000),
214 	cfbBits(0xFFFFFFFFFFFF0000),
215     };
216 #endif /* PGSZ */
217 #endif
218 
219 #if PSZ == 24
220 #if PGSZ == 32
221 PixelGroup cfbstarttab[] =
222     {
223 	cfbBits(0x00000000),
224 	cfbBits(0x000000FF),
225 	cfbBits(0x0000FFFF),
226 	cfbBits(0x00FFFFFF),
227     };
228 PixelGroup cfbendtab[] =
229     {
230 	cfbBits(0x00000000),
231 	cfbBits(0xFFFFFF00),
232 	cfbBits(0xFFFF0000),
233 	cfbBits(0xFF000000),
234     };
235 #else /* PGSZ == 64 */
236 PixelGroup cfbstarttab[] =
237     {
238 	cfbBits(0x0000000000000000),
239 	cfbBits(0x000000FFFFFFFFFF),
240 	cfbBits(0x000000000000FFFF),
241     };
242 PixelGroup cfbendtab[] =
243     {
244 	cfbBits(0x0000000000000000),
245 	cfbBits(0xFFFFFFFFFF000000),
246 	cfbBits(0xFFFF000000000000),
247     };
248 #endif /* PGSZ */
249 #endif /* PSZ == 24 */
250 
251 #if PSZ == 32
252 #if PGSZ == 32
253 PixelGroup cfbstarttab[] =
254     {
255 	cfbBits(0x00000000),
256     };
257 PixelGroup cfbendtab[] =
258     {
259 	cfbBits(0x00000000),
260     };
261 #else /* PGSZ == 64 */
262 PixelGroup cfbstarttab[] =
263     {
264 	cfbBits(0x0000000000000000),
265 	cfbBits(0x00000000FFFFFFFF),
266     };
267 PixelGroup cfbendtab[] =
268     {
269 	cfbBits(0x0000000000000000),
270 	cfbBits(0xFFFFFFFF00000000),
271     };
272 #endif /* PGSZ */
273 #endif /* PSZ == 32 */
274 
275 /* a hack, for now, since the entries for 0 need to be all
276    1 bits, not all zeros.
277    this means the code DOES NOT WORK for segments of length
278    0 (which is only a problem in the horizontal line code.)
279 */
280 #if PSZ == 4
281 #if PGSZ == 32
282 PixelGroup cfbstartpartial[] =
283     {
284 	cfbBits(0xFFFFFFFF),
285 	cfbBits(0x0FFFFFFF),
286 	cfbBits(0x00FFFFFF),
287 	cfbBits(0x000FFFFF),
288 	cfbBits(0x0000FFFF),
289 	cfbBits(0x00000FFF),
290 	cfbBits(0x000000FF),
291 	cfbBits(0x0000000F)
292     };
293 
294 PixelGroup cfbendpartial[] =
295     {
296 	cfbBits(0xFFFFFFFF),
297 	cfbBits(0xF0000000),
298 	cfbBits(0xFF000000),
299 	cfbBits(0xFFF00000),
300 	cfbBits(0xFFFF0000),
301 	cfbBits(0xFFFFF000),
302 	cfbBits(0xFFFFFF00),
303 	cfbBits(0xFFFFFFF0)
304     };
305 #else /* PGSZ == 64 */
306 PixelGroup cfbstartpartial[] =
307     {
308 	cfbBits(0xFFFFFFFFFFFFFFFF),
309 	cfbBits(0x0FFFFFFFFFFFFFFF),
310 	cfbBits(0x00FFFFFFFFFFFFFF),
311 	cfbBits(0x000FFFFFFFFFFFFF),
312 	cfbBits(0x0000FFFFFFFFFFFF),
313 	cfbBits(0x00000FFFFFFFFFFF),
314 	cfbBits(0x000000FFFFFFFFFF),
315 	cfbBits(0x0000000FFFFFFFFF),
316 	cfbBits(0x00000000FFFFFFFF),
317 	cfbBits(0x000000000FFFFFFF),
318 	cfbBits(0x0000000000FFFFFF),
319 	cfbBits(0x00000000000FFFFF),
320 	cfbBits(0x000000000000FFFF),
321 	cfbBits(0x0000000000000FFF),
322 	cfbBits(0x00000000000000FF),
323 	cfbBits(0x000000000000000F),
324     };
325 
326 PixelGroup cfbendpartial[] =
327     {
328 	cfbBits(0xFFFFFFFFFFFFFFFF),
329 	cfbBits(0xF000000000000000),
330 	cfbBits(0xFF00000000000000),
331 	cfbBits(0xFFF0000000000000),
332 	cfbBits(0xFFFF000000000000),
333 	cfbBits(0xFFFFF00000000000),
334 	cfbBits(0xFFFFFF0000000000),
335 	cfbBits(0xFFFFFFF000000000),
336 	cfbBits(0xFFFFFFFF00000000),
337 	cfbBits(0xFFFFFFFFF0000000),
338 	cfbBits(0xFFFFFFFFFF000000),
339 	cfbBits(0xFFFFFFFFFFF00000),
340 	cfbBits(0xFFFFFFFFFFFF0000),
341 	cfbBits(0xFFFFFFFFFFFFF000),
342 	cfbBits(0xFFFFFFFFFFFFFF00),
343 	cfbBits(0xFFFFFFFFFFFFFFF0),
344     };
345 #endif /* PGSZ */
346 #endif /* PSZ == 4 */
347 
348 #if PSZ == 8
349 #if PGSZ == 32
350 PixelGroup cfbstartpartial[] =
351     {
352 	cfbBits(0xFFFFFFFF),
353 	cfbBits(0x00FFFFFF),
354 	cfbBits(0x0000FFFF),
355 	cfbBits(0x000000FF)
356     };
357 
358 PixelGroup cfbendpartial[] =
359     {
360 	cfbBits(0xFFFFFFFF),
361 	cfbBits(0xFF000000),
362 	cfbBits(0xFFFF0000),
363 	cfbBits(0xFFFFFF00)
364     };
365 #else /* PGSZ == 64 */
366 PixelGroup cfbstartpartial[] =
367     {
368 	cfbBits(0xFFFFFFFFFFFFFFFF),
369 	cfbBits(0x00FFFFFFFFFFFFFF),
370 	cfbBits(0x0000FFFFFFFFFFFF),
371 	cfbBits(0x000000FFFFFFFFFF),
372 	cfbBits(0x00000000FFFFFFFF),
373 	cfbBits(0x0000000000FFFFFF),
374 	cfbBits(0x000000000000FFFF),
375 	cfbBits(0x00000000000000FF),
376     };
377 
378 PixelGroup cfbendpartial[] =
379     {
380 	cfbBits(0xFFFFFFFFFFFFFFFF),
381 	cfbBits(0xFF00000000000000),
382 	cfbBits(0xFFFF000000000000),
383 	cfbBits(0xFFFFFF0000000000),
384 	cfbBits(0xFFFFFFFF00000000),
385 	cfbBits(0xFFFFFFFFFF000000),
386 	cfbBits(0xFFFFFFFFFFFF0000),
387 	cfbBits(0xFFFFFFFFFFFFFF00),
388     };
389 #endif /* PGSZ */
390 #endif /* PSZ == 8 */
391 
392 #if PSZ == 16
393 #if PGSZ == 32
394 PixelGroup cfbstartpartial[] =
395     {
396 	cfbBits(0xFFFFFFFF),
397 	cfbBits(0x0000FFFF),
398     };
399 
400 PixelGroup cfbendpartial[] =
401     {
402 	cfbBits(0xFFFFFFFF),
403 	cfbBits(0xFFFF0000),
404     };
405 #else /* PGSZ == 64 */
406 PixelGroup cfbstartpartial[] =
407     {
408 	cfbBits(0xFFFFFFFFFFFFFFFF),
409 	cfbBits(0x0000FFFFFFFFFFFF),
410 	cfbBits(0x00000000FFFFFFFF),
411 	cfbBits(0x000000000000FFFF),
412     };
413 
414 PixelGroup cfbendpartial[] =
415     {
416 	cfbBits(0xFFFFFFFFFFFFFFFF),
417 	cfbBits(0xFFFF000000000000),
418 	cfbBits(0xFFFFFFFF00000000),
419 	cfbBits(0xFFFFFFFFFFFF0000),
420     };
421 #endif /* PGSZ */
422 #endif /* PSZ == 16 */
423 
424 #if PSZ == 24
425 #if PGSZ == 32
426 PixelGroup cfbstartpartial[] =
427     {
428 	cfbBits(0xFFFFFFFF),
429 	cfbBits(0x000000FF),
430 	cfbBits(0x0000FFFF),
431 	cfbBits(0x00FFFFFF),
432     };
433 
434 PixelGroup cfbendpartial[] =
435     {
436 	cfbBits(0xFFFFFFFF),
437 	cfbBits(0xFFFFFF00),
438 	cfbBits(0xFFFF0000),
439 	cfbBits(0xFF000000),
440     };
441 #else /* PGSZ == 64 */
442 PixelGroup cfbstartpartial[] =
443     {
444 	cfbBits(0xFFFFFFFFFFFFFFFF),
445 	cfbBits(0x0000FFFFFFFFFFFF),
446 	cfbBits(0x000000FFFFFFFFFF),
447 	cfbBits(0x00000000FFFFFFFF),
448 	cfbBits(0x0000000000FFFFFF),
449 	cfbBits(0x000000000000FFFF),
450 	cfbBits(0x00000000000000FF),
451     };
452 
453 PixelGroup cfbendpartial[] =
454     {
455 	cfbBits(0xFFFFFFFFFFFFFFFF),
456 	cfbBits(0xFFFFFFFFFFFF0000),
457 	cfbBits(0xFFFFFFFFFF000000),
458 	cfbBits(0xFFFFFFFF00000000),
459 	cfbBits(0xFFFFFF0000000000),
460 	cfbBits(0xFFFF000000000000),
461 	cfbBits(0xFF00000000000000),
462     };
463 #endif /* PGSZ */
464 #endif /* PSZ == 24 */
465 
466 #if PSZ == 32
467 #if PGSZ == 32
468 PixelGroup cfbstartpartial[] =
469     {
470 	cfbBits(0xFFFFFFFF),
471     };
472 
473 PixelGroup cfbendpartial[] =
474     {
475 	cfbBits(0xFFFFFFFF),
476     };
477 #else /* PGSZ == 64 */
478 PixelGroup cfbstartpartial[] =
479     {
480 	cfbBits(0xFFFFFFFFFFFFFFFF),
481 	cfbBits(0x00000000FFFFFFFF),
482     };
483 
484 PixelGroup cfbendpartial[] =
485     {
486 	cfbBits(0xFFFFFFFFFFFFFFFF),
487 	cfbBits(0xFFFFFFFF00000000),
488     };
489 #endif /* PGSZ */
490 #endif /* PSZ == 32 */
491 
492 /* used for masking bits in bresenham lines
493    mask[n] is used to mask out all but bit n in a longword (n is a
494 screen position).
495    rmask[n] is used to mask out the single bit at position n (n
496 is a screen posiotion.)
497 */
498 
499 #if PSZ == 4
500 #if PGSZ == 32
501 PixelGroup cfbmask[] =
502     {
503 	cfbBits(0xF0000000),
504 	cfbBits(0x0F000000),
505  	cfbBits(0x00F00000),
506  	cfbBits(0x000F0000),
507  	cfbBits(0x0000F000),
508  	cfbBits(0x00000F00),
509  	cfbBits(0x000000F0),
510  	cfbBits(0x0000000F)
511     };
512 PixelGroup cfbrmask[] =
513     {
514 	cfbBits(0x0FFFFFFF),
515 	cfbBits(0xF0FFFFFF),
516  	cfbBits(0xFF0FFFFF),
517  	cfbBits(0xFFF0FFFF),
518  	cfbBits(0xFFFF0FFF),
519  	cfbBits(0xFFFFF0FF),
520  	cfbBits(0xFFFFFF0F),
521  	cfbBits(0xFFFFFFF0)
522     };
523 #else /* PGSZ == 64 */
524 PixelGroup cfbmask[] =
525     {
526 	cfbBits(0xF000000000000000),
527 	cfbBits(0x0F00000000000000),
528  	cfbBits(0x00F0000000000000),
529  	cfbBits(0x000F000000000000),
530  	cfbBits(0x0000F00000000000),
531  	cfbBits(0x00000F0000000000),
532  	cfbBits(0x000000F000000000),
533  	cfbBits(0x0000000F00000000),
534 	cfbBits(0x00000000F0000000),
535 	cfbBits(0x000000000F000000),
536  	cfbBits(0x0000000000F00000),
537  	cfbBits(0x00000000000F0000),
538  	cfbBits(0x000000000000F000),
539  	cfbBits(0x0000000000000F00),
540  	cfbBits(0x00000000000000F0),
541  	cfbBits(0x000000000000000F),
542     };
543 PixelGroup cfbrmask[] =
544     {
545 	cfbBits(0x0FFFFFFFFFFFFFFF),
546 	cfbBits(0xF0FFFFFFFFFFFFFF),
547  	cfbBits(0xFF0FFFFFFFFFFFFF),
548  	cfbBits(0xFFF0FFFFFFFFFFFF),
549  	cfbBits(0xFFFF0FFFFFFFFFFF),
550  	cfbBits(0xFFFFF0FFFFFFFFFF),
551  	cfbBits(0xFFFFFF0FFFFFFFFF),
552  	cfbBits(0xFFFFFFF0FFFFFFFF),
553 	cfbBits(0xFFFFFFFF0FFFFFFF),
554 	cfbBits(0xFFFFFFFFF0FFFFFF),
555  	cfbBits(0xFFFFFFFFFF0FFFFF),
556  	cfbBits(0xFFFFFFFFFFF0FFFF),
557  	cfbBits(0xFFFFFFFFFFFF0FFF),
558  	cfbBits(0xFFFFFFFFFFFFF0FF),
559  	cfbBits(0xFFFFFFFFFFFFFF0F),
560  	cfbBits(0xFFFFFFFFFFFFFFF0),
561     };
562 #endif /* PGSZ */
563 #endif /* PSZ == 4 */
564 
565 #if PSZ == 8
566 #if PGSZ == 32
567 PixelGroup cfbmask[] =
568     {
569 	cfbBits(0xFF000000),
570  	cfbBits(0x00FF0000),
571  	cfbBits(0x0000FF00),
572  	cfbBits(0x000000FF)
573     };
574 PixelGroup cfbrmask[] =
575     {
576 	cfbBits(0x00FFFFFF),
577  	cfbBits(0xFF00FFFF),
578  	cfbBits(0xFFFF00FF),
579  	cfbBits(0xFFFFFF00)
580     };
581 #else /* PGSZ == 64 */
582 PixelGroup cfbmask[] =
583     {
584 	cfbBits(0xFF00000000000000),
585  	cfbBits(0x00FF000000000000),
586  	cfbBits(0x0000FF0000000000),
587  	cfbBits(0x000000FF00000000),
588 	cfbBits(0x00000000FF000000),
589  	cfbBits(0x0000000000FF0000),
590  	cfbBits(0x000000000000FF00),
591  	cfbBits(0x00000000000000FF),
592     };
593 PixelGroup cfbrmask[] =
594     {
595 	cfbBits(0x00FFFFFFFFFFFFFF),
596  	cfbBits(0xFF00FFFFFFFFFFFF),
597  	cfbBits(0xFFFF00FFFFFFFFFF),
598  	cfbBits(0xFFFFFF00FFFFFFFF),
599 	cfbBits(0xFFFFFFFF00FFFFFF),
600  	cfbBits(0xFFFFFFFFFF00FFFF),
601  	cfbBits(0xFFFFFFFFFFFF00FF),
602  	cfbBits(0xFFFFFFFFFFFFFF00),
603     };
604 #endif /* PGSZ */
605 #endif /* PSZ == 8 */
606 
607 #if PSZ == 16
608 #if PGSZ == 32
609 PixelGroup cfbmask[] =
610     {
611 	cfbBits(0xFFFF0000),
612  	cfbBits(0x0000FFFF),
613     };
614 PixelGroup cfbrmask[] =
615     {
616 	cfbBits(0x0000FFFF),
617  	cfbBits(0xFFFF0000),
618     };
619 #else /* PGSZ == 64 */
620 PixelGroup cfbmask[] =
621     {
622 	cfbBits(0xFFFF000000000000),
623  	cfbBits(0x0000FFFF00000000),
624 	cfbBits(0x00000000FFFF0000),
625  	cfbBits(0x000000000000FFFF),
626     };
627 PixelGroup cfbrmask[] =
628     {
629 	cfbBits(0x0000FFFFFFFFFFFF),
630  	cfbBits(0xFFFF0000FFFFFFFF),
631 	cfbBits(0xFFFFFFFF0000FFFF),
632  	cfbBits(0xFFFFFFFFFFFF0000),
633     };
634 #endif /* PGSZ */
635 #endif /* PSZ == 16 */
636 
637 #if PSZ == 24
638 #if PGSZ == 32
639 PixelGroup cfbmask[] =
640     {
641  	cfbBits(0xFFFFFF00),
642 	cfbBits(0x00000000),
643 	cfbBits(0x000000FF),
644  	cfbBits(0xFFFF0000),
645 	cfbBits(0x0000FFFF),
646 	cfbBits(0xFF000000),
647 	cfbBits(0x00FFFFFF),
648 	cfbBits(0x00000000),
649     };
650 PixelGroup cfbrmask[] =
651     {
652 	cfbBits(0x000000FF),
653  	cfbBits(0xFFFFFFFF),
654  	cfbBits(0xFFFFFF00),
655 	cfbBits(0x0000FFFF),
656 	cfbBits(0xFFFF0000),
657 	cfbBits(0x00FFFFFF),
658 	cfbBits(0xFF000000),
659  	cfbBits(0xFFFFFFFF),
660     };
661 #else /* PGSZ == 64 */
662 PixelGroup cfbmask[] =
663     {
664 	cfbBits(0xFFFFFF0000000000),
665  	cfbBits(0x000000FFFFFF0000),
666  	cfbBits(0x000000000000FFFF),
667     };
668 PixelGroup cfbmask2[] =
669     {
670  	cfbBits(0x0000000000000000),
671  	cfbBits(0x0000000000000000),
672 	cfbBits(0xFF00000000000000),
673     };
674 PixelGroup cfbrmask[] =
675     {
676  	cfbBits(0x000000FFFFFFFFFF),
677  	cfbBits(0xFFFFFF000000FFFF),
678  	cfbBits(0xFFFFFFFFFFFF0000),
679     };
680 PixelGroup cfbrmask2[] =
681     {
682  	cfbBits(0x0000000000000000),
683  	cfbBits(0x0000000000000000),
684  	cfbBits(0x00FFFFFFFFFFFFFF),
685     };
686 #endif /* PGSZ */
687 #endif /* PSZ == 24 */
688 
689 #if PSZ == 32
690 #if PGSZ == 32
691 PixelGroup cfbmask[] =
692     {
693 	cfbBits(0xFFFFFFFF),
694     };
695 PixelGroup cfbrmask[] =
696     {
697 	cfbBits(0xFFFFFFFF),
698     };
699 #else /* PGSZ == 64 */
700 PixelGroup cfbmask[] =
701     {
702 	cfbBits(0xFFFFFFFF00000000),
703 	cfbBits(0x00000000FFFFFFFF),
704     };
705 PixelGroup cfbrmask[] =
706     {
707 	cfbBits(0x00000000FFFFFFFF),
708 	cfbBits(0xFFFFFFFF00000000),
709     };
710 #endif /* PGSZ */
711 #endif /* PSZ == 32 */
712 
713 /*
714  * QuartetBitsTable contains PPW+1 masks whose binary values are masks in the
715  * low order quartet that contain the number of bits specified in the
716  * index.  This table is used by getstipplepixels.
717  */
718 #if PSZ == 4
719 PixelGroup QuartetBitsTable[] = {
720 #if PGSZ == 32
721 #if (BITMAP_BIT_ORDER == MSBFirst)
722     0x00000000,                         /* 0 - 00000000 */
723     0x00000080,				/* 1 - 10000000 */
724     0x000000C0,                         /* 2 - 11000000 */
725     0x000000E0,                         /* 3 - 11100000 */
726     0x000000F0,                         /* 4 - 11110000 */
727     0x000000F8,                         /* 5 - 11111000 */
728     0x000000FC,                         /* 6 - 11111100 */
729     0x000000FE,                         /* 7 - 11111110 */
730     0x000000FF                          /* 8 - 11111111 */
731 #else /* (BITMAP_BIT_ORDER == LSBFirst */
732     0x00000000,                         /* 0 - 00000000 */
733     0x00000001,                         /* 1 - 00000001 */
734     0x00000003,                         /* 2 - 00000011 */
735     0x00000007,                         /* 3 - 00000111 */
736     0x0000000F,                         /* 4 - 00001111 */
737     0x0000001F,                         /* 5 - 00011111 */
738     0x0000003F,                         /* 6 - 00111111 */
739     0x0000007F,                         /* 7 - 01111111 */
740     0x000000FF                          /* 8 - 11111111 */
741 #endif /* (BITMAP_BIT_ORDER == MSBFirst) */
742 #else /* PGSZ == 64 */
743 #if (BITMAP_BIT_ORDER == MSBFirst)
744     0x00000000,                         /* 0 - 0000000000000000 */
745     0x00008000,				/* 1 - 1000000000000000 */
746     0x0000C000,                         /* 2 - 1100000000000000 */
747     0x0000E000,                         /* 3 - 1110000000000000 */
748     0x0000F000,                         /* 4 - 1111000000000000 */
749     0x0000F800,                         /* 5 - 1111100000000000 */
750     0x0000FC00,                         /* 6 - 1111110000000000 */
751     0x0000FE00,                         /* 7 - 1111111000000000 */
752     0x0000FF00,                         /* 8 - 1111111100000000 */
753     0x0000FF80,				/* 9 - 1111111110000000 */
754     0x0000FFC0,                         /* 10- 1111111111000000 */
755     0x0000FFE0,                         /* 11- 1111111111100000 */
756     0x0000FFF0,                         /* 12- 1111111111110000 */
757     0x0000FFF8,                         /* 13- 1111111111111000 */
758     0x0000FFFC,                         /* 14- 1111111111111100 */
759     0x0000FFFE,                         /* 15- 1111111111111110 */
760     0x0000FFFF,                         /* 16- 1111111111111111 */
761 #else /* (BITMAP_BIT_ORDER == LSBFirst */
762     0x00000000,                         /* 0 - 0000000000000000 */
763     0x00000001,                         /* 1 - 0000000000000001 */
764     0x00000003,                         /* 2 - 0000000000000011 */
765     0x00000007,                         /* 3 - 0000000000000111 */
766     0x0000000F,                         /* 4 - 0000000000001111 */
767     0x0000001F,                         /* 5 - 0000000000011111 */
768     0x0000003F,                         /* 6 - 0000000000111111 */
769     0x0000007F,                         /* 7 - 0000000001111111 */
770     0x000000FF,                         /* 8 - 0000000011111111 */
771     0x000001FF,                         /* 9 - 0000000111111111 */
772     0x000003FF,                         /* 10- 0000001111111111 */
773     0x000007FF,                         /* 11- 0000011111111111 */
774     0x00000FFF,                         /* 12- 0000111111111111 */
775     0x00001FFF,                         /* 13- 0001111111111111 */
776     0x00003FFF,                         /* 14- 0011111111111111 */
777     0x00007FFF,                         /* 15- 0111111111111111 */
778     0x0000FFFF,                         /* 16- 1111111111111111 */
779 #endif /* (BITMAP_BIT_ORDER == MSBFirst) */
780 #endif /* PGSZ */
781 };
782 #endif /* PSZ == 4 */
783 
784 #if PSZ == 8
785 PixelGroup QuartetBitsTable[] = {
786 #if PGSZ == 32
787 #if (BITMAP_BIT_ORDER == MSBFirst)
788     0x00000000,                         /* 0 - 0000 */
789     0x00000008,                         /* 1 - 1000 */
790     0x0000000C,                         /* 2 - 1100 */
791     0x0000000E,                         /* 3 - 1110 */
792     0x0000000F                          /* 4 - 1111 */
793 #else /* (BITMAP_BIT_ORDER == LSBFirst */
794     0x00000000,                         /* 0 - 0000 */
795     0x00000001,                         /* 1 - 0001 */
796     0x00000003,                         /* 2 - 0011 */
797     0x00000007,                         /* 3 - 0111 */
798     0x0000000F                          /* 4 - 1111 */
799 #endif /* (BITMAP_BIT_ORDER == MSBFirst) */
800 #else /* PGSZ == 64 */
801 #if (BITMAP_BIT_ORDER == MSBFirst)
802     0x00000000,                         /* 0 - 00000000 */
803     0x00000080,                         /* 1 - 10000000 */
804     0x000000C0,                         /* 2 - 11000000 */
805     0x000000E0,                         /* 3 - 11100000 */
806     0x000000F0,                         /* 4 - 11110000 */
807     0x000000F8,                         /* 5 - 11111000 */
808     0x000000FC,                         /* 6 - 11111100 */
809     0x000000FE,                         /* 7 - 11111110 */
810     0x000000FF                          /* 8 - 11111111 */
811 #else /* (BITMAP_BIT_ORDER == LSBFirst */
812     0x00000000,                         /* 0 - 00000000 */
813     0x00000001,                         /* 1 - 00000001 */
814     0x00000003,                         /* 2 - 00000011 */
815     0x00000007,                         /* 3 - 00000111 */
816     0x0000000F,                         /* 4 - 10000111 */
817     0x0000001F,                         /* 5 - 00011111 */
818     0x0000003F,                         /* 6 - 00111111 */
819     0x0000007F,                         /* 7 - 01111111 */
820     0x000000FF                          /* 8 - 11111111 */
821 #endif /* (BITMAP_BIT_ORDER == MSBFirst) */
822 #endif /* PGSZ */
823 };
824 #endif /* PSZ == 8 */
825 
826 #if PSZ == 16
827 PixelGroup QuartetBitsTable[] = {
828 #if PGSZ == 32
829 #if (BITMAP_BIT_ORDER == MSBFirst)
830     0x00000000,                         /* 0 - 00 */
831     0x00000002,                         /* 1 - 10 */
832     0x00000003,                         /* 2 - 11 */
833 #else /* (BITMAP_BIT_ORDER == LSBFirst */
834     0x00000000,                         /* 0 - 00 */
835     0x00000001,                         /* 1 - 01 */
836     0x00000003,                         /* 2 - 11 */
837 #endif /* (BITMAP_BIT_ORDER == MSBFirst) */
838 #else /* PGSZ == 64 */
839 #if (BITMAP_BIT_ORDER == MSBFirst)
840     0x00000000,                         /* 0 - 0000 */
841     0x00000008,                         /* 1 - 1000 */
842     0x0000000C,                         /* 2 - 1100 */
843     0x0000000E,                         /* 3 - 1110 */
844     0x0000000F,                         /* 4 - 1111 */
845 #else /* (BITMAP_BIT_ORDER == LSBFirst */
846     0x00000000,                         /* 0 - 0000 */
847     0x00000001,                         /* 1 - 0001 */
848     0x00000003,                         /* 2 - 0011 */
849     0x00000007,                         /* 3 - 0111 */
850     0x0000000F,                         /* 4 - 1111 */
851 #endif /* (BITMAP_BIT_ORDER == MSBFirst) */
852 #endif /* PGSZ */
853 };
854 #endif /* PSZ == 16 */
855 
856 #if PSZ == 24
857 PixelGroup QuartetBitsTable[] = {
858 #if PGSZ == 32
859 #if (BITMAP_BIT_ORDER == MSBFirst)
860     0x00000000,                         /* 0 - 0 */
861     0x00000001,                         /* 1 - 1 */
862 #else /* (BITMAP_BIT_ORDER == LSBFirst */
863     0x00000000,                         /* 0 - 0 */
864     0x00000001,                         /* 1 - 1 */
865 #endif /* (BITMAP_BIT_ORDER == MSBFirst) */
866 #else /* PGSZ == 64 */
867 #if (BITMAP_BIT_ORDER == MSBFirst)
868     0x00000000,                         /* 0 - 00 */
869     0x00000002,                         /* 1 - 10 */
870     0x00000003,                         /* 2 - 11*/
871 #else /* (BITMAP_BIT_ORDER == LSBFirst */
872     0x00000000,                         /* 0 - 00 */
873     0x00000001,                         /* 1 - 01 */
874     0x00000003,                         /* 2 - 11 */
875 #endif /* (BITMAP_BIT_ORDER == MSBFirst) */
876 #endif /* PGSZ */
877 };
878 #endif /* PSZ == 24 */
879 
880 #if PSZ == 32
881 PixelGroup QuartetBitsTable[] = {
882 #if PGSZ == 32
883 #if (BITMAP_BIT_ORDER == MSBFirst)
884     0x00000000,                         /* 0 - 0 */
885     0x00000001,                         /* 1 - 1 */
886 #else /* (BITMAP_BIT_ORDER == LSBFirst */
887     0x00000000,                         /* 0 - 0 */
888     0x00000001,                         /* 1 - 1 */
889 #endif /* (BITMAP_BIT_ORDER == MSBFirst) */
890 #else /* PGSZ == 64 */
891 #if (BITMAP_BIT_ORDER == MSBFirst)
892     0x00000000,                         /* 0 - 00 */
893     0x00000002,                         /* 1 - 10 */
894     0x00000003,                         /* 2 - 11*/
895 #else /* (BITMAP_BIT_ORDER == LSBFirst */
896     0x00000000,                         /* 0 - 00 */
897     0x00000001,                         /* 1 - 01 */
898     0x00000003,                         /* 2 - 11 */
899 #endif /* (BITMAP_BIT_ORDER == MSBFirst) */
900 #endif /* PGSZ */
901 };
902 #endif /* PSZ == 32 */
903 
904 /*
905  * QuartetPixelMaskTable is used by getstipplepixels to get a pixel mask
906  * corresponding to a quartet of bits.  Note: the bit/byte order dependency
907  * is handled by QuartetBitsTable above.
908  */
909 #if PSZ == 4
910 #if PGSZ == 32
911 PixelGroup QuartetPixelMaskTable[] = {
912     0x00000000,
913     0x0000000F,
914     0x000000F0,
915     0x000000FF,
916     0x00000F00,
917     0x00000F0F,
918     0x00000FF0,
919     0x00000FFF,
920     0x0000F000,
921     0x0000F00F,
922     0x0000F0F0,
923     0x0000F0FF,
924     0x0000FF00,
925     0x0000FF0F,
926     0x0000FFF0,
927     0x0000FFFF,
928     0x000F0000,
929     0x000F000F,
930     0x000F00F0,
931     0x000F00FF,
932     0x000F0F00,
933     0x000F0F0F,
934     0x000F0FF0,
935     0x000F0FFF,
936     0x000FF000,
937     0x000FF00F,
938     0x000FF0F0,
939     0x000FF0FF,
940     0x000FFF00,
941     0x000FFF0F,
942     0x000FFFF0,
943     0x000FFFFF,
944     0x00F00000,
945     0x00F0000F,
946     0x00F000F0,
947     0x00F000FF,
948     0x00F00F00,
949     0x00F00F0F,
950     0x00F00FF0,
951     0x00F00FFF,
952     0x00F0F000,
953     0x00F0F00F,
954     0x00F0F0F0,
955     0x00F0F0FF,
956     0x00F0FF00,
957     0x00F0FF0F,
958     0x00F0FFF0,
959     0x00F0FFFF,
960     0x00FF0000,
961     0x00FF000F,
962     0x00FF00F0,
963     0x00FF00FF,
964     0x00FF0F00,
965     0x00FF0F0F,
966     0x00FF0FF0,
967     0x00FF0FFF,
968     0x00FFF000,
969     0x00FFF00F,
970     0x00FFF0F0,
971     0x00FFF0FF,
972     0x00FFFF00,
973     0x00FFFF0F,
974     0x00FFFFF0,
975     0x00FFFFFF,
976     0x0F000000,
977     0x0F00000F,
978     0x0F0000F0,
979     0x0F0000FF,
980     0x0F000F00,
981     0x0F000F0F,
982     0x0F000FF0,
983     0x0F000FFF,
984     0x0F00F000,
985     0x0F00F00F,
986     0x0F00F0F0,
987     0x0F00F0FF,
988     0x0F00FF00,
989     0x0F00FF0F,
990     0x0F00FFF0,
991     0x0F00FFFF,
992     0x0F0F0000,
993     0x0F0F000F,
994     0x0F0F00F0,
995     0x0F0F00FF,
996     0x0F0F0F00,
997     0x0F0F0F0F,
998     0x0F0F0FF0,
999     0x0F0F0FFF,
1000     0x0F0FF000,
1001     0x0F0FF00F,
1002     0x0F0FF0F0,
1003     0x0F0FF0FF,
1004     0x0F0FFF00,
1005     0x0F0FFF0F,
1006     0x0F0FFFF0,
1007     0x0F0FFFFF,
1008     0x0FF00000,
1009     0x0FF0000F,
1010     0x0FF000F0,
1011     0x0FF000FF,
1012     0x0FF00F00,
1013     0x0FF00F0F,
1014     0x0FF00FF0,
1015     0x0FF00FFF,
1016     0x0FF0F000,
1017     0x0FF0F00F,
1018     0x0FF0F0F0,
1019     0x0FF0F0FF,
1020     0x0FF0FF00,
1021     0x0FF0FF0F,
1022     0x0FF0FFF0,
1023     0x0FF0FFFF,
1024     0x0FFF0000,
1025     0x0FFF000F,
1026     0x0FFF00F0,
1027     0x0FFF00FF,
1028     0x0FFF0F00,
1029     0x0FFF0F0F,
1030     0x0FFF0FF0,
1031     0x0FFF0FFF,
1032     0x0FFFF000,
1033     0x0FFFF00F,
1034     0x0FFFF0F0,
1035     0x0FFFF0FF,
1036     0x0FFFFF00,
1037     0x0FFFFF0F,
1038     0x0FFFFFF0,
1039     0x0FFFFFFF,
1040     0xF0000000,
1041     0xF000000F,
1042     0xF00000F0,
1043     0xF00000FF,
1044     0xF0000F00,
1045     0xF0000F0F,
1046     0xF0000FF0,
1047     0xF0000FFF,
1048     0xF000F000,
1049     0xF000F00F,
1050     0xF000F0F0,
1051     0xF000F0FF,
1052     0xF000FF00,
1053     0xF000FF0F,
1054     0xF000FFF0,
1055     0xF000FFFF,
1056     0xF00F0000,
1057     0xF00F000F,
1058     0xF00F00F0,
1059     0xF00F00FF,
1060     0xF00F0F00,
1061     0xF00F0F0F,
1062     0xF00F0FF0,
1063     0xF00F0FFF,
1064     0xF00FF000,
1065     0xF00FF00F,
1066     0xF00FF0F0,
1067     0xF00FF0FF,
1068     0xF00FFF00,
1069     0xF00FFF0F,
1070     0xF00FFFF0,
1071     0xF00FFFFF,
1072     0xF0F00000,
1073     0xF0F0000F,
1074     0xF0F000F0,
1075     0xF0F000FF,
1076     0xF0F00F00,
1077     0xF0F00F0F,
1078     0xF0F00FF0,
1079     0xF0F00FFF,
1080     0xF0F0F000,
1081     0xF0F0F00F,
1082     0xF0F0F0F0,
1083     0xF0F0F0FF,
1084     0xF0F0FF00,
1085     0xF0F0FF0F,
1086     0xF0F0FFF0,
1087     0xF0F0FFFF,
1088     0xF0FF0000,
1089     0xF0FF000F,
1090     0xF0FF00F0,
1091     0xF0FF00FF,
1092     0xF0FF0F00,
1093     0xF0FF0F0F,
1094     0xF0FF0FF0,
1095     0xF0FF0FFF,
1096     0xF0FFF000,
1097     0xF0FFF00F,
1098     0xF0FFF0F0,
1099     0xF0FFF0FF,
1100     0xF0FFFF00,
1101     0xF0FFFF0F,
1102     0xF0FFFFF0,
1103     0xF0FFFFFF,
1104     0xFF000000,
1105     0xFF00000F,
1106     0xFF0000F0,
1107     0xFF0000FF,
1108     0xFF000F00,
1109     0xFF000F0F,
1110     0xFF000FF0,
1111     0xFF000FFF,
1112     0xFF00F000,
1113     0xFF00F00F,
1114     0xFF00F0F0,
1115     0xFF00F0FF,
1116     0xFF00FF00,
1117     0xFF00FF0F,
1118     0xFF00FFF0,
1119     0xFF00FFFF,
1120     0xFF0F0000,
1121     0xFF0F000F,
1122     0xFF0F00F0,
1123     0xFF0F00FF,
1124     0xFF0F0F00,
1125     0xFF0F0F0F,
1126     0xFF0F0FF0,
1127     0xFF0F0FFF,
1128     0xFF0FF000,
1129     0xFF0FF00F,
1130     0xFF0FF0F0,
1131     0xFF0FF0FF,
1132     0xFF0FFF00,
1133     0xFF0FFF0F,
1134     0xFF0FFFF0,
1135     0xFF0FFFFF,
1136     0xFFF00000,
1137     0xFFF0000F,
1138     0xFFF000F0,
1139     0xFFF000FF,
1140     0xFFF00F00,
1141     0xFFF00F0F,
1142     0xFFF00FF0,
1143     0xFFF00FFF,
1144     0xFFF0F000,
1145     0xFFF0F00F,
1146     0xFFF0F0F0,
1147     0xFFF0F0FF,
1148     0xFFF0FF00,
1149     0xFFF0FF0F,
1150     0xFFF0FFF0,
1151     0xFFF0FFFF,
1152     0xFFFF0000,
1153     0xFFFF000F,
1154     0xFFFF00F0,
1155     0xFFFF00FF,
1156     0xFFFF0F00,
1157     0xFFFF0F0F,
1158     0xFFFF0FF0,
1159     0xFFFF0FFF,
1160     0xFFFFF000,
1161     0xFFFFF00F,
1162     0xFFFFF0F0,
1163     0xFFFFF0FF,
1164     0xFFFFFF00,
1165     0xFFFFFF0F,
1166     0xFFFFFFF0,
1167     0xFFFFFFFF,
1168 };
1169 #else /* PGSZ == 64 */
1170 No QuartetPixelMaskTable for psz=PSZ
1171 this would be a 64K entry table, a bit much I think.
1172 Try breaking things in two:
1173 mask = table[index&0xff00]<<32 | table[index&0xff]
1174 #endif /* PGSZ */
1175 #endif /* PSZ == 4 */
1176 
1177 #if PSZ == 8
1178 PixelGroup QuartetPixelMaskTable[] = {
1179 #if PGSZ == 32
1180     0x00000000,
1181     0x000000FF,
1182     0x0000FF00,
1183     0x0000FFFF,
1184     0x00FF0000,
1185     0x00FF00FF,
1186     0x00FFFF00,
1187     0x00FFFFFF,
1188     0xFF000000,
1189     0xFF0000FF,
1190     0xFF00FF00,
1191     0xFF00FFFF,
1192     0xFFFF0000,
1193     0xFFFF00FF,
1194     0xFFFFFF00,
1195     0xFFFFFFFF
1196 #else /* PGSZ == 64 */
1197     0x0000000000000000,    0x00000000000000FF,
1198     0x000000000000FF00,    0x000000000000FFFF,
1199     0x0000000000FF0000,    0x0000000000FF00FF,
1200     0x0000000000FFFF00,    0x0000000000FFFFFF,
1201     0x00000000FF000000,    0x00000000FF0000FF,
1202     0x00000000FF00FF00,    0x00000000FF00FFFF,
1203     0x00000000FFFF0000,    0x00000000FFFF00FF,
1204     0x00000000FFFFFF00,    0x00000000FFFFFFFF,
1205     0x000000FF00000000,    0x000000FF000000FF,
1206     0x000000FF0000FF00,    0x000000FF0000FFFF,
1207     0x000000FF00FF0000,    0x000000FF00FF00FF,
1208     0x000000FF00FFFF00,    0x000000FF00FFFFFF,
1209     0x000000FFFF000000,    0x000000FFFF0000FF,
1210     0x000000FFFF00FF00,    0x000000FFFF00FFFF,
1211     0x000000FFFFFF0000,    0x000000FFFFFF00FF,
1212     0x000000FFFFFFFF00,    0x000000FFFFFFFFFF,
1213     0x0000FF0000000000,    0x0000FF00000000FF,
1214     0x0000FF000000FF00,    0x0000FF000000FFFF,
1215     0x0000FF0000FF0000,    0x0000FF0000FF00FF,
1216     0x0000FF0000FFFF00,    0x0000FF0000FFFFFF,
1217     0x0000FF00FF000000,    0x0000FF00FF0000FF,
1218     0x0000FF00FF00FF00,    0x0000FF00FF00FFFF,
1219     0x0000FF00FFFF0000,    0x0000FF00FFFF00FF,
1220     0x0000FF00FFFFFF00,    0x0000FF00FFFFFFFF,
1221     0x0000FFFF00000000,    0x0000FFFF000000FF,
1222     0x0000FFFF0000FF00,    0x0000FFFF0000FFFF,
1223     0x0000FFFF00FF0000,    0x0000FFFF00FF00FF,
1224     0x0000FFFF00FFFF00,    0x0000FFFF00FFFFFF,
1225     0x0000FFFFFF000000,    0x0000FFFFFF0000FF,
1226     0x0000FFFFFF00FF00,    0x0000FFFFFF00FFFF,
1227     0x0000FFFFFFFF0000,    0x0000FFFFFFFF00FF,
1228     0x0000FFFFFFFFFF00,    0x0000FFFFFFFFFFFF,
1229     0x00FF000000000000,    0x00FF0000000000FF,
1230     0x00FF00000000FF00,    0x00FF00000000FFFF,
1231     0x00FF000000FF0000,    0x00FF000000FF00FF,
1232     0x00FF000000FFFF00,    0x00FF000000FFFFFF,
1233     0x00FF0000FF000000,    0x00FF0000FF0000FF,
1234     0x00FF0000FF00FF00,    0x00FF0000FF00FFFF,
1235     0x00FF0000FFFF0000,    0x00FF0000FFFF00FF,
1236     0x00FF0000FFFFFF00,    0x00FF0000FFFFFFFF,
1237     0x00FF00FF00000000,    0x00FF00FF000000FF,
1238     0x00FF00FF0000FF00,    0x00FF00FF0000FFFF,
1239     0x00FF00FF00FF0000,    0x00FF00FF00FF00FF,
1240     0x00FF00FF00FFFF00,    0x00FF00FF00FFFFFF,
1241     0x00FF00FFFF000000,    0x00FF00FFFF0000FF,
1242     0x00FF00FFFF00FF00,    0x00FF00FFFF00FFFF,
1243     0x00FF00FFFFFF0000,    0x00FF00FFFFFF00FF,
1244     0x00FF00FFFFFFFF00,    0x00FF00FFFFFFFFFF,
1245     0x00FFFF0000000000,    0x00FFFF00000000FF,
1246     0x00FFFF000000FF00,    0x00FFFF000000FFFF,
1247     0x00FFFF0000FF0000,    0x00FFFF0000FF00FF,
1248     0x00FFFF0000FFFF00,    0x00FFFF0000FFFFFF,
1249     0x00FFFF00FF000000,    0x00FFFF00FF0000FF,
1250     0x00FFFF00FF00FF00,    0x00FFFF00FF00FFFF,
1251     0x00FFFF00FFFF0000,    0x00FFFF00FFFF00FF,
1252     0x00FFFF00FFFFFF00,    0x00FFFF00FFFFFFFF,
1253     0x00FFFFFF00000000,    0x00FFFFFF000000FF,
1254     0x00FFFFFF0000FF00,    0x00FFFFFF0000FFFF,
1255     0x00FFFFFF00FF0000,    0x00FFFFFF00FF00FF,
1256     0x00FFFFFF00FFFF00,    0x00FFFFFF00FFFFFF,
1257     0x00FFFFFFFF000000,    0x00FFFFFFFF0000FF,
1258     0x00FFFFFFFF00FF00,    0x00FFFFFFFF00FFFF,
1259     0x00FFFFFFFFFF0000,    0x00FFFFFFFFFF00FF,
1260     0x00FFFFFFFFFFFF00,    0x00FFFFFFFFFFFFFF,
1261     0xFF00000000000000,    0xFF000000000000FF,
1262     0xFF0000000000FF00,    0xFF0000000000FFFF,
1263     0xFF00000000FF0000,    0xFF00000000FF00FF,
1264     0xFF00000000FFFF00,    0xFF00000000FFFFFF,
1265     0xFF000000FF000000,    0xFF000000FF0000FF,
1266     0xFF000000FF00FF00,    0xFF000000FF00FFFF,
1267     0xFF000000FFFF0000,    0xFF000000FFFF00FF,
1268     0xFF000000FFFFFF00,    0xFF000000FFFFFFFF,
1269     0xFF0000FF00000000,    0xFF0000FF000000FF,
1270     0xFF0000FF0000FF00,    0xFF0000FF0000FFFF,
1271     0xFF0000FF00FF0000,    0xFF0000FF00FF00FF,
1272     0xFF0000FF00FFFF00,    0xFF0000FF00FFFFFF,
1273     0xFF0000FFFF000000,    0xFF0000FFFF0000FF,
1274     0xFF0000FFFF00FF00,    0xFF0000FFFF00FFFF,
1275     0xFF0000FFFFFF0000,    0xFF0000FFFFFF00FF,
1276     0xFF0000FFFFFFFF00,    0xFF0000FFFFFFFFFF,
1277     0xFF00FF0000000000,    0xFF00FF00000000FF,
1278     0xFF00FF000000FF00,    0xFF00FF000000FFFF,
1279     0xFF00FF0000FF0000,    0xFF00FF0000FF00FF,
1280     0xFF00FF0000FFFF00,    0xFF00FF0000FFFFFF,
1281     0xFF00FF00FF000000,    0xFF00FF00FF0000FF,
1282     0xFF00FF00FF00FF00,    0xFF00FF00FF00FFFF,
1283     0xFF00FF00FFFF0000,    0xFF00FF00FFFF00FF,
1284     0xFF00FF00FFFFFF00,    0xFF00FF00FFFFFFFF,
1285     0xFF00FFFF00000000,    0xFF00FFFF000000FF,
1286     0xFF00FFFF0000FF00,    0xFF00FFFF0000FFFF,
1287     0xFF00FFFF00FF0000,    0xFF00FFFF00FF00FF,
1288     0xFF00FFFF00FFFF00,    0xFF00FFFF00FFFFFF,
1289     0xFF00FFFFFF000000,    0xFF00FFFFFF0000FF,
1290     0xFF00FFFFFF00FF00,    0xFF00FFFFFF00FFFF,
1291     0xFF00FFFFFFFF0000,    0xFF00FFFFFFFF00FF,
1292     0xFF00FFFFFFFFFF00,    0xFF00FFFFFFFFFFFF,
1293     0xFFFF000000000000,    0xFFFF0000000000FF,
1294     0xFFFF00000000FF00,    0xFFFF00000000FFFF,
1295     0xFFFF000000FF0000,    0xFFFF000000FF00FF,
1296     0xFFFF000000FFFF00,    0xFFFF000000FFFFFF,
1297     0xFFFF0000FF000000,    0xFFFF0000FF0000FF,
1298     0xFFFF0000FF00FF00,    0xFFFF0000FF00FFFF,
1299     0xFFFF0000FFFF0000,    0xFFFF0000FFFF00FF,
1300     0xFFFF0000FFFFFF00,    0xFFFF0000FFFFFFFF,
1301     0xFFFF00FF00000000,    0xFFFF00FF000000FF,
1302     0xFFFF00FF0000FF00,    0xFFFF00FF0000FFFF,
1303     0xFFFF00FF00FF0000,    0xFFFF00FF00FF00FF,
1304     0xFFFF00FF00FFFF00,    0xFFFF00FF00FFFFFF,
1305     0xFFFF00FFFF000000,    0xFFFF00FFFF0000FF,
1306     0xFFFF00FFFF00FF00,    0xFFFF00FFFF00FFFF,
1307     0xFFFF00FFFFFF0000,    0xFFFF00FFFFFF00FF,
1308     0xFFFF00FFFFFFFF00,    0xFFFF00FFFFFFFFFF,
1309     0xFFFFFF0000000000,    0xFFFFFF00000000FF,
1310     0xFFFFFF000000FF00,    0xFFFFFF000000FFFF,
1311     0xFFFFFF0000FF0000,    0xFFFFFF0000FF00FF,
1312     0xFFFFFF0000FFFF00,    0xFFFFFF0000FFFFFF,
1313     0xFFFFFF00FF000000,    0xFFFFFF00FF0000FF,
1314     0xFFFFFF00FF00FF00,    0xFFFFFF00FF00FFFF,
1315     0xFFFFFF00FFFF0000,    0xFFFFFF00FFFF00FF,
1316     0xFFFFFF00FFFFFF00,    0xFFFFFF00FFFFFFFF,
1317     0xFFFFFFFF00000000,    0xFFFFFFFF000000FF,
1318     0xFFFFFFFF0000FF00,    0xFFFFFFFF0000FFFF,
1319     0xFFFFFFFF00FF0000,    0xFFFFFFFF00FF00FF,
1320     0xFFFFFFFF00FFFF00,    0xFFFFFFFF00FFFFFF,
1321     0xFFFFFFFFFF000000,    0xFFFFFFFFFF0000FF,
1322     0xFFFFFFFFFF00FF00,    0xFFFFFFFFFF00FFFF,
1323     0xFFFFFFFFFFFF0000,    0xFFFFFFFFFFFF00FF,
1324     0xFFFFFFFFFFFFFF00,    0xFFFFFFFFFFFFFFFF,
1325 #endif /* PGSZ */
1326 };
1327 #endif /* PSZ == 8 */
1328 
1329 #if PSZ == 16
1330 PixelGroup QuartetPixelMaskTable[] = {
1331 #if PGSZ == 32
1332     0x00000000,
1333     0x0000FFFF,
1334     0xFFFF0000,
1335     0xFFFFFFFF,
1336 #else /* PGSZ == 64 */
1337     0x0000000000000000,    0x000000000000FFFF,
1338     0x00000000FFFF0000,    0x00000000FFFFFFFF,
1339     0x0000FFFF00000000,    0x0000FFFF0000FFFF,
1340     0x0000FFFFFFFF0000,    0x0000FFFFFFFFFFFF,
1341     0xFFFF000000000000,    0xFFFF00000000FFFF,
1342     0xFFFF0000FFFF0000,    0xFFFF0000FFFFFFFF,
1343     0xFFFFFFFF00000000,    0xFFFFFFFF0000FFFF,
1344     0xFFFFFFFFFFFF0000,    0xFFFFFFFFFFFFFFFF,
1345 #endif /* PGSZ */
1346 };
1347 #endif /* PSZ == 16 */
1348 
1349 #if PSZ == 24
1350 PixelGroup QuartetPixelMaskTable[] = {
1351 #if PGSZ == 32
1352 /* Four pixels consist three pixel groups....*/
1353     0x00000000, 0x00FFFFFF, /*0x00000000, *//*0*/
1354 /*    0x00000000, 0x00000000, 0x00000000,*/ /*0*/
1355 /*    0x00FFFFFF, 0x00000000, 0x00000000,*/ /*1*/
1356 /*    0xFF000000, 0x0000FFFF, 0x00000000,*/ /*2*/
1357 /*    0xFFFFFFFF, 0x0000FFFF, 0x00000000,*/ /*3*/
1358 /*    0x00000000, 0xFFFF0000, 0x000000FF,*/ /*4*/
1359 /*    0x00FFFFFF, 0xFFFF0000, 0x000000FF,*/ /*5*/
1360 /*    0xFF000000, 0xFFFFFFFF, 0x000000FF,*/ /*6*/
1361 /*    0xFFFFFFFF, 0xFFFFFFFF, 0x000000FF,*/ /*7*/
1362 /*    0x00000000, 0x00000000, 0xFFFFFF00,*/ /*8*/
1363 /*    0x00FFFFFF, 0x00000000, 0xFFFFFF00,*/ /*9*/
1364 /*    0xFF000000, 0x0000FFFF, 0xFFFFFF00,*/ /*10*/
1365 /*    0xFFFFFFFF, 0x0000FFFF, 0xFFFFFF00,*/ /*11*/
1366 /*    0x00000000, 0xFFFF0000, 0xFFFFFFFF,*/ /*12*/
1367 /*    0x00FFFFFF, 0xFFFF0000, 0xFFFFFFFF,*/ /*13*/
1368 /*    0xFF000000, 0xFFFFFFFF, 0xFFFFFFFF,*/ /*14*/
1369 /*    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,*/ /*15*/
1370 #else /* PGSZ == 64 */
1371     0x0000000000000000,    0x0000000000FFFFFF,
1372     0x0000FFFFFF000000,    0xFFFFFFFFFFFFFFFF
1373 #endif /* PGSZ */
1374 };
1375 #endif /* PSZ == 24 */
1376 
1377 #if PSZ == 32
1378 PixelGroup QuartetPixelMaskTable[] = {
1379 #if PGSZ == 32
1380     0x00000000,
1381     0xFFFFFFFF,
1382 #else /* PGSZ == 64 */
1383     0x0000000000000000,
1384     0x00000000FFFFFFFF,
1385     0xFFFFFFFF00000000,
1386     0xFFFFFFFFFFFFFFFF
1387 #endif /* PGSZ */
1388 };
1389 #endif /* PSZ == 32 */
1390 
1391 #if PSZ == 24
1392 int cfb24Shift[] =
1393 #if	(BITMAP_BIT_ORDER == MSBFirst)
1394 {8,0,16,16,8,24,0,0};
1395 #else	/* (BITMAP_BIT_ORDER == LSBFirst) */
1396 {0,0,24,8,16,16,8,0};
1397 #endif	/* (BITMAP_BIT_ORDER == MSBFirst) */
1398 #endif
1399