git.sesse.net Git - rdpsrv/blob - Xserver/programs/Xserver/cfb/cfb8bit.h

   1 /*
   2  * cfb8bit.h
   3  *
   4  * Defines which are only useful to 8 bit color frame buffers
   5  *
   6  * That doesn't seem to be true any more.  Some of the macros in here
   7  * are used for depths other than 8.  Perhaps the file should be
   8  * renamed.  dpw
   9  */
  10
  11 /*
  12
  13 Copyright (c) 1989  X Consortium
  14
  15 Permission is hereby granted, free of charge, to any person obtaining a copy
  16 of this software and associated documentation files (the "Software"), to deal
  17 in the Software without restriction, including without limitation the rights
  18 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  19 copies of the Software, and to permit persons to whom the Software is
  20 furnished to do so, subject to the following conditions:
  21
  22 The above copyright notice and this permission notice shall be included in
  23 all copies or substantial portions of the Software.
  24
  25 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  26 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  27 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  28 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  29 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31
  32 Except as contained in this notice, the name of the X Consortium shall not be
  33 used in advertising or otherwise to promote the sale, use or other dealings
  34 in this Software without prior written authorization from the X Consortium.
  35 */
  36
  37 /* $XConsortium: cfb8bit.h,v 1.18 95/04/07 18:59:27 kaleb Exp $ */
  38 /* $XFree86: xc/programs/Xserver/cfb/cfb8bit.h,v 3.2 1996/06/29 09:05:22 dawes Exp $ */
  39
  40 #include "servermd.h"
  41
  42 #if (BITMAP_BIT_ORDER == MSBFirst)
  43 #define GetBitGroup(x)          (((PixelGroup) (x)) >> (PGSZ - PGSZB))
  44 #define NextBitGroup(x)         ((x) <<= PGSZB)
  45 #define NextSomeBits(x,n)       ((x) <<= (n))
  46 #else
  47 #define GetBitGroup(x)          ((x) & PGSZBMSK)
  48 #define NextBitGroup(x)         ((x) >>= PGSZB)
  49 #define NextSomeBits(x,n)       ((x) >>= (n))
  50 #endif
  51
  52 #define RotBitsLeft(x,k)    ((x) = BitLeft (x,k) | \
  53                                    BitRight (x, PGSZ-(k)))
  54
  55 #if defined(__GNUC__) && defined(mc68020)
  56 #undef RotBitsLeft
  57 #define RotBitsLeft(x,k)        asm("rol%.l %2,%0" \
  58                                 : "=d" (x) \
  59                                 : "0" (x), "dI" (k))
  60 #endif
  61
  62 #if PSZ == 8
  63
  64 #define GetPixelGroup(x)                (cfb8StippleXor[GetBitGroup(x)])
  65 #define RRopPixels(dst,x)       (DoRRop(dst,cfb8StippleAnd[x], cfb8StippleXor[x]))
  66 #define RRopPixelGroup(dst,x)   (RRopPixels(dst,GetBitGroup(x)))
  67 #define MaskRRopPixels(dst,x,mask)  (DoMaskRRop(dst,cfb8StippleAnd[x], cfb8StippleXor[x], mask))
  68
  69 #define NUM_MASKS       (1<<PPW) /* XXX goes in cfbmskbits.h? */
  70 extern int              cfb8StippleMode, cfb8StippleAlu;
  71 extern PixelGroup       cfb8StippleFg, cfb8StippleBg, cfb8StipplePm;
  72 extern PixelGroup       cfb8StippleMasks[NUM_MASKS];
  73 extern PixelGroup       cfb8StippleAnd[NUM_MASKS], cfb8StippleXor[NUM_MASKS];
  74 extern int              cfb8StippleRRop;
  75
  76 #define cfb8PixelMasks  cfb8StippleMasks
  77 #define cfb8Pixels      cfb8StippleXor
  78
  79 #define cfb8CheckPixels(fg, bg) \
  80     (FillOpaqueStippled == cfb8StippleMode && \
  81      GXcopy == cfb8StippleAlu && \
  82      ((fg) & PMSK) == cfb8StippleFg && \
  83      ((bg) & PMSK) == cfb8StippleBg && \
  84      PMSK == cfb8StipplePm)
  85
  86 #define cfb8CheckOpaqueStipple(alu,fg,bg,pm) \
  87     ((FillOpaqueStippled == cfb8StippleMode && \
  88       (alu) == cfb8StippleAlu && \
  89       ((fg) & PMSK) == cfb8StippleFg && \
  90       ((bg) & PMSK) == cfb8StippleBg && \
  91       ((pm) & PMSK) == cfb8StipplePm) ? 0 : cfb8SetOpaqueStipple(alu,fg,bg,pm))
  92
  93 #define cfb8CheckStipple(alu,fg,pm) \
  94     ((FillStippled == cfb8StippleMode && \
  95       (alu) == cfb8StippleAlu && \
  96       ((fg) & PMSK) == cfb8StippleFg && \
  97       ((pm) & PMSK) == cfb8StipplePm) ? 0 : cfb8SetStipple(alu,fg,pm))
  98
  99 #define cfb8SetPixels(fg,bg) cfb8SetOpaqueStipple(GXcopy,fg,bg,PMSK)
 100
 101 /*
 102  * These macros are shared between the unnatural spans code
 103  * and the unnatural rectangle code.  No reasonable person
 104  * would attempt to use them anyplace else.
 105  */
 106
 107 #define NextUnnaturalStippleWord \
 108         if (bitsLeft >= MFB_PPW) \
 109         { \
 110             inputBits = *srcTemp++; \
 111             bitsLeft -= MFB_PPW; \
 112             partBitsLeft = MFB_PPW; \
 113         } \
 114         else \
 115         { \
 116             inputBits = 0; \
 117             if (bitsLeft) \
 118                 inputBits = *srcTemp & ~cfb8BitLenMasks[bitsLeft]; \
 119             srcTemp = srcStart; \
 120             partBitsLeft = bitsLeft; \
 121             bitsLeft = bitsWhole; \
 122         }
 123
 124 #define NextUnnaturalStippleBits \
 125     if (partBitsLeft >= PPW) { \
 126         bits = GetBitGroup (inputBits); \
 127         NextBitGroup (inputBits); \
 128         partBitsLeft -= PPW; \
 129     } else { \
 130         bits = GetBitGroup (inputBits); \
 131         nextPartBits = PPW - partBitsLeft; \
 132         NextUnnaturalStippleWord \
 133         if (partBitsLeft < nextPartBits) { \
 134             if (partBitsLeft) {\
 135                 bits |= BitRight (GetBitGroup (inputBits), \
 136                                   PPW - nextPartBits) & PPWMSK;\
 137                 nextPartBits -= partBitsLeft; \
 138             } \
 139             NextUnnaturalStippleWord \
 140         } \
 141         bits |= BitRight (GetBitGroup (inputBits), \
 142                           PPW - nextPartBits) & PPWMSK; \
 143         NextSomeBits (inputBits, nextPartBits); \
 144         partBitsLeft -= nextPartBits; \
 145     }
 146
 147 #define NextUnnaturalStippleBitsFast \
 148     if (partBitsLeft >= PPW) { \
 149         bits = GetBitGroup(inputBits); \
 150         NextBitGroup(inputBits); \
 151         partBitsLeft -= PPW; \
 152     } else { \
 153         bits = GetBitGroup (inputBits); \
 154         nextPartBits = PPW - partBitsLeft; \
 155         inputBits = *srcTemp++; \
 156         bits |= BitRight (GetBitGroup (inputBits), \
 157                           partBitsLeft) & PPWMSK; \
 158         NextSomeBits (inputBits, nextPartBits); \
 159         partBitsLeft =  MFB_PPW - nextPartBits; \
 160     }
 161
 162 /*
 163  * WriteBitGroup takes the destination address, a pixel
 164  * value (which must be 8 bits duplicated 4 time with PFILL)
 165  * and the PPW bits to write, which must be in the low order
 166  * bits of the register (probably from GetBitGroup) and writes
 167  * the appropriate locations in memory with the pixel value.  This
 168  * is a copy-mode only operation.
 169  */
 170
 171 #define RRopBitGroup(dst,bits)                                  \
 172     {                                                           \
 173     register PixelGroup    _bitsTmp = (bits);                   \
 174     *(dst) = RRopPixels(*(dst),bits);                           \
 175     }
 176
 177 #define MaskRRopBitGroup(dst,bits,mask)                         \
 178     {                                                           \
 179     register PixelGroup   _bitsTmp = (bits);                    \
 180     *(dst) = MaskRRopPixels(*(dst),bits,mask);                  \
 181     }
 182 #endif /* PSZ == 8 */
 183
 184 #if !defined(AVOID_MEMORY_READ) && PSZ == 8
 185
 186 #define WriteBitGroup(dst,pixel,bits)                           \
 187     {                                                           \
 188     register PixelGroup _maskTmp = cfb8PixelMasks[(bits)];   \
 189     *(dst) = (*(dst) & ~_maskTmp) | ((pixel) & _maskTmp);       \
 190     }
 191
 192 #define SwitchBitGroup(dst,pixel,bits)                          \
 193     {                                                           \
 194     register PixelGroup _maskTmp = cfb8PixelMasks[(bits)];   \
 195     register PixelGroup _pixTmp = ((pixel) & _maskTmp); \
 196     _maskTmp = ~_maskTmp;                                       \
 197     SwitchBitsLoop (*(dst) = (*(dst) & _maskTmp) | _pixTmp;)    \
 198     }
 199
 200 #else /* AVOID_MEMORY_READ */
 201
 202 #if PGSZ == 32
 203 #if (BITMAP_BIT_ORDER == MSBFirst)
 204 #define SinglePixel0    3
 205 #define SinglePixel1    2
 206 #define SinglePixel2    1
 207 #define SinglePixel3    0
 208 #define SinglePixel4    7
 209 #define SinglePixel5    6
 210 #define SinglePixel6    5
 211 #define SinglePixel7    4
 212 #define SinglePixel8    0xB
 213 #define SinglePixel9    0xA
 214 #define DoublePixel0    1
 215 #define DoublePixel1    0
 216 #define DoublePixel2    3
 217 #define DoublePixel3    2
 218 #define DoublePixel4    5
 219 #define DoublePixel5    4
 220 #else
 221 #define SinglePixel0    0
 222 #define SinglePixel1    1
 223 #define SinglePixel2    2
 224 #define SinglePixel3    3
 225 #define SinglePixel4    4
 226 #define SinglePixel5    5
 227 #define SinglePixel6    6
 228 #define SinglePixel7    7
 229 #define SinglePixel8    8
 230 #define SinglePixel9    9
 231 #define DoublePixel0    0
 232 #define DoublePixel1    1
 233 #define DoublePixel2    2
 234 #define DoublePixel3    3
 235 #define DoublePixel4    4
 236 #define DoublePixel5    5
 237 #endif
 238 #define QuadPixel0      0
 239 #define QuadPixel1      1
 240 #define QuadPixel2      2
 241 #else /* PGSZ == 64 */
 242 #if (BITMAP_BIT_ORDER == MSBFirst)
 243 #define SinglePixel0    7
 244 #define SinglePixel1    6
 245 #define SinglePixel2    5
 246 #define SinglePixel3    4
 247 #define SinglePixel4    3
 248 #define SinglePixel5    2
 249 #define SinglePixel6    1
 250 #define SinglePixel7    0
 251 #define DoublePixel0    3
 252 #define DoublePixel1    2
 253 #define DoublePixel2    1
 254 #define DoublePixel3    0
 255 #define QuadPixel0      1
 256 #define QuadPixel1      0
 257 #else
 258 #define SinglePixel0    0
 259 #define SinglePixel1    1
 260 #define SinglePixel2    2
 261 #define SinglePixel3    3
 262 #define SinglePixel4    4
 263 #define SinglePixel5    5
 264 #define SinglePixel6    6
 265 #define SinglePixel7    7
 266 #define DoublePixel0    0
 267 #define DoublePixel1    1
 268 #define DoublePixel2    2
 269 #define DoublePixel3    3
 270 #define QuadPixel0      0
 271 #define QuadPixel1      1
 272 #endif
 273 #define OctaPixel0      0
 274 #endif /* PGSZ == 64 */
 275
 276 #if PSZ == 8
 277
 278 #if PGSZ == 32
 279 #define WriteBitGroup(dst,pixel,bits) \
 280         switch (bits) {                 \
 281         case 0:                         \
 282             break;                      \
 283         case 1:                         \
 284             ((CARD8 *) (dst))[SinglePixel0] = (pixel);  \
 285             break;                      \
 286         case 2:                         \
 287             ((CARD8 *) (dst))[SinglePixel1] = (pixel);  \
 288             break;                      \
 289         case 3:                         \
 290             ((CARD16 *) (dst))[DoublePixel0] = (pixel); \
 291             break;                      \
 292         case 4:                         \
 293             ((CARD8 *) (dst))[SinglePixel2] = (pixel);  \
 294             break;                      \
 295         case 5:                         \
 296             ((CARD8 *) (dst))[SinglePixel0] = (pixel);  \
 297             ((CARD8 *) (dst))[SinglePixel2] = (pixel);  \
 298             break;                      \
 299         case 6:                         \
 300             ((CARD8 *) (dst))[SinglePixel1] = (pixel);  \
 301             ((CARD8 *) (dst))[SinglePixel2] = (pixel);  \
 302             break;                      \
 303         case 7:                         \
 304             ((CARD16 *) (dst))[DoublePixel0] = (pixel); \
 305             ((CARD8 *) (dst))[SinglePixel2] = (pixel);  \
 306             break;                      \
 307         case 8:                         \
 308             ((CARD8 *) (dst))[SinglePixel3] = (pixel);  \
 309             break;                      \
 310         case 9:                         \
 311             ((CARD8 *) (dst))[SinglePixel0] = (pixel);  \
 312             ((CARD8 *) (dst))[SinglePixel3] = (pixel);  \
 313             break;                      \
 314         case 10:                        \
 315             ((CARD8 *) (dst))[SinglePixel1] = (pixel);  \
 316             ((CARD8 *) (dst))[SinglePixel3] = (pixel);  \
 317             break;                      \
 318         case 11:                        \
 319             ((CARD16 *) (dst))[DoublePixel0] = (pixel); \
 320             ((CARD8 *) (dst))[SinglePixel3] = (pixel);  \
 321             break;                      \
 322         case 12:                        \
 323             ((CARD16 *) (dst))[DoublePixel1] = (pixel); \
 324             break;                      \
 325         case 13:                        \
 326             ((CARD8 *) (dst))[SinglePixel0] = (pixel);  \
 327             ((CARD16 *) (dst))[DoublePixel1] = (pixel); \
 328             break;                      \
 329         case 14:                        \
 330             ((CARD8 *) (dst))[SinglePixel1] = (pixel);  \
 331             ((CARD16 *) (dst))[DoublePixel1] = (pixel); \
 332             break;                      \
 333         case 15:                        \
 334             ((CARD32 *) (dst))[0] = (pixel);    \
 335             break;                      \
 336         }
 337 #else /* PGSZ == 64 */
 338 #define WriteBitGroup(dst,pixel,bits)                           \
 339     if ( bits == 0xff )                                         \
 340         ((PixelGroup *) (dst))[OctaPixel0] = (pixel);           \
 341     else {                                                      \
 342         switch (bits & 0x0f) {                                  \
 343             case 0:                                             \
 344                 break;                                          \
 345             case 1:                                             \
 346                 ((CARD8 *) (dst))[SinglePixel0] = (pixel);      \
 347                 break;                                          \
 348             case 2:                                             \
 349                 ((CARD8 *) (dst))[SinglePixel1] = (pixel);      \
 350                 break;                                          \
 351             case 3:                                             \
 352                 ((CARD16 *) (dst))[DoublePixel0] = (pixel);     \
 353                 break;                                          \
 354             case 4:                                             \
 355                 ((CARD8 *) (dst))[SinglePixel2] = (pixel);      \
 356                 break;                                          \
 357             case 5:                                             \
 358                 ((CARD8 *) (dst))[SinglePixel0] = (pixel);      \
 359                 ((CARD8 *) (dst))[SinglePixel2] = (pixel);      \
 360                 break;                                          \
 361             case 6:                                             \
 362                 ((CARD8 *) (dst))[SinglePixel1] = (pixel);      \
 363                 ((CARD8 *) (dst))[SinglePixel2] = (pixel);      \
 364                 break;                                          \
 365             case 7:                                             \
 366                 ((CARD16 *) (dst))[DoublePixel0] = (pixel);     \
 367                 ((CARD8 *) (dst))[SinglePixel2] = (pixel);      \
 368                 break;                                          \
 369             case 8:                                             \
 370                 ((CARD8 *) (dst))[SinglePixel3] = (pixel);      \
 371                 break;                                          \
 372             case 9:                                             \
 373                 ((CARD8 *) (dst))[SinglePixel0] = (pixel);      \
 374                 ((CARD8 *) (dst))[SinglePixel3] = (pixel);      \
 375                 break;                                          \
 376             case 10:                                            \
 377                 ((CARD8 *) (dst))[SinglePixel1] = (pixel);      \
 378                 ((CARD8 *) (dst))[SinglePixel3] = (pixel);      \
 379                 break;                                          \
 380             case 11:                                            \
 381                 ((CARD16 *) (dst))[DoublePixel0] = (pixel);     \
 382                 ((CARD8 *) (dst))[SinglePixel3] = (pixel);      \
 383                 break;                                          \
 384             case 12:                                            \
 385                 ((CARD16 *) (dst))[DoublePixel1] = (pixel);     \
 386                 break;                                          \
 387             case 13:                                            \
 388                 ((CARD8 *) (dst))[SinglePixel0] = (pixel);      \
 389                 ((CARD16 *) (dst))[DoublePixel1] = (pixel);     \
 390                 break;                                          \
 391             case 14:                                            \
 392                 ((CARD8 *) (dst))[SinglePixel1] = (pixel);      \
 393                 ((CARD16 *) (dst))[DoublePixel1] = (pixel);     \
 394                 break;                                          \
 395             case 15:                                            \
 396                 ((CARD32 *) (dst))[QuadPixel0] = (pixel);       \
 397                 break;                                          \
 398         }                                                       \
 399         switch ((bits & 0xf0) >> 4) {                           \
 400             case 0:                                             \
 401                 break;                                          \
 402             case 1:                                             \
 403                 ((CARD8 *) (dst))[SinglePixel4] = (pixel);      \
 404                 break;                                          \
 405             case 2:                                             \
 406                 ((CARD8 *) (dst))[SinglePixel5] = (pixel);      \
 407                 break;                                          \
 408             case 3:                                             \
 409                 ((CARD16 *) (dst))[DoublePixel2] = (pixel);     \
 410                 break;                                          \
 411             case 4:                                             \
 412                 ((CARD8 *) (dst))[SinglePixel6] = (pixel);      \
 413                 break;                                          \
 414             case 5:                                             \
 415                 ((CARD8 *) (dst))[SinglePixel4] = (pixel);      \
 416                 ((CARD8 *) (dst))[SinglePixel6] = (pixel);      \
 417                 break;                                          \
 418             case 6:                                             \
 419                 ((CARD8 *) (dst))[SinglePixel5] = (pixel);      \
 420                 ((CARD8 *) (dst))[SinglePixel6] = (pixel);      \
 421                 break;                                          \
 422             case 7:                                             \
 423                 ((CARD16 *) (dst))[DoublePixel2] = (pixel);     \
 424                 ((CARD8 *) (dst))[SinglePixel6] = (pixel);      \
 425                 break;                                          \
 426             case 8:                                             \
 427                 ((CARD8 *) (dst))[SinglePixel7] = (pixel);      \
 428                 break;                                          \
 429             case 9:                                             \
 430                 ((CARD8 *) (dst))[SinglePixel4] = (pixel);      \
 431                 ((CARD8 *) (dst))[SinglePixel7] = (pixel);      \
 432                 break;                                          \
 433             case 10:                                            \
 434                 ((CARD8 *) (dst))[SinglePixel5] = (pixel);      \
 435                 ((CARD8 *) (dst))[SinglePixel7] = (pixel);      \
 436                 break;                                          \
 437             case 11:                                            \
 438                 ((CARD16 *) (dst))[DoublePixel2] = (pixel);     \
 439                 ((CARD8 *) (dst))[SinglePixel7] = (pixel);      \
 440                 break;                                          \
 441             case 12:                                            \
 442                 ((CARD16 *) (dst))[DoublePixel3] = (pixel);     \
 443                 break;                                          \
 444             case 13:                                            \
 445                 ((CARD8 *) (dst))[SinglePixel4] = (pixel);      \
 446                 ((CARD16 *) (dst))[DoublePixel3] = (pixel);     \
 447                 break;                                          \
 448             case 14:                                            \
 449                 ((CARD8 *) (dst))[SinglePixel5] = (pixel);      \
 450                 ((CARD16 *) (dst))[DoublePixel3] = (pixel);     \
 451                 break;                                          \
 452             case 15:                                            \
 453                 ((CARD32 *) (dst))[QuadPixel1] = (pixel);       \
 454                 break;                                          \
 455         }                                                       \
 456     }
 457 #endif /* PGSZ == 64 */
 458
 459 #if PGSZ == 32
 460 #define SwitchBitGroup(dst,pixel,bits) { \
 461         switch (bits) { \
 462         case 0: \
 463             break; \
 464         case 1: \
 465             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel0] = (pixel);) \
 466             break; \
 467         case 2: \
 468             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel1] = (pixel);) \
 469             break; \
 470         case 3: \
 471             SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel0] = (pixel);) \
 472             break; \
 473         case 4: \
 474             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel2] = (pixel);) \
 475             break; \
 476         case 5: \
 477             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel0] = (pixel); \
 478                      ((CARD8 *) (dst))[SinglePixel2] = (pixel);) \
 479             break; \
 480         case 6: \
 481             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel1] = (pixel); \
 482                      ((CARD8 *) (dst))[SinglePixel2] = (pixel);) \
 483             break; \
 484         case 7: \
 485             SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel0] = (pixel); \
 486                      ((CARD8 *) (dst))[SinglePixel2] = (pixel);) \
 487             break; \
 488         case 8: \
 489             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel3] = (pixel);) \
 490             break; \
 491         case 9: \
 492             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel0] = (pixel); \
 493                      ((CARD8 *) (dst))[SinglePixel3] = (pixel);) \
 494             break; \
 495         case 10: \
 496             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel1] = (pixel); \
 497                      ((CARD8 *) (dst))[SinglePixel3] = (pixel);) \
 498             break; \
 499         case 11: \
 500             SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel0] = (pixel); \
 501                      ((CARD8 *) (dst))[SinglePixel3] = (pixel);) \
 502             break; \
 503         case 12: \
 504             SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel1] = (pixel);) \
 505             break; \
 506         case 13: \
 507             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel0] = (pixel); \
 508                      ((CARD16 *) (dst))[DoublePixel1] = (pixel);) \
 509             break; \
 510         case 14: \
 511             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel1] = (pixel); \
 512                      ((CARD16 *) (dst))[DoublePixel1] = (pixel);) \
 513             break; \
 514         case 15: \
 515             SwitchBitsLoop (((CARD32 *) (dst))[0] = (pixel);) \
 516             break; \
 517         } \
 518 }
 519 #else /* PGSZ == 64 */
 520 #define SwitchBitGroup(dst,pixel,bits) {                                   \
 521     if ( bits == 0xff )                                                    \
 522         SwitchBitsLoop (((PixelGroup *) (dst))[OctaPixel0] = (pixel);)     \
 523     else {                                                                 \
 524         switch (bits & 0x0f) {                                             \
 525             case 0:                                                        \
 526                 break;                                                     \
 527             case 1:                                                        \
 528                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel0] = (pixel);) \
 529                 break;                                                     \
 530             case 2:                                                        \
 531                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel1] = (pixel);) \
 532                 break;                                                     \
 533             case 3:                                                        \
 534                 SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel0] = (pixel);)\
 535                 break;                                                     \
 536             case 4:                                                        \
 537                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel2] = (pixel);) \
 538                 break;                                                     \
 539             case 5:                                                        \
 540                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel0] = (pixel);  \
 541                                 ((CARD8 *) (dst))[SinglePixel2] = (pixel);) \
 542                 break;                                                     \
 543             case 6:                                                        \
 544                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel1] = (pixel);  \
 545                                 ((CARD8 *) (dst))[SinglePixel2] = (pixel);) \
 546                 break;                                                     \
 547             case 7:                                                        \
 548                 SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel0] = (pixel); \
 549                                 ((CARD8 *) (dst))[SinglePixel2] = (pixel);) \
 550                 break;                                                     \
 551             case 8:                                                        \
 552                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel3] = (pixel);) \
 553                 break;                                                     \
 554             case 9:                                                        \
 555                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel0] = (pixel);  \
 556                                 ((CARD8 *) (dst))[SinglePixel3] = (pixel);) \
 557                 break;                                                     \
 558             case 10:                                                       \
 559                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel1] = (pixel);  \
 560                                 ((CARD8 *) (dst))[SinglePixel3] = (pixel);) \
 561                 break;                                                     \
 562             case 11:                                                       \
 563                 SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel0] = (pixel); \
 564                                 ((CARD8 *) (dst))[SinglePixel3] = (pixel);) \
 565                 break;                                                     \
 566             case 12:                                                       \
 567                 SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel1] = (pixel);)\
 568                 break;                                                     \
 569             case 13:                                                       \
 570                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel0] = (pixel);  \
 571                                 ((CARD16 *) (dst))[DoublePixel1] = (pixel);)\
 572                 break;                                                     \
 573             case 14:                                                       \
 574                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel1] = (pixel);  \
 575                                 ((CARD16 *) (dst))[DoublePixel1] = (pixel);)\
 576                 break;                                                     \
 577             case 15:                                                       \
 578                 SwitchBitsLoop (((CARD32 *) (dst))[QuadPixel0] = (pixel);)    \
 579                 break;                                                     \
 580         }                                                                  \
 581         switch ((bits & 0xf0) >> 4) {                                      \
 582             case 0:                                                        \
 583                 break;                                                     \
 584             case 1:                                                        \
 585                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel4] = (pixel);) \
 586                 break;                                                     \
 587             case 2:                                                        \
 588                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel5] = (pixel);) \
 589                 break;                                                     \
 590             case 3:                                                        \
 591                 SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel2] = (pixel);)\
 592                 break;                                                     \
 593             case 4:                                                        \
 594                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel6] = (pixel);) \
 595                 break;                                                     \
 596             case 5:                                                        \
 597                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel4] = (pixel);  \
 598                                 ((CARD8 *) (dst))[SinglePixel6] = (pixel);) \
 599                 break;                                                     \
 600             case 6:                                                        \
 601                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel5] = (pixel);  \
 602                                 ((CARD8 *) (dst))[SinglePixel6] = (pixel);) \
 603                 break;                                                     \
 604             case 7:                                                        \
 605                 SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel2] = (pixel); \
 606                                 ((CARD8 *) (dst))[SinglePixel6] = (pixel);) \
 607                 break;                                                     \
 608             case 8:                                                        \
 609                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel7] = (pixel);) \
 610                 break;                                                     \
 611             case 9:                                                        \
 612                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel4] = (pixel);  \
 613                                 ((CARD8 *) (dst))[SinglePixel7] = (pixel);) \
 614                 break;                                                     \
 615             case 10:                                                       \
 616                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel5] = (pixel);  \
 617                                 ((CARD8 *) (dst))[SinglePixel7] = (pixel);) \
 618                 break;                                                     \
 619             case 11:                                                       \
 620                 SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel2] = (pixel); \
 621                                 ((CARD8 *) (dst))[SinglePixel7] = (pixel);) \
 622                 break;                                                     \
 623             case 12:                                                       \
 624                 SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel3] = (pixel);)\
 625                 break;                                                     \
 626             case 13:                                                       \
 627                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel4] = (pixel);  \
 628                                 ((CARD16 *) (dst))[DoublePixel3] = (pixel);)\
 629                 break;                                                     \
 630             case 14:                                                       \
 631                 SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel5] = (pixel);  \
 632                                 ((CARD16 *) (dst))[DoublePixel3] = (pixel);)\
 633                 break;                                                     \
 634             case 15:                                                       \
 635                 SwitchBitsLoop (((CARD32 *) (dst))[QuadPixel1] = (pixel);) \
 636                 break;                                                     \
 637         }                                                                  \
 638     }                                                                      \
 639 }
 640 #endif /* PGSZ == 64 */
 641 #endif /* PSZ == 8 */
 642
 643 #if PSZ == 16
 644
 645 #if PGSZ == 32
 646 #define WriteBitGroup(dst,pixel,bits) \
 647         switch (bits) {                 \
 648         case 0:                         \
 649             break;                      \
 650         case 1:                         \
 651             ((CARD16 *) (dst))[SinglePixel0] = (pixel); \
 652             break;                      \
 653         case 2:                         \
 654             ((CARD16 *) (dst))[SinglePixel1] = (pixel); \
 655             break;                      \
 656         case 3:                         \
 657             ((CARD32 *) (dst))[DoublePixel0] = (pixel); \
 658             break;                      \
 659         case 4:                         \
 660             ((CARD16 *) (dst))[SinglePixel2] = (pixel); \
 661             break;                      \
 662         case 5:                         \
 663             ((CARD16 *) (dst))[SinglePixel0] = (pixel); \
 664             ((CARD16 *) (dst))[SinglePixel2] = (pixel); \
 665             break;                      \
 666         case 6:                         \
 667             ((CARD16 *) (dst))[SinglePixel1] = (pixel); \
 668             ((CARD16 *) (dst))[SinglePixel2] = (pixel); \
 669             break;                      \
 670         case 7:                         \
 671             ((CARD32 *) (dst))[DoublePixel0] = (pixel); \
 672             ((CARD16 *) (dst))[SinglePixel2] = (pixel); \
 673             break;                      \
 674         case 8:                         \
 675             ((CARD16 *) (dst))[SinglePixel3] = (pixel); \
 676             break;                      \
 677         case 9:                         \
 678             ((CARD16 *) (dst))[SinglePixel0] = (pixel); \
 679             ((CARD16 *) (dst))[SinglePixel3] = (pixel); \
 680             break;                      \
 681         case 10:                        \
 682             ((CARD16 *) (dst))[SinglePixel1] = (pixel); \
 683             ((CARD16 *) (dst))[SinglePixel3] = (pixel); \
 684             break;                      \
 685         case 11:                        \
 686             ((CARD32 *) (dst))[DoublePixel0] = (pixel); \
 687             ((CARD16 *) (dst))[SinglePixel3] = (pixel); \
 688             break;                      \
 689         case 12:                        \
 690             ((CARD32 *) (dst))[DoublePixel1] = (pixel); \
 691             break;                      \
 692         case 13:                        \
 693             ((CARD16 *) (dst))[SinglePixel0] = (pixel); \
 694             ((CARD32 *) (dst))[DoublePixel1] = (pixel); \
 695             break;                      \
 696         case 14:                        \
 697             ((CARD16 *) (dst))[SinglePixel1] = (pixel); \
 698             ((CARD32 *) (dst))[DoublePixel1] = (pixel); \
 699             break;                      \
 700         case 15:                        \
 701             ((CARD32 *) (dst))[DoublePixel0] = (pixel); \
 702             ((CARD32 *) (dst))[DoublePixel1] = (pixel); \
 703             break;                      \
 704         }
 705 #else /* PGSZ == 64 */
 706 #define WriteBitGroup(dst,pixel,bits) \
 707     if ( bits == 0xff ) {                                               \
 708         ((PixelGroup *) (dst))[QuadPixel0] = (pixel);                   \
 709         ((PixelGroup *) (dst))[QuadPixel1] = (pixel);                   \
 710     }                                                                   \
 711     else {                                                              \
 712         switch (bits & 0x0f) {                                          \
 713         case 0:                         \
 714             break;                      \
 715         case 1:                         \
 716             ((CARD16 *) (dst))[SinglePixel0] = (pixel); \
 717             break;                      \
 718         case 2:                         \
 719             ((CARD16 *) (dst))[SinglePixel1] = (pixel); \
 720             break;                      \
 721         case 3:                         \
 722             ((CARD32 *) (dst))[DoublePixel0] = (pixel); \
 723             break;                      \
 724         case 4:                         \
 725             ((CARD16 *) (dst))[SinglePixel2] = (pixel); \
 726             break;                      \
 727         case 5:                         \
 728             ((CARD16 *) (dst))[SinglePixel0] = (pixel); \
 729             ((CARD16 *) (dst))[SinglePixel2] = (pixel); \
 730             break;                      \
 731         case 6:                         \
 732             ((CARD16 *) (dst))[SinglePixel1] = (pixel); \
 733             ((CARD16 *) (dst))[SinglePixel2] = (pixel); \
 734             break;                      \
 735         case 7:                         \
 736             ((CARD32 *) (dst))[DoublePixel0] = (pixel); \
 737             ((CARD16 *) (dst))[SinglePixel2] = (pixel); \
 738             break;                      \
 739         case 8:                         \
 740             ((CARD16 *) (dst))[SinglePixel3] = (pixel); \
 741             break;                      \
 742         case 9:                         \
 743             ((CARD16 *) (dst))[SinglePixel0] = (pixel); \
 744             ((CARD16 *) (dst))[SinglePixel3] = (pixel); \
 745             break;                      \
 746         case 10:                        \
 747             ((CARD16 *) (dst))[SinglePixel1] = (pixel); \
 748             ((CARD16 *) (dst))[SinglePixel3] = (pixel); \
 749             break;                      \
 750         case 11:                        \
 751             ((CARD32 *) (dst))[DoublePixel0] = (pixel); \
 752             ((CARD16 *) (dst))[SinglePixel3] = (pixel); \
 753             break;                      \
 754         case 12:                        \
 755             ((CARD32 *) (dst))[DoublePixel1] = (pixel); \
 756             break;                      \
 757         case 13:                        \
 758             ((CARD16 *) (dst))[SinglePixel0] = (pixel); \
 759             ((CARD32 *) (dst))[DoublePixel1] = (pixel); \
 760             break;                      \
 761         case 14:                        \
 762             ((CARD16 *) (dst))[SinglePixel1] = (pixel); \
 763             ((CARD32 *) (dst))[DoublePixel1] = (pixel); \
 764             break;                      \
 765         case 15:                        \
 766             ((CARD32 *) (dst))[DoublePixel0] = (pixel); \
 767             ((CARD32 *) (dst))[DoublePixel1] = (pixel); \
 768             break;                      \
 769         }                               \
 770         switch ((bits & 0xf0) >> 4) {                   \
 771         case 0:                         \
 772             break;                      \
 773         case 1:                         \
 774             ((CARD16 *) (dst))[SinglePixel4] = (pixel); \
 775             break;                      \
 776         case 2:                         \
 777             ((CARD16 *) (dst))[SinglePixel5] = (pixel); \
 778             break;                      \
 779         case 3:                         \
 780             ((CARD32 *) (dst))[DoublePixel2] = (pixel); \
 781             break;                      \
 782         case 4:                         \
 783             ((CARD16 *) (dst))[SinglePixel6] = (pixel); \
 784             break;                      \
 785         case 5:                         \
 786             ((CARD16 *) (dst))[SinglePixel4] = (pixel); \
 787             ((CARD16 *) (dst))[SinglePixel6] = (pixel); \
 788             break;                      \
 789         case 6:                         \
 790             ((CARD16 *) (dst))[SinglePixel5] = (pixel); \
 791             ((CARD16 *) (dst))[SinglePixel6] = (pixel); \
 792             break;                      \
 793         case 7:                         \
 794             ((CARD32 *) (dst))[DoublePixel2] = (pixel); \
 795             ((CARD16 *) (dst))[SinglePixel6] = (pixel); \
 796             break;                      \
 797         case 8:                         \
 798             ((CARD16 *) (dst))[SinglePixel7] = (pixel); \
 799             break;                      \
 800         case 9:                         \
 801             ((CARD16 *) (dst))[SinglePixel4] = (pixel); \
 802             ((CARD16 *) (dst))[SinglePixel7] = (pixel); \
 803             break;                      \
 804         case 10:                        \
 805             ((CARD16 *) (dst))[SinglePixel5] = (pixel); \
 806             ((CARD16 *) (dst))[SinglePixel7] = (pixel); \
 807             break;                      \
 808         case 11:                        \
 809             ((CARD32 *) (dst))[DoublePixel2] = (pixel); \
 810             ((CARD16 *) (dst))[SinglePixel7] = (pixel); \
 811             break;                      \
 812         case 12:                        \
 813             ((CARD32 *) (dst))[DoublePixel3] = (pixel); \
 814             break;                      \
 815         case 13:                        \
 816             ((CARD16 *) (dst))[SinglePixel4] = (pixel); \
 817             ((CARD32 *) (dst))[DoublePixel3] = (pixel); \
 818             break;                      \
 819         case 14:                        \
 820             ((CARD16 *) (dst))[SinglePixel5] = (pixel); \
 821             ((CARD32 *) (dst))[DoublePixel3] = (pixel); \
 822             break;                      \
 823         case 15:                        \
 824             ((CARD32 *) (dst))[DoublePixel2] = (pixel); \
 825             ((CARD32 *) (dst))[DoublePixel3] = (pixel); \
 826             break;                      \
 827         }                               \
 828     }
 829 #endif /* PGSZ */
 830
 831 #if PGSZ == 32
 832 #define SwitchBitGroup(dst,pixel,bits) { \
 833         switch (bits) { \
 834         case 0: \
 835             break; \
 836         case 1: \
 837             SwitchBitsLoop (((CARD16 *) (dst))[SinglePixel0] = (pixel);) \
 838             break; \
 839         case 2: \
 840             SwitchBitsLoop (((CARD16 *) (dst))[SinglePixel1] = (pixel);) \
 841             break; \
 842         case 3: \
 843             SwitchBitsLoop (((CARD32 *) (dst))[DoublePixel0] = (pixel);) \
 844             break; \
 845         case 4: \
 846             SwitchBitsLoop (((CARD16 *) (dst))[SinglePixel2] = (pixel);) \
 847             break; \
 848         case 5: \
 849             SwitchBitsLoop (((CARD16 *) (dst))[SinglePixel0] = (pixel); \
 850                      ((CARD16 *) (dst))[SinglePixel2] = (pixel);) \
 851             break; \
 852         case 6: \
 853             SwitchBitsLoop (((CARD16 *) (dst))[SinglePixel1] = (pixel); \
 854                      ((CARD16 *) (dst))[SinglePixel2] = (pixel);) \
 855             break; \
 856         case 7: \
 857             SwitchBitsLoop (((CARD32 *) (dst))[DoublePixel0] = (pixel); \
 858                      ((CARD16 *) (dst))[SinglePixel2] = (pixel);) \
 859             break; \
 860         case 8: \
 861             SwitchBitsLoop (((CARD16 *) (dst))[SinglePixel3] = (pixel);) \
 862             break; \
 863         case 9: \
 864             SwitchBitsLoop (((CARD16 *) (dst))[SinglePixel0] = (pixel); \
 865                      ((CARD16 *) (dst))[SinglePixel3] = (pixel);) \
 866             break; \
 867         case 10: \
 868             SwitchBitsLoop (((CARD16 *) (dst))[SinglePixel1] = (pixel); \
 869                      ((CARD16 *) (dst))[SinglePixel3] = (pixel);) \
 870             break; \
 871         case 11: \
 872             SwitchBitsLoop (((CARD32 *) (dst))[DoublePixel0] = (pixel); \
 873                      ((CARD16 *) (dst))[SinglePixel3] = (pixel);) \
 874             break; \
 875         case 12: \
 876             SwitchBitsLoop (((CARD32 *) (dst))[DoublePixel1] = (pixel);) \
 877             break; \
 878         case 13: \
 879             SwitchBitsLoop (((CARD16 *) (dst))[SinglePixel0] = (pixel); \
 880                      ((CARD32 *) (dst))[DoublePixel1] = (pixel);) \
 881             break; \
 882         case 14: \
 883             SwitchBitsLoop (((CARD16 *) (dst))[SinglePixel1] = (pixel); \
 884                      ((CARD32 *) (dst))[DoublePixel1] = (pixel);) \
 885             break; \
 886         case 15: \
 887             SwitchBitsLoop (((CARD32 *) (dst))[DoublePixel0] = (pixel); \
 888                             ((CARD32 *) (dst))[DoublePixel1] = (pixel);) \
 889             break; \
 890         } \
 891 }
 892 #else /* PGSZ == 64 */
 893 #define SwitchBitGroup(dst,pixel,bits) { \
 894         cfb cannot hack 64-bit SwitchBitGroup psz=PSZ
 895 #endif /* PGSZ */
 896
 897 #endif /* PSZ == 16 */
 898
 899 #if PSZ == 24
 900 /* 32 000011112222*/
 901 /* 24 000111222333*/
 902 /* 16 001122334455*/
 903 /*  8 0123456789AB*/
 904 #if PGSZ == 32
 905 #define WriteBitGroup(dst,pixel,bits) \
 906         { \
 907         register CARD32 reg_pixel = (pixel); \
 908         switch (bits) {                 \
 909         case 0:                         \
 910             break;                      \
 911         case 1:                         \
 912             ((CARD16 *) (dst))[DoublePixel0] = reg_pixel;       \
 913             ((CARD8 *) (dst))[SinglePixel2] = ((reg_pixel>>16)&0xFF);   \
 914             break;                      \
 915         case 2:                         \
 916             ((CARD8 *) (dst))[SinglePixel3] = reg_pixel&0xFF;   \
 917             ((CARD16 *) (dst))[DoublePixel2] = (reg_pixel>>8)&0xFFFF;   \
 918             break;                      \
 919         case 3:                         \
 920             ((CARD8 *) (dst))[SinglePixel3] = reg_pixel & 0xFF; \
 921             ((CARD16 *) (dst))[DoublePixel0] = reg_pixel;       \
 922             ((CARD16 *) (dst))[DoublePixel2] = (reg_pixel>>8)&0xFFFF;   \
 923             ((CARD8 *) (dst))[SinglePixel2] = (reg_pixel>>16&0xFF);     \
 924             break;                      \
 925         case 4:                         \
 926             ((CARD16 *) (dst))[DoublePixel3] = reg_pixel;       \
 927             ((CARD8 *) (dst))[SinglePixel8] = (reg_pixel>>16)&0xFF; \
 928             break;                      \
 929         case 5:                         \
 930             ((CARD16 *) (dst))[DoublePixel0] = \
 931             ((CARD16 *) (dst))[DoublePixel3] = reg_pixel;       \
 932             reg_pixel >>= 16;   \
 933             ((CARD8 *) (dst))[SinglePixel2] = \
 934             ((CARD8 *) (dst))[SinglePixel8] = reg_pixel&0xFF; \
 935             break;                      \
 936         case 6:                         \
 937             ((CARD8 *) (dst))[SinglePixel3] = reg_pixel;        \
 938             ((CARD16 *) (dst))[DoublePixel3] = reg_pixel;       \
 939             reg_pixel >>= 8;    \
 940             ((CARD16 *) (dst))[DoublePixel2] = reg_pixel;       \
 941             reg_pixel >>= 8;    \
 942             ((CARD8 *) (dst))[SinglePixel8] = reg_pixel&0xFF; \
 943             break;                      \
 944         case 7:                         \
 945             ((CARD16 *) (dst))[DoublePixel0] = \
 946             ((CARD16 *) (dst))[DoublePixel3] = reg_pixel;       \
 947             ((CARD8 *) (dst))[SinglePixel3] = reg_pixel&0xFF;   \
 948             reg_pixel >>= 8;    \
 949             ((CARD16 *) (dst))[DoublePixel2] = reg_pixel;       \
 950             reg_pixel >>= 8;    \
 951             ((CARD8 *) (dst))[SinglePixel2] = \
 952             ((CARD8 *) (dst))[SinglePixel8] = reg_pixel&0xFF; \
 953             break;                      \
 954         case 8:                         \
 955             ((CARD8 *) (dst))[SinglePixel9] = reg_pixel&0xFF;   \
 956             ((CARD16 *) (dst))[DoublePixel5] = (reg_pixel>>8);  \
 957             break;                      \
 958         case 9:                         \
 959             ((CARD16 *) (dst))[DoublePixel0] = reg_pixel;       \
 960             ((CARD8 *) (dst))[SinglePixel9] = reg_pixel&0xFF;   \
 961             reg_pixel >>= 8;    \
 962             ((CARD16 *) (dst))[DoublePixel5] = reg_pixel;       \
 963             reg_pixel >>= 8;    \
 964             ((CARD8 *) (dst))[SinglePixel2] = reg_pixel&0xFF;   \
 965             break;                      \
 966         case 10:                        \
 967             ((CARD8 *) (dst))[SinglePixel3] = \
 968             ((CARD8 *) (dst))[SinglePixel9] = reg_pixel&0xFF;   \
 969             reg_pixel >>= 8;    \
 970             ((CARD16 *) (dst))[DoublePixel2] = \
 971             ((CARD16 *) (dst))[DoublePixel5] = reg_pixel;       \
 972             break;                      \
 973         case 11:                        \
 974             ((CARD8 *) (dst))[SinglePixel3] = \
 975             ((CARD8 *) (dst))[SinglePixel9] = reg_pixel;        \
 976             ((CARD16 *) (dst))[DoublePixel0] = reg_pixel;       \
 977             reg_pixel >>= 8;    \
 978             ((CARD16 *) (dst))[DoublePixel2] = \
 979             ((CARD16 *) (dst))[DoublePixel5] = reg_pixel;       \
 980             reg_pixel >>= 8;    \
 981             ((CARD8 *) (dst))[SinglePixel2] = reg_pixel;        \
 982             break;                      \
 983         case 12:                        \
 984             ((CARD16 *) (dst))[DoublePixel3] = reg_pixel;       \
 985             ((CARD8 *) (dst))[SinglePixel9] = reg_pixel;        \
 986             reg_pixel >>= 8;    \
 987             ((CARD16 *) (dst))[DoublePixel5] = reg_pixel;       \
 988             reg_pixel >>= 8;    \
 989             ((CARD8 *) (dst))[SinglePixel8] = reg_pixel; \
 990             break;                      \
 991         case 13:                        \
 992             ((CARD16 *) (dst))[DoublePixel0] = \
 993             ((CARD16 *) (dst))[DoublePixel3] = reg_pixel;       \
 994             ((CARD8 *) (dst))[SinglePixel9] = reg_pixel;        \
 995             reg_pixel >>= 8;    \
 996             ((CARD16 *) (dst))[DoublePixel5] = reg_pixel;       \
 997             reg_pixel >>= 8;    \
 998             ((CARD8 *) (dst))[SinglePixel2] = \
 999             ((CARD8 *) (dst))[SinglePixel8] = reg_pixel; \
1000             break;                      \
1001         case 14:                        \
1002             ((CARD8 *) (dst))[SinglePixel3] = \
1003             ((CARD8 *) (dst))[SinglePixel9] = reg_pixel;        \
1004             ((CARD16 *) (dst))[DoublePixel3] = reg_pixel;       \
1005             reg_pixel >>= 8;    \
1006             ((CARD16 *) (dst))[DoublePixel2] = \
1007             ((CARD16 *) (dst))[DoublePixel5] = reg_pixel;       \
1008             reg_pixel >>= 8;    \
1009             ((CARD8 *) (dst))[SinglePixel8] = reg_pixel; \
1010             break;                      \
1011         case 15:                        \
1012             ((CARD16 *) (dst))[DoublePixel0] = \
1013             ((CARD16 *) (dst))[DoublePixel3] = reg_pixel;       \
1014             ((CARD8 *) (dst))[SinglePixel3] = \
1015             ((CARD8 *) (dst))[SinglePixel9] = reg_pixel;        \
1016             reg_pixel >>= 8;    \
1017             ((CARD16 *) (dst))[DoublePixel2] = \
1018             ((CARD16 *) (dst))[DoublePixel5] = reg_pixel;       \
1019             reg_pixel >>= 8;    \
1020             ((CARD8 *) (dst))[SinglePixel8] = \
1021             ((CARD8 *) (dst))[SinglePixel2] = reg_pixel;        \
1022             break;                      \
1023         } \
1024       }
1025 #else /* PGSZ == 64 */
1026 #define WriteBitGroup(dst,pixel,bits) \
1027     if ( bits == 0xff )  {                                 \
1028         ((PixelGroup *) (dst))[DoublePixel0] = (pixel);    \
1029         ((PixelGroup *) (dst))[DoublePixel1] = (pixel);    \
1030         ((PixelGroup *) (dst))[DoublePixel2] = (pixel);    \
1031         ((PixelGroup *) (dst))[DoublePixel3] = (pixel);    \
1032     }                                                      \
1033     else {                                                 \
1034         switch (bits & 0x0f) {                             \
1035         case 0:                         \
1036             break;                      \
1037         case 1:                         \
1038             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1039             break;                      \
1040         case 2:                         \
1041             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1042             break;                      \
1043         case 3:                         \
1044             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1045             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1046             break;                      \
1047         case 4:                         \
1048             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1049             break;                      \
1050         case 5:                         \
1051             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1052             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1053             break;                      \
1054         case 6:                         \
1055             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1056             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1057             break;                      \
1058         case 7:                         \
1059             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1060             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1061             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1062             break;                      \
1063         case 8:                         \
1064             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1065             break;                      \
1066         case 9:                         \
1067             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1068             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1069             break;                      \
1070         case 10:                        \
1071             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1072             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1073             break;                      \
1074         case 11:                        \
1075             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1076             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1077             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1078             break;                      \
1079         case 12:                        \
1080             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1081             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1082             break;                      \
1083         case 13:                        \
1084             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1085             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1086             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1087             break;                      \
1088         case 14:                        \
1089             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1090             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1091             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1092             break;                      \
1093         case 15:                        \
1094             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1095             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1096             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1097             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1098             break;                      \
1099         }                               \
1100         switch ((bits & 0xf0) >> 4) {   \
1101         case 0:                         \
1102             break;                      \
1103         case 1:                         \
1104             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1105             break;                      \
1106         case 2:                         \
1107             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1108             break;                      \
1109         case 3:                         \
1110             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1111             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1112             break;                      \
1113         case 4:                         \
1114             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1115             break;                      \
1116         case 5:                         \
1117             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1118             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1119             break;                      \
1120         case 6:                         \
1121             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1122             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1123             break;                      \
1124         case 7:                         \
1125             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1126             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1127             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1128             break;                      \
1129         case 8:                         \
1130             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1131             break;                      \
1132         case 9:                         \
1133             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1134             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1135             break;                      \
1136         case 10:                        \
1137             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1138             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1139             break;                      \
1140         case 11:                        \
1141             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1142             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1143             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1144             break;                      \
1145         case 12:                        \
1146             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1147             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1148             break;                      \
1149         case 13:                        \
1150             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1151             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1152             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1153             break;                      \
1154         case 14:                        \
1155             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1156             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1157             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1158             break;                      \
1159         case 15:                        \
1160             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1161             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1162             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1163             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1164             break;                      \
1165         }                               \
1166     }
1167 #endif /* PGSZ */
1168
1169 #if PGSZ == 32
1170 #define SwitchBitGroup(dst,pixel,bits) { \
1171         switch (bits) { \
1172         case 0: \
1173             break; \
1174         case 1: \
1175             SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel0] = (pixel); \
1176                             ((CARD8 *) (dst))[SinglePixel2] = (pixel);) \
1177             break; \
1178         case 2: \
1179             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel3] = (pixel); \
1180                             ((CARD16 *) (dst))[DoublePixel2] = (pixel);) \
1181             break; \
1182         case 3: \
1183             SwitchBitsLoop (((CARD32 *) (dst))[QuadPixel0] = (pixel); \
1184                             ((CARD16 *) (dst))[DoublePixel2] = (pixel);) \
1185             break; \
1186         case 4: \
1187             SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel3] = (pixel); \
1188                             ((CARD8 *) (dst))[SinglePixel8] = (pixel);) \
1189             break; \
1190         case 5: \
1191             SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel0] = (pixel); \
1192                             ((CARD8 *) (dst))[SinglePixel2] = (pixel); \
1193                             ((CARD16 *) (dst))[DoublePixel3] = (pixel); \
1194                             ((CARD8 *) (dst))[SinglePixel8] = (pixel);) \
1195             break; \
1196         case 6: \
1197             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel3] = (pixel); \
1198                             ((CARD32 *) (dst))[QuadPixel2] = (pixel); \
1199                             ((CARD8 *) (dst))[SinglePixel8] = (pixel);) \
1200             break; \
1201         case 7: \
1202             SwitchBitsLoop (((CARD32 *) (dst))[QuadPixel0] = (pixel); \
1203                             ((CARD32 *) (dst))[QuadPixel1] = (pixel); \
1204                             ((CARD8 *) (dst))[SinglePixel8] = (pixel);) \
1205             break; \
1206         case 8: \
1207             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel9] = (pixel); \
1208                             ((CARD16 *) (dst))[DoublePixel5] = (pixel);) \
1209             break; \
1210         case 9: \
1211             SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel0] = (pixel); \
1212                             ((CARD8 *) (dst))[SinglePixel2] = (pixel); \
1213                             ((CARD8 *) (dst))[SinglePixel9] = (pixel); \
1214                             ((CARD16 *) (dst))[DoublePixel5] = (pixel);) \
1215             break; \
1216         case 10: \
1217             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel3] = (pixel); \
1218                             ((CARD16 *) (dst))[DoublePixel2] = (pixel); \
1219                             ((CARD8 *) (dst))[SinglePixel9] = (pixel); \
1220                             ((CARD16 *) (dst))[DoublePixel5] = (pixel);) \
1221             break; \
1222         case 11: \
1223             SwitchBitsLoop (((CARD32 *) (dst))[QuadPixel0] = (pixel); \
1224                             ((CARD16 *) (dst))[DoublePixel3] = (pixel);) \
1225                             ((CARD8 *) (dst))[SinglePixel9] = (pixel); \
1226                             ((CARD16 *) (dst))[DoublePixel5] = (pixel);) \
1227             break; \
1228         case 12: \
1229             SwitchBitsLoop (((CARD16 *) (dst))[DoublePixel3] = (pixel); \
1230                             ((CARD32 *) (dst))[QuadPixel2] = (pixel);) \
1231             break; \
1232         case 13: \
1233             SwitchBitsLoop (((CARD16 *) (dst))[SinglePixel0] = (pixel); \
1234                             ((CARD8 *) (dst))[SinglePixel2] = (pixel); \
1235                             ((CARD16 *) (dst))[DoublePixel3] = (pixel); \
1236                             ((CARD32 *) (dst))[QuadPixel2] = (pixel);) \
1237             break; \
1238         case 14: \
1239             SwitchBitsLoop (((CARD8 *) (dst))[SinglePixel3] = (pixel); \
1240                             ((CARD32 *) (dst))[QuadPixel1] = (pixel); \
1241                             ((CARD32 *) (dst))[QuadPixel2] = (pixel);) \
1242             break; \
1243         case 15: \
1244             SwitchBitsLoop (((CARD32 *) (dst))[QuadPixel0] = (pixel); \
1245                             ((CARD32 *) (dst))[QuadPixel1] = (pixel); \
1246                             ((CARD32 *) (dst))[QuadPixel2] = (pixel);) \
1247             break; \
1248         } \
1249 }
1250 #else /* PGSZ == 64 */
1251 #define SwitchBitGroup(dst,pixel,bits) { \
1252         cfb cannot hack 64-bit SwitchBitGroup psz=PSZ
1253 #endif /* PGSZ */
1254
1255 #endif /* PSZ == 24 */
1256
1257 #if PSZ == 32
1258
1259 #if PGSZ == 32
1260 #define WriteBitGroup(dst,pixel,bits) \
1261         switch (bits) {                 \
1262         case 0:                         \
1263             break;                      \
1264         case 1:                         \
1265             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1266             break;                      \
1267         case 2:                         \
1268             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1269             break;                      \
1270         case 3:                         \
1271             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1272             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1273             break;                      \
1274         case 4:                         \
1275             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1276             break;                      \
1277         case 5:                         \
1278             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1279             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1280             break;                      \
1281         case 6:                         \
1282             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1283             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1284             break;                      \
1285         case 7:                         \
1286             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1287             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1288             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1289             break;                      \
1290         case 8:                         \
1291             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1292             break;                      \
1293         case 9:                         \
1294             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1295             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1296             break;                      \
1297         case 10:                        \
1298             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1299             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1300             break;                      \
1301         case 11:                        \
1302             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1303             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1304             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1305             break;                      \
1306         case 12:                        \
1307             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1308             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1309             break;                      \
1310         case 13:                        \
1311             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1312             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1313             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1314             break;                      \
1315         case 14:                        \
1316             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1317             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1318             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1319             break;                      \
1320         case 15:                        \
1321             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1322             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1323             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1324             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1325             break;                      \
1326         }
1327 #else /* PGSZ == 64 */
1328 #define WriteBitGroup(dst,pixel,bits) \
1329     if ( bits == 0xff )  {                                 \
1330         ((PixelGroup *) (dst))[DoublePixel0] = (pixel);    \
1331         ((PixelGroup *) (dst))[DoublePixel1] = (pixel);    \
1332         ((PixelGroup *) (dst))[DoublePixel2] = (pixel);    \
1333         ((PixelGroup *) (dst))[DoublePixel3] = (pixel);    \
1334     }                                                      \
1335     else {                                                 \
1336         switch (bits & 0x0f) {                             \
1337         case 0:                         \
1338             break;                      \
1339         case 1:                         \
1340             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1341             break;                      \
1342         case 2:                         \
1343             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1344             break;                      \
1345         case 3:                         \
1346             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1347             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1348             break;                      \
1349         case 4:                         \
1350             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1351             break;                      \
1352         case 5:                         \
1353             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1354             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1355             break;                      \
1356         case 6:                         \
1357             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1358             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1359             break;                      \
1360         case 7:                         \
1361             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1362             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1363             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1364             break;                      \
1365         case 8:                         \
1366             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1367             break;                      \
1368         case 9:                         \
1369             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1370             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1371             break;                      \
1372         case 10:                        \
1373             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1374             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1375             break;                      \
1376         case 11:                        \
1377             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1378             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1379             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1380             break;                      \
1381         case 12:                        \
1382             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1383             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1384             break;                      \
1385         case 13:                        \
1386             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1387             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1388             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1389             break;                      \
1390         case 14:                        \
1391             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1392             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1393             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1394             break;                      \
1395         case 15:                        \
1396             ((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1397             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1398             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1399             ((CARD32 *) (dst))[SinglePixel3] = (pixel); \
1400             break;                      \
1401         }                               \
1402         switch ((bits & 0xf0) >> 4) {   \
1403         case 0:                         \
1404             break;                      \
1405         case 1:                         \
1406             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1407             break;                      \
1408         case 2:                         \
1409             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1410             break;                      \
1411         case 3:                         \
1412             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1413             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1414             break;                      \
1415         case 4:                         \
1416             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1417             break;                      \
1418         case 5:                         \
1419             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1420             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1421             break;                      \
1422         case 6:                         \
1423             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1424             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1425             break;                      \
1426         case 7:                         \
1427             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1428             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1429             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1430             break;                      \
1431         case 8:                         \
1432             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1433             break;                      \
1434         case 9:                         \
1435             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1436             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1437             break;                      \
1438         case 10:                        \
1439             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1440             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1441             break;                      \
1442         case 11:                        \
1443             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1444             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1445             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1446             break;                      \
1447         case 12:                        \
1448             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1449             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1450             break;                      \
1451         case 13:                        \
1452             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1453             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1454             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1455             break;                      \
1456         case 14:                        \
1457             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1458             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1459             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1460             break;                      \
1461         case 15:                        \
1462             ((CARD32 *) (dst))[SinglePixel4] = (pixel); \
1463             ((CARD32 *) (dst))[SinglePixel5] = (pixel); \
1464             ((CARD32 *) (dst))[SinglePixel6] = (pixel); \
1465             ((CARD32 *) (dst))[SinglePixel7] = (pixel); \
1466             break;                      \
1467         }                               \
1468     }
1469 #endif /* PGSZ */
1470
1471 #if PGSZ == 32
1472 #define SwitchBitGroup(dst,pixel,bits) { \
1473         switch (bits) { \
1474         case 0: \
1475             break; \
1476         case 1: \
1477             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel0] = (pixel);) \
1478             break; \
1479         case 2: \
1480             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel1] = (pixel);) \
1481             break; \
1482         case 3: \
1483             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1484                             ((CARD32 *) (dst))[SinglePixel1] = (pixel);) \
1485             break; \
1486         case 4: \
1487             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel2] = (pixel);) \
1488             break; \
1489         case 5: \
1490             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1491                             ((CARD32 *) (dst))[SinglePixel2] = (pixel);) \
1492             break; \
1493         case 6: \
1494             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1495                             ((CARD32 *) (dst))[SinglePixel2] = (pixel);) \
1496             break; \
1497         case 7: \
1498             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1499                             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1500                             ((CARD32 *) (dst))[SinglePixel2] = (pixel);) \
1501             break; \
1502         case 8: \
1503             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel3] = (pixel);) \
1504             break; \
1505         case 9: \
1506             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1507                             ((CARD32 *) (dst))[SinglePixel3] = (pixel);) \
1508             break; \
1509         case 10: \
1510             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1511                             ((CARD32 *) (dst))[SinglePixel3] = (pixel);) \
1512             break; \
1513         case 11: \
1514             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1515                             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1516                             ((CARD32 *) (dst))[SinglePixel3] = (pixel);) \
1517             break; \
1518         case 12: \
1519             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1520                             ((CARD32 *) (dst))[SinglePixel3] = (pixel);) \
1521             break; \
1522         case 13: \
1523             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1524                             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1525                             ((CARD32 *) (dst))[SinglePixel3] = (pixel);) \
1526             break; \
1527         case 14: \
1528             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1529                             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1530                             ((CARD32 *) (dst))[SinglePixel3] = (pixel);) \
1531             break; \
1532         case 15: \
1533             SwitchBitsLoop (((CARD32 *) (dst))[SinglePixel0] = (pixel); \
1534                             ((CARD32 *) (dst))[SinglePixel1] = (pixel); \
1535                             ((CARD32 *) (dst))[SinglePixel2] = (pixel); \
1536                             ((CARD32 *) (dst))[SinglePixel3] = (pixel);) \
1537             break; \
1538         } \
1539 }
1540 #else /* PGSZ == 64 */
1541 #define SwitchBitGroup(dst,pixel,bits) { \
1542         cfb cannot hack 64-bit SwitchBitGroup psz=PSZ
1543 #endif /* PGSZ */
1544
1545 #endif /* PSZ == 32 */
1546 #endif /* AVOID_MEMORY_READ */
1547
1548 extern PixelGroup cfb8BitLenMasks[PGSZ];
1549
1550 extern int cfb8SetStipple (
1551 #if NeedFunctionPrototypes
1552     int /*alu*/,
1553     unsigned long /*fg*/,
1554     unsigned long /*planemask*/
1555 #endif
1556 );
1557
1558 extern int cfb8SetOpaqueStipple (
1559 #if NeedFunctionPrototypes
1560     int /*alu*/,
1561     unsigned long /*fg*/,
1562     unsigned long /*bg*/,
1563     unsigned long /*planemask*/
1564 #endif
1565 );
1566
1567 extern int cfb8ComputeClipMasks32 (
1568 #if NeedFunctionPrototypes
1569     BoxPtr      /*pBox*/,
1570     int         /*numRects*/,
1571     int         /*x*/,
1572     int         /*y*/,
1573     int         /*w*/,
1574     int         /*h*/,
1575     CARD32 * /*clips*/
1576 #endif
1577 );