git.sesse.net Git - rdpsrv/blob - Xserver/programs/Xserver/cfb/cfbsolid.c

   1 /*
   2  * $XConsortium: cfbsolid.c,v 1.9 94/04/17 20:29:02 dpw Exp $
   3  * $XFree86: xc/programs/Xserver/cfb/cfbsolid.c,v 3.0 1996/06/29 09:05:51 dawes Exp $
   4  *
   5 Copyright (c) 1990  X Consortium
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a copy
   8 of this software and associated documentation files (the "Software"), to deal
   9 in the Software without restriction, including without limitation the rights
  10 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 copies of the Software, and to permit persons to whom the Software is
  12 furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice shall be included in
  15 all copies or substantial portions of the Software.
  16
  17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  20 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23
  24 Except as contained in this notice, the name of the X Consortium shall not be
  25 used in advertising or otherwise to promote the sale, use or other dealings
  26 in this Software without prior written authorization from the X Consortium.
  27  *
  28  * Author:  Keith Packard, MIT X Consortium
  29  */
  30
  31
  32 #include "X.h"
  33 #include "Xmd.h"
  34 #include "servermd.h"
  35 #include "gcstruct.h"
  36 #include "window.h"
  37 #include "pixmapstr.h"
  38 #include "scrnintstr.h"
  39 #include "windowstr.h"
  40
  41 #include "cfb.h"
  42 #include "cfbmskbits.h"
  43 #include "cfbrrop.h"
  44
  45 #include "mi.h"
  46 #include "mispans.h"
  47
  48 #if defined(FAST_CONSTANT_OFFSET_MODE) && (RROP != GXcopy)
  49 # define Expand(left,right,leftAdjust) {\
  50     int part = nmiddle & 3; \
  51     int widthStep; \
  52     widthStep = widthDst - nmiddle - leftAdjust; \
  53     nmiddle >>= 2; \
  54     pdst = pdstRect; \
  55     while (h--) { \
  56         left \
  57         pdst += part; \
  58         switch (part) { \
  59             RROP_UNROLL_CASE3(pdst) \
  60         } \
  61         m = nmiddle; \
  62         while (m) { \
  63             pdst += 4; \
  64             RROP_UNROLL_LOOP4(pdst,-4) \
  65             m--; \
  66         } \
  67         right \
  68         pdst += widthStep; \
  69     } \
  70 }
  71 #else
  72 # ifdef RROP_UNROLL
  73 #  define Expand(left,right,leftAdjust) {\
  74     int part = nmiddle & RROP_UNROLL_MASK; \
  75     int widthStep; \
  76     widthStep = widthDst - nmiddle - leftAdjust; \
  77     nmiddle >>= RROP_UNROLL_SHIFT; \
  78     pdst = pdstRect; \
  79     while (h--) { \
  80         left \
  81         pdst += part; \
  82         switch (part) { \
  83             RROP_UNROLL_CASE(pdst) \
  84         } \
  85         m = nmiddle; \
  86         while (m) { \
  87             pdst += RROP_UNROLL; \
  88             RROP_UNROLL_LOOP(pdst) \
  89             m--; \
  90         } \
  91         right \
  92         pdst += widthStep; \
  93     } \
  94 }
  95
  96 # else
  97 #  define Expand(left, right, leftAdjust) { \
  98     while (h--) { \
  99         pdst = pdstRect; \
 100         left \
 101         m = nmiddle; \
 102         while (m--) {\
 103             RROP_SOLID(pdst); \
 104             pdst++; \
 105         } \
 106         right \
 107         pdstRect += widthDst; \
 108     } \
 109 }
 110 # endif
 111 #endif
 112
 113
 114 void
 115 RROP_NAME(cfbFillRectSolid) (pDrawable, pGC, nBox, pBox)
 116     DrawablePtr     pDrawable;
 117     GCPtr           pGC;
 118     int             nBox;
 119     BoxPtr          pBox;
 120 {
 121     register int    m;
 122     register unsigned long   *pdst;
 123     RROP_DECLARE
 124     register unsigned long   leftMask, rightMask;
 125     unsigned long   *pdstBase, *pdstRect;
 126     int             nmiddle;
 127     int             h;
 128     int             w;
 129     int             widthDst;
 130     cfbPrivGCPtr    devPriv;
 131 #if PSZ == 24
 132     int leftIndex, rightIndex, xOffset;
 133 #endif
 134
 135     devPriv = cfbGetGCPrivate(pGC);
 136
 137     cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
 138
 139     RROP_FETCH_GC(pGC)
 140
 141     for (; nBox; nBox--, pBox++)
 142     {
 143         pdstRect = pdstBase + pBox->y1 * widthDst;
 144         h = pBox->y2 - pBox->y1;
 145         w = pBox->x2 - pBox->x1;
 146 #if PSZ == 8
 147         if (w == 1)
 148         {
 149             register char    *pdstb = ((char *) pdstRect) + pBox->x1;
 150             int     incr = widthDst * PGSZB;
 151
 152             while (h--)
 153             {
 154                 RROP_SOLID (pdstb);
 155                 pdstb += incr;
 156             }
 157         }
 158         else
 159         {
 160 #endif
 161 #if PSZ == 24
 162         leftIndex = pBox->x1 &3;
 163 /*      rightIndex = ((leftIndex+w)<5)?0:pBox->x2 &3;*/
 164         rightIndex = pBox->x2 &3;
 165
 166         nmiddle = w - rightIndex;
 167         if(leftIndex){
 168           nmiddle -= (4 - leftIndex);
 169         }
 170         nmiddle >>= 2;
 171         if(nmiddle < 0)
 172           nmiddle = 0;
 173
 174         pdstRect += (pBox->x1 * 3) >> 2;
 175         pdst = pdstRect;
 176         switch(leftIndex+w){
 177         case 4:
 178             switch(leftIndex){
 179             case 0:
 180                 while(h--){
 181 #if RROP == GXcopy
 182                     *pdst++ = piQxelXor[0];
 183                     *pdst++ = piQxelXor[1];
 184                     *pdst-- = piQxelXor[2];
 185 #endif
 186 #if RROP == GXxor
 187                     *pdst++ ^= piQxelXor[0];
 188                     *pdst++ ^= piQxelXor[1];
 189                     *pdst-- ^= piQxelXor[2];
 190 #endif
 191 #if RROP == GXand
 192                     *pdst++ &= piQxelAnd[0];
 193                     *pdst++ &= piQxelAnd[1];
 194                     *pdst-- &= piQxelAnd[2];
 195 #endif
 196 #if RROP == GXor
 197                     *pdst++ |= piQxelOr[0];
 198                     *pdst++ |= piQxelOr[1];
 199                     *pdst-- |= piQxelOr[2];
 200 #endif
 201 #if RROP == GXset
 202                     *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 203                     pdst++;
 204                     *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 205                     pdst++;
 206                     *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 207                     pdst--;
 208 #endif
 209                     pdst--;
 210                     pdst += widthDst;
 211                 }
 212                 break;
 213             case 1:
 214                 while(h--){
 215 #if RROP == GXcopy
 216                     *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 217                     *pdst++ = piQxelXor[1];
 218                     *pdst-- = piQxelXor[2];
 219 #endif
 220 #if RROP == GXxor
 221                     *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 222                     *pdst++ ^= piQxelXor[1];
 223                     *pdst-- ^= piQxelXor[2];
 224 #endif
 225 #if RROP == GXand
 226                     *pdst++ &= (piQxelAnd[0] | 0x00FFFFFF);
 227                     *pdst++ &= piQxelAnd[1];
 228                     *pdst-- &= piQxelAnd[2];
 229 #endif
 230 #if RROP == GXor
 231                     *pdst++ |= (piQxelOr[0] & 0xFF000000);
 232                     *pdst++ |= piQxelOr[1];
 233                     *pdst-- |= piQxelOr[2];
 234 #endif
 235 #if RROP == GXset
 236                     *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 237                     pdst++;
 238                     *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 239                     pdst++;
 240                     *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 241                     pdst--;
 242 #endif
 243                     pdst--;
 244                     pdst += widthDst;
 245                 }
 246                 break;
 247             case 2:
 248                 while(h--){
 249 #if RROP == GXcopy
 250                     *pdst++ = ((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
 251                     *pdst-- = piQxelXor[2];
 252 #endif
 253 #if RROP == GXxor
 254                     *pdst++ ^= (piQxelXor[1] & 0xFFFF0000);
 255                     *pdst-- ^= piQxelXor[2];
 256 #endif
 257 #if RROP == GXand
 258                     *pdst++ &= (piQxelAnd[1] | 0xFFFF);
 259                     *pdst-- &= piQxelAnd[2];
 260 #endif
 261 #if RROP == GXor
 262                     *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 263                     *pdst-- |= piQxelOr[2];
 264 #endif
 265 #if RROP == GXset
 266                     *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 267                     pdst++;
 268                     *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 269                     pdst--;
 270 #endif
 271                     pdst += widthDst;
 272                 }
 273                 break;
 274             case 3:
 275                 while(h--){
 276 #if RROP == GXcopy
 277                     *pdst = ((*pdst) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
 278 #endif
 279 #if RROP == GXxor
 280                     *pdst ^= (piQxelXor[2] & 0xFFFFFF00);
 281 #endif
 282 #if RROP == GXand
 283                     *pdst &= (piQxelAnd[2] | 0xFF);
 284 #endif
 285 #if RROP == GXor
 286                     *pdst |= (piQxelOr[2] & 0xFFFFFF00);
 287 #endif
 288 #if RROP == GXset
 289                     *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
 290 #endif
 291                     pdst += widthDst;
 292                 }
 293                 break;
 294             }
 295             break;
 296         case 3:
 297             switch(leftIndex){
 298             case 0:
 299                 while(h--){
 300 #if RROP == GXcopy
 301                     *pdst++ = piQxelXor[0];
 302                     *pdst++ = piQxelXor[1];
 303                     *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 304 #endif
 305 #if RROP == GXxor
 306                     *pdst++ ^= piQxelXor[0];
 307                     *pdst++ ^= piQxelXor[1];
 308                     *pdst-- ^= (piQxelXor[2] & 0xFF);
 309 #endif
 310 #if RROP == GXand
 311                     *pdst++ &= piQxelAnd[0];
 312                     *pdst++ &= piQxelAnd[1];
 313                     *pdst-- &= (piQxeAnd[2] | 0xFFFFFF00);
 314 #endif
 315 #if RROP == GXor
 316                     *pdst++ |= piQxelOr[0];
 317                     *pdst++ |= piQxelOr[1];
 318                     *pdst-- |= (piQxelOr[2] & 0xFF);
 319 #endif
 320 #if RROP == GXset
 321                     *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 322                     pdst++;
 323                     *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 324                     pdst++;
 325                     *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 326                     pdst--;
 327 #endif
 328                     pdst--;
 329                     pdst += widthDst;
 330                 }
 331                 break;
 332             case 1:
 333                 while(h--){
 334 #if RROP == GXcopy
 335                     *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 336                     *pdst++ = piQxelXor[1];
 337                     *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 338 #endif
 339 #if RROP == GXxor
 340                     *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 341                     *pdst++ ^= piQxelXor[1];
 342                     *pdst-- ^= (piQxelXor[2] & 0xFF);
 343 #endif
 344 #if RROP == GXand
 345                     *pdst++ &= (piQxelAnd[0] | 0x00FFFFFF);
 346                     *pdst++ &= piQxelAnd[1];
 347                     *pdst-- &= (piQxelAnd[2] | 0xFFFFFF00);
 348 #endif
 349 #if RROP == GXor
 350                     *pdst++ |= (piQxelOr[0] & 0xFF000000);
 351                     *pdst++ |= piQxelOr[1];
 352                     *pdst-- |= (piQxelOr[2] & 0xFF);
 353 #endif
 354 #if RROP == GXset
 355                     *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 356                     pdst++;
 357                     *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 358                     pdst++;
 359                     *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 360                     pdst--;
 361 #endif
 362                     pdst--;
 363                     pdst += widthDst;
 364                 }
 365                 break;
 366             case 2:
 367                 while(h--){
 368 #if RROP == GXcopy
 369                     *pdst++ = ((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
 370                     *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 371 #endif
 372 #if RROP == GXxor
 373                     *pdst++ ^= (piQxelXor[1] & 0xFFFF0000);
 374                     *pdst-- ^= (piQxelXor[2] & 0xFF);
 375 #endif
 376 #if RROP == GXand
 377                     *pdst++ &= (piQxelAnd[1] | 0xFFFF);
 378                     *pdst-- &= (piQxelAnd[2] | 0xFFFFFF00);
 379 #endif
 380 #if RROP == GXor
 381                     *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 382                     *pdst-- |= (piQxelOr[2] & 0xFF);
 383 #endif
 384 #if RROP == GXset
 385                     *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 386                     pdst++;
 387                     *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 388                     pdst--;
 389 #endif
 390                     pdst += widthDst;
 391                 }
 392                 break;
 393             case 3:
 394                 while(h--){
 395 #if RROP == GXcopy
 396                     *pdst = ((*pdst) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
 397 #endif
 398 #if RROP == GXxor
 399                     *pdst ^= (piQxelXor[2] & 0xFFFFFF00);
 400 #endif
 401 #if RROP == GXand
 402                     *pdst &= (piQxelAnd[2] | 0xFF);
 403 #endif
 404 #if RROP == GXor
 405                     *pdst |= (piQxelOr[2] & 0xFFFFFF00);
 406 #endif
 407 #if RROP == GXset
 408                     *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
 409 #endif
 410                     pdst += widthDst;
 411                 }
 412                 break;
 413             }
 414             break;
 415         case 2: /* leftIndex + w = 2*/
 416             switch(leftIndex){
 417             case 2:
 418                 while(h--){
 419 #if RROP == GXcopy
 420                     *pdst++ = ((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
 421                     *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 422 #endif
 423 #if RROP == GXxor
 424                     *pdst++ ^= (piQxelXor[1] & 0xFFFF0000);
 425                     *pdst-- ^= (piQxelXor[2] & 0xFF);
 426 #endif
 427 #if RROP == GXand
 428                     *pdst++ &= (piQxelAnd[1] | 0xFFFF0000);
 429                     *pdst-- &= (piQxelAnd[2] | 0xFF);
 430 #endif
 431 #if RROP == GXor
 432                     *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 433                     *pdst-- |= (piQxelOr[2] & 0xFF);
 434 #endif
 435 #if RROP == GXset
 436                     *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 437                     pdst++;
 438                     *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 439                     pdst--;
 440 #endif
 441                     pdst += widthDst;
 442                   }
 443                 break;
 444             case 1:
 445                 while(h--){
 446 #if RROP == GXcopy
 447                     *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 448                     *pdst-- = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
 449 #endif
 450 #if RROP == GXxor
 451                     *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 452                     *pdst-- ^= (piQxelXor[1] & 0xFFFF);
 453 #endif
 454 #if RROP == GXand
 455                     *pdst++ &= (piQxelAnd[0] | 0xFFFFFF);
 456                     *pdst-- &= (piQxelAnd[1] | 0xFFFF0000);
 457 #endif
 458 #if RROP == GXor
 459                     *pdst++ |= (piQxelOr[0] & 0xFF000000);
 460                     *pdst-- |= (piQxelOr[1] & 0xFFFF);
 461 #endif
 462 #if RROP == GXset
 463                     *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 464                     pdst++;
 465                     *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
 466                     pdst--;
 467 #endif
 468                     pdst += widthDst;
 469                   }
 470                 break;
 471             case 0: /*case 2 leftIndex == 0 */
 472                 while(h--){
 473 #if RROP == GXcopy
 474                     *pdst++ = piQxelXor[0];
 475                     *pdst-- = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
 476 #endif
 477 #if RROP == GXxor
 478                     *pdst++ ^= piQxelXor[0];
 479                     *pdst-- ^= (piQxelXor[1] & 0xFFFF);
 480 #endif
 481 #if RROP == GXand
 482                     *pdst++ &= piQxelAnd[0];
 483                     *pdst-- &= (piQxelAnd[1] | 0xFFFF0000);
 484 #endif
 485 #if RROP == GXor
 486                     *pdst++ |= piQxelOr[0];
 487                     *pdst-- |= (piQxelOr[1] & 0xFFFF);
 488 #endif
 489 #if RROP == GXset
 490                     *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 491                     pdst++;
 492                     *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
 493                     pdst--;
 494 #endif
 495                     pdst += widthDst;
 496                 }
 497                 break;
 498             }
 499             break;
 500         case 1: /*only if leftIndex = 0 and w = 1*/
 501             while(h--){
 502 #if RROP == GXcopy
 503                 *pdst = ((*pdst) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
 504 #endif
 505 #if RROP == GXxor
 506                 *pdst ^= (piQxelXor[0] & 0xFFFFFF);
 507 #endif
 508 #if RROP == GXand
 509                 *pdst &= (piQxelAnd[0] | 0xFF000000);
 510 #endif
 511 #if RROP == GXor
 512                 *pdst |= (piQxelOr[0] & 0xFFFFFF);
 513 #endif
 514 #if RROP == GXset
 515                 *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
 516 #endif
 517                 pdst += widthDst;
 518             }
 519             break;
 520         case 0: /*never*/
 521             break;
 522         default:
 523             {
 524                 while(h--){
 525                     pdst = pdstRect;
 526                     switch(leftIndex){
 527                     case 0:
 528                         break;
 529                     case 1:
 530 #if RROP == GXcopy
 531                         *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 532                         *pdst++ = piQxelXor[1];
 533                         *pdst++ = piQxelXor[2];
 534 #endif
 535 #if RROP == GXxor
 536                         *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 537                         *pdst++ ^= piQxelXor[1];
 538                         *pdst++ ^= piQxelXor[2];
 539 #endif
 540 #if RROP == GXand
 541                         *pdst++ &= (piQxelAnd[0] | 0xFFFFFF);
 542                         *pdst++ &= piQxelAnd[1];
 543                         *pdst++ &= piQxelAnd[2];
 544 #endif
 545 #if RROP == GXor
 546                         *pdst++ |= (piQxelOr[0] & 0xFF000000);
 547                         *pdst++ |= piQxelOr[1];
 548                         *pdst++ |= piQxelOr[2];
 549 #endif
 550 #if RROP == GXset
 551                         *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 552                         pdst++;
 553                         *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 554                         pdst++;
 555                         *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 556                         pdst++;
 557 #endif
 558                     break;
 559                     case 2:
 560 #if RROP == GXcopy
 561                         *pdst++ = (((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000));
 562                         *pdst++ = piQxelXor[2];
 563 #endif
 564 #if RROP == GXxor
 565                         *pdst++ ^=(piQxelXor[1] & 0xFFFF0000);
 566                         *pdst++ ^= piQxelXor[2];
 567 #endif
 568 #if RROP == GXand
 569                         *pdst++ &= (piQxelAnd[1] | 0xFFFF);
 570                         *pdst++ &= piQxelAnd[2];
 571 #endif
 572 #if RROP == GXor
 573                         *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 574                         *pdst++ |= piQxelOr[2];
 575 #endif
 576 #if RROP == GXset
 577                         *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 578                         pdst++;
 579                         *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 580                         pdst++;
 581 #endif
 582                         break;
 583                     case 3:
 584 #if RROP == GXcopy
 585                         *pdst++ = ((*pdst) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
 586 #endif
 587 #if RROP == GXxor
 588                         *pdst++ ^= (piQxelXor[2] & 0xFFFFFF00);
 589 #endif
 590 #if RROP == GXand
 591                         *pdst++ &= (piQxelAnd[2] | 0xFF);
 592 #endif
 593 #if RROP == GXor
 594                         *pdst++ |= (piQxelOr[2] & 0xFFFFFF00);
 595 #endif
 596 #if RROP == GXset
 597                         *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
 598                         pdst++;
 599 #endif
 600                         break;
 601                       }
 602                     m = nmiddle;
 603                     while(m--){
 604 #if RROP == GXcopy
 605                         *pdst++ = piQxelXor[0];
 606                         *pdst++ = piQxelXor[1];
 607                         *pdst++ = piQxelXor[2];
 608 #endif
 609 #if RROP == GXxor
 610                         *pdst++ ^= piQxelXor[0];
 611                         *pdst++ ^= piQxelXor[1];
 612                         *pdst++ ^= piQxelXor[2];
 613 #endif
 614 #if RROP == GXand
 615                         *pdst++ &= piQxelAnd[0];
 616                         *pdst++ &= piQxelAnd[1];
 617                         *pdst++ &= piQxelAnd[2];
 618 #endif
 619 #if RROP == GXor
 620                         *pdst++ |= piQxelOr[0];
 621                         *pdst++ |= piQxelOr[1];
 622                         *pdst++ |= piQxelOr[2];
 623 #endif
 624 #if RROP == GXset
 625                         *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 626                         pdst++;
 627                         *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 628                         pdst++;
 629                         *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 630                         pdst++;
 631 #endif
 632                 }
 633                 switch(rightIndex){
 634                 case 0:
 635                   break;
 636                 case 1:
 637 #if RROP == GXcopy
 638                   *pdst++ = ((*pdst) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
 639 #endif
 640 #if RROP == GXxor
 641                   *pdst++ ^= (piQxelXor[0] & 0xFFFFFF);
 642 #endif
 643 #if RROP == GXand
 644                   *pdst++ &= (piQxelAnd[0] | 0xFF);
 645 #endif
 646 #if RROP == GXor
 647                   *pdst++ |= (piQxelOr[0] & 0xFFFFFF);
 648 #endif
 649 #if RROP == GXset
 650                   *pdst++ = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
 651 #endif
 652                   break;
 653                 case 2:
 654 #if RROP == GXcopy
 655                   *pdst++ = piQxelXor[0];
 656                   *pdst++ = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
 657 #endif
 658 #if RROP == GXxor
 659                   *pdst++ ^= piQxelXor[0];
 660                   *pdst++ ^= (piQxelXor[1] & 0xFFFF);
 661 #endif
 662 #if RROP == GXand
 663                   *pdst++ &= piQxelAnd[0];
 664                   *pdst++ &= (piQxelAnd[1] | 0xFFFF0000);
 665 #endif
 666 #if RROP == GXor
 667                   *pdst++ |= piQxelOr[0];
 668                   *pdst++ |= (piQxelOr[1] & 0xFFFF);
 669 #endif
 670 #if RROP == GXset
 671                   *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 672                   *pdst++;
 673                   *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
 674                   *pdst++;
 675 #endif
 676                   break;
 677                 case 3:
 678 #if RROP == GXcopy
 679                   *pdst++ = piQxelXor[0];
 680                   *pdst++ = piQxelXor[1];
 681                   *pdst++ = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 682 #endif
 683 #if RROP == GXxor
 684                   *pdst++ ^= piQxelXor[0];
 685                   *pdst++ ^= piQxelXor[1];
 686                   *pdst++ ^= (piQxelXor[2] & 0xFF);
 687 #endif
 688 #if RROP == GXand
 689                   *pdst++ &= piQxelAnd[0];
 690                   *pdst++ &= piQxelAnd[1];
 691                   *pdst++ &= (piQxelAnd[2] | 0xFFFFFF00);
 692 #endif
 693 #if RROP == GXor
 694                   *pdst++ |= piQxelOr[0];
 695                   *pdst++ |= piQxelOr[1];
 696                   *pdst++ |= (piQxelOr[2] & 0xFF);
 697 #endif
 698 #if RROP == GXset
 699                   *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 700                   pdst++;
 701                   *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 702                   pdst++;
 703                   *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 704                   pdst++;
 705 #endif
 706                   break;
 707                 }
 708                 pdstRect += widthDst;
 709             }
 710         }
 711         }
 712 #else /* PSZ != 24 */
 713         pdstRect += (pBox->x1 >> PWSH);
 714         if ((pBox->x1 & PIM) + w <= PPW)
 715         {
 716             maskpartialbits(pBox->x1, w, leftMask);
 717             pdst = pdstRect;
 718             while (h--) {
 719                 RROP_SOLID_MASK (pdst, leftMask);
 720                 pdst += widthDst;
 721             }
 722         }
 723         else
 724         {
 725             maskbits (pBox->x1, w, leftMask, rightMask, nmiddle);
 726             if (leftMask)
 727             {
 728                 if (rightMask)  /* left mask and right mask */
 729                 {
 730                     Expand(RROP_SOLID_MASK (pdst, leftMask); pdst++;,
 731                            RROP_SOLID_MASK (pdst, rightMask);, 1)
 732                 }
 733                 else    /* left mask and no right mask */
 734                 {
 735                     Expand(RROP_SOLID_MASK (pdst, leftMask); pdst++;,
 736                            ;, 1)
 737                 }
 738             }
 739             else
 740             {
 741                 if (rightMask)  /* no left mask and right mask */
 742                 {
 743                     Expand(;,
 744                            RROP_SOLID_MASK (pdst, rightMask);, 0)
 745                 }
 746                 else    /* no left mask and no right mask */
 747                 {
 748                     Expand(;,
 749                             ;, 0)
 750                 }
 751             }
 752         }
 753 #endif
 754 #if PSZ == 8
 755         }
 756 #endif
 757     }
 758 }
 759
 760 void
 761 RROP_NAME(cfbSolidSpans) (pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
 762     DrawablePtr pDrawable;
 763     GCPtr       pGC;
 764     int         nInit;                  /* number of spans to fill */
 765     DDXPointPtr pptInit;                /* pointer to list of start points */
 766     int         *pwidthInit;            /* pointer to list of n widths */
 767     int         fSorted;
 768 {
 769     unsigned long   *pdstBase;
 770     int             widthDst;
 771
 772     RROP_DECLARE
 773
 774     register unsigned long  *pdst;
 775     register int            nlmiddle;
 776     register unsigned long  startmask, endmask;
 777     register int            w;
 778     int                     x;
 779
 780                                 /* next three parameters are post-clip */
 781     int             n;          /* number of spans to fill */
 782     DDXPointPtr     ppt;        /* pointer to list of start points */
 783     int             *pwidthFree;/* copies of the pointers to free */
 784     DDXPointPtr     pptFree;
 785     int             *pwidth;
 786     cfbPrivGCPtr    devPriv;
 787 #if PSZ == 24
 788     int leftIndex, rightIndex, xOffset;
 789 #endif
 790
 791     devPriv = cfbGetGCPrivate(pGC);
 792     RROP_FETCH_GCPRIV(devPriv)
 793     n = nInit * miFindMaxBand(devPriv->pCompositeClip);
 794     pwidthFree = (int *)ALLOCATE_LOCAL(n * sizeof(int));
 795     pptFree = (DDXPointRec *)ALLOCATE_LOCAL(n * sizeof(DDXPointRec));
 796     if(!pptFree || !pwidthFree)
 797     {
 798         if (pptFree) DEALLOCATE_LOCAL(pptFree);
 799         if (pwidthFree) DEALLOCATE_LOCAL(pwidthFree);
 800         return;
 801     }
 802     pwidth = pwidthFree;
 803     ppt = pptFree;
 804     n = miClipSpans(devPriv->pCompositeClip,
 805                      pptInit, pwidthInit, nInit,
 806                      ppt, pwidth, fSorted);
 807
 808     cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
 809
 810     while (n--)
 811     {
 812         x = ppt->x;
 813         pdst = pdstBase + (ppt->y * widthDst);
 814         ++ppt;
 815         w = *pwidth++;
 816         if (!w)
 817             continue;
 818 #if PSZ == 24
 819         leftIndex = x &3;
 820 /*      rightIndex = ((leftIndex+w)<5)?0:(x+w)&3;*/
 821         rightIndex = (x+w)&3;
 822
 823         nlmiddle = w - rightIndex;
 824         if(leftIndex){
 825           nlmiddle -= (4 - leftIndex);
 826         }
 827 /*      nlmiddle += 3;*/
 828         nlmiddle >>= 2;
 829         if(nlmiddle < 0)
 830           nlmiddle = 0;
 831
 832         pdst += (x >> 2)*3;
 833         pdst += leftIndex? (leftIndex -1):0;
 834         switch(leftIndex+w){
 835         case 4:
 836             switch(leftIndex){
 837             case 0:
 838 #if RROP == GXcopy
 839                     *pdst++ = piQxelXor[0];
 840                     *pdst++ = piQxelXor[1];
 841                     *pdst-- = piQxelXor[2];
 842 #endif
 843 #if RROP == GXxor
 844                     *pdst++ ^= piQxelXor[0];
 845                     *pdst++ ^= piQxelXor[1];
 846                     *pdst-- ^= piQxelXor[2];
 847 #endif
 848 #if RROP == GXand
 849                     *pdst++ &= piQxelAnd[0];
 850                     *pdst++ &= piQxelAnd[1];
 851                     *pdst-- &= piQxelAnd[2];
 852 #endif
 853 #if RROP == GXor
 854                     *pdst++ |= piQxelOr[0];
 855                     *pdst++ |= piQxelOr[1];
 856                     *pdst-- |= piQxelOr[2];
 857 #endif
 858 #if RROP == GXset
 859                     *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 860                     pdst++;
 861                     *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 862                     pdst++;
 863                     *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 864                     pdst--;
 865 #endif
 866                     pdst--;
 867                 break;
 868             case 1:
 869 #if RROP == GXcopy
 870                     *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 871                     *pdst++ = piQxelXor[1];
 872                     *pdst-- = piQxelXor[2];
 873 #endif
 874 #if RROP == GXxor
 875                     *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 876                     *pdst++ ^= piQxelXor[1];
 877                     *pdst-- ^= piQxelXor[2];
 878 #endif
 879 #if RROP == GXand
 880                     *pdst++ &= (piQxelAnd[0] | 0x00FFFFFF);
 881                     *pdst++ &= piQxelAnd[1];
 882                     *pdst-- &= piQxelAnd[2];
 883 #endif
 884 #if RROP == GXor
 885                     *pdst++ |= (piQxelOr[0] & 0xFF000000);
 886                     *pdst++ |= piQxelOr[1];
 887                     *pdst-- |= piQxelOr[2];
 888 #endif
 889 #if RROP == GXset
 890                     *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 891                     pdst++;
 892                     *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 893                     pdst++;
 894                     *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 895                     pdst--;
 896 #endif
 897                     pdst--;
 898                 break;
 899             case 2:
 900 #if RROP == GXcopy
 901                     *pdst++ = ((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
 902                     *pdst-- = piQxelXor[2];
 903 #endif
 904 #if RROP == GXxor
 905                     *pdst++ ^= (piQxelXor[1] & 0xFFFF0000);
 906                     *pdst-- ^= piQxelXor[2];
 907 #endif
 908 #if RROP == GXand
 909                     *pdst++ &= (piQxelAnd[1] | 0xFFFF);
 910                     *pdst-- &= piQxelAnd[2];
 911 #endif
 912 #if RROP == GXor
 913                     *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
 914                     *pdst-- |= piQxelOr[2];
 915 #endif
 916 #if RROP == GXset
 917                     *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 918                     pdst++;
 919                     *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
 920                     pdst--;
 921 #endif
 922                 break;
 923             case 3:
 924 #if RROP == GXcopy
 925                     *pdst = ((*pdst) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
 926 #endif
 927 #if RROP == GXxor
 928                     *pdst ^= (piQxelXor[2] & 0xFFFFFF00);
 929 #endif
 930 #if RROP == GXand
 931                     *pdst &= (piQxelAnd[2] | 0xFF);
 932 #endif
 933 #if RROP == GXor
 934                     *pdst |= (piQxelOr[2] & 0xFFFFFF00);
 935 #endif
 936 #if RROP == GXset
 937                     *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
 938 #endif
 939                 break;
 940             }
 941             break;
 942         case 3:
 943             switch(leftIndex){
 944             case 0:
 945 #if RROP == GXcopy
 946                     *pdst++ = piQxelXor[0];
 947                     *pdst++ = piQxelXor[1];
 948                     *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 949 #endif
 950 #if RROP == GXxor
 951                     *pdst++ ^= piQxelXor[0];
 952                     *pdst++ ^= piQxelXor[1];
 953                     *pdst-- ^= (piQxelXor[2] & 0xFF);
 954 #endif
 955 #if RROP == GXand
 956                     *pdst++ &= piQxelAnd[0];
 957                     *pdst++ &= piQxelAnd[1];
 958                     *pdst-- &= (piQxelAnd[2] | 0xFFFFFF00);
 959 #endif
 960 #if RROP == GXor
 961                     *pdst++ |= piQxelOr[0];
 962                     *pdst++ |= piQxelOr[1];
 963
 964                     *pdst-- |= (piQxelOr[2] & 0xFF);
 965 #endif
 966 #if RROP == GXset
 967                     *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
 968                     pdst++;
 969                     *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
 970                     pdst++;
 971                     *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
 972                     pdst--;
 973 #endif
 974                     pdst--;
 975                 break;
 976             case 1:
 977 #if RROP == GXcopy
 978                     *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 979                     *pdst++ = piQxelXor[1];
 980                     *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 981 #endif
 982 #if RROP == GXxor
 983                     *pdst++ ^= (piQxelXor[0] & 0xFF000000);
 984                     *pdst++ ^= piQxelXor[1];
 985                     *pdst-- ^= (piQxelXor[2] & 0xFF);
 986 #endif
 987 #if RROP == GXand
 988                     *pdst++ &= (piQxelAnd[0] | 0x00FFFFFF);
 989                     *pdst++ &= piQxelAnd[1];
 990                     *pdst-- &= (piQxelAnd[2] | 0xFFFFFF00);
 991 #endif
 992 #if RROP == GXor
 993                     *pdst++ |= (piQxelOr[0] & 0xFF000000);
 994                     *pdst++ |= piQxelOr[1];
 995                     *pdst-- |= (piQxelOr[2] & 0xFF);
 996 #endif
 997 #if RROP == GXset
 998                     *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
 999                     pdst++;
1000                     *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
1001                     pdst++;
1002                     *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
1003                     pdst--;
1004 #endif
1005                     pdst--;
1006                 break;
1007             case 2:
1008 /*              pdst++;*/
1009 #if RROP == GXcopy
1010                     *pdst++ = ((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
1011                     *pdst-- = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
1012 #endif
1013 #if RROP == GXxor
1014                     *pdst++ ^= (piQxelXor[1] & 0xFFFF0000);
1015                     *pdst-- ^= (piQxelXor[2] & 0xFF);
1016 #endif
1017 #if RROP == GXand
1018                     *pdst++ &= (piQxelAnd[1] | 0xFFFF);
1019                     *pdst-- &= (piQxelAnd[2] | 0xFFFFFF00);
1020 #endif
1021 #if RROP == GXor
1022                     *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
1023                     *pdst-- |= (piQxelOr[2] & 0xFF);
1024 #endif
1025 #if RROP == GXset
1026                     *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
1027                     pdst++;
1028                     *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
1029                     pdst--;
1030 #endif
1031                 break;
1032             }
1033             break;
1034         case 2: /* leftIndex + w = 2*/
1035             if(leftIndex){
1036 #if RROP == GXcopy
1037                     *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
1038                     *pdst-- = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
1039 #endif
1040 #if RROP == GXxor
1041                     *pdst++ ^= (piQxelXor[0] & 0xFF000000);
1042                     *pdst-- ^= (piQxelXor[1] & 0xFFFF);
1043 #endif
1044 #if RROP == GXand
1045                     *pdst++ &= (piQxelAnd[0] | 0xFFFFFF);
1046                     *pdst-- &= (piQxelAnd[1] | 0xFFFF0000);
1047 #endif
1048 #if RROP == GXor
1049                     *pdst++ |= (piQxelOr[0] & 0xFF000000);
1050                     *pdst-- |= (piQxelOr[1] & 0xFFFF);
1051 #endif
1052 #if RROP == GXset
1053                     *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
1054                     pdst++;
1055                     *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
1056                     pdst--;
1057 #endif
1058             }
1059             else{ /*case 2 leftIndex === 0 */
1060 #if RROP == GXcopy
1061                     *pdst++ = piQxelXor[0];
1062                     *pdst-- = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
1063 #endif
1064 #if RROP == GXxor
1065                     *pdst++ ^= piQxelXor[0];
1066                     *pdst-- ^= (piQxelXor[1] & 0xFFFF);
1067 #endif
1068 #if RROP == GXand
1069                     *pdst++ &= piQxelAnd[0];
1070                     *pdst-- &= (piQxelAnd[1] | 0xFFFF0000);
1071 #endif
1072 #if RROP == GXor
1073                     *pdst++ |= piQxelOr[0];
1074                     *pdst-- |= (piQxelOr[1] & 0xFFFF);
1075 #endif
1076 #if RROP == GXset
1077                     *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
1078                     pdst++;
1079                     *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
1080                     pdst--;
1081 #endif
1082             }
1083             break;
1084         case 1: /*only if leftIndex = 0 and w = 1*/
1085 #if RROP == GXcopy
1086                 *pdst = ((*pdst) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
1087 #endif
1088 #if RROP == GXxor
1089                 *pdst ^= (piQxelXor[0] & 0xFFFFFF);
1090 #endif
1091 #if RROP == GXand
1092                 *pdst &= (piQxelAnd[0] | 0xFF000000);
1093 #endif
1094 #if RROP == GXor
1095                 *pdst |= (piQxelOr[0] & 0xFFFFFF);
1096 #endif
1097 #if RROP == GXset
1098                 *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
1099 #endif
1100             break;
1101         case 0: /*never*/
1102             break;
1103         default:
1104         {
1105             switch(leftIndex){
1106                     case 0:
1107                         break;
1108                     case 1:
1109 #if RROP == GXcopy
1110                         *pdst++ = ((*pdst) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
1111                         *pdst++ = piQxelXor[1];
1112                         *pdst++ = piQxelXor[2];
1113 #endif
1114 #if RROP == GXxor
1115                         *pdst++ ^= (piQxelXor[0] & 0xFF000000);
1116                         *pdst++ ^= piQxelXor[1];
1117                         *pdst++ ^= piQxelXor[2];
1118 #endif
1119 #if RROP == GXand
1120                         *pdst++ &= (piQxelAnd[0] | 0xFFFFFF);
1121                         *pdst++ &= piQxelAnd[1];
1122                         *pdst++ &= piQxelAnd[2];
1123 #endif
1124 #if RROP == GXor
1125                         *pdst++ |= (piQxelOr[0] & 0xFF000000);
1126                         *pdst++ |= piQxelOr[1];
1127                         *pdst++ |= piQxelOr[2];
1128 #endif
1129 #if RROP == GXset
1130                         *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFF000000);
1131                         pdst++;
1132                         *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
1133                         pdst++;
1134                         *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
1135                         pdst++;
1136 #endif
1137                     break;
1138                     case 2:
1139 #if RROP == GXcopy
1140                         *pdst++ = (((*pdst) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000));
1141                         *pdst++ = piQxelXor[2];
1142 #endif
1143 #if RROP == GXxor
1144                         *pdst++ ^=(piQxelXor[1] & 0xFFFF0000);
1145                         *pdst++ ^= piQxelXor[2];
1146 #endif
1147 #if RROP == GXand
1148                         *pdst++ &= (piQxelAnd[1] | 0xFFFF);
1149                         *pdst++ &= piQxelAnd[2];
1150 #endif
1151 #if RROP == GXor
1152                         *pdst++ |= (piQxelOr[1] & 0xFFFF0000);
1153                         *pdst++ |= piQxelOr[2];
1154 #endif
1155 #if RROP == GXset
1156                         *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
1157                         pdst++;
1158                         *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
1159                         pdst++;
1160 #endif
1161                         break;
1162                     case 3:
1163 #if RROP == GXcopy
1164                         *pdst++ = ((*pdst) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
1165 #endif
1166 #if RROP == GXxor
1167                         *pdst++ ^= (piQxelXor[2] & 0xFFFFFF00);
1168 #endif
1169 #if RROP == GXand
1170                         *pdst++ &= (piQxelAnd[2] | 0xFF);
1171 #endif
1172 #if RROP == GXor
1173                         *pdst++ |= (piQxelOr[2] & 0xFFFFFF00);
1174 #endif
1175 #if RROP == GXset
1176                         *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
1177                         pdst++;
1178 #endif
1179                         break;
1180                     }
1181                     while(nlmiddle--){
1182 #if RROP == GXcopy
1183                         *pdst++ = piQxelXor[0];
1184                         *pdst++ = piQxelXor[1];
1185                         *pdst++ = piQxelXor[2];
1186 #endif
1187 #if RROP == GXxor
1188                         *pdst++ ^= piQxelXor[0];
1189                         *pdst++ ^= piQxelXor[1];
1190                         *pdst++ ^= piQxelXor[2];
1191 #endif
1192 #if RROP == GXand
1193                         *pdst++ &= piQxelAnd[0];
1194                         *pdst++ &= piQxelAnd[1];
1195                         *pdst++ &= piQxelAnd[2];
1196 #endif
1197 #if RROP == GXor
1198                         *pdst++ |= piQxelOr[0];
1199                         *pdst++ |= piQxelOr[1];
1200                         *pdst++ |= piQxelOr[2];
1201 #endif
1202 #if RROP == GXset
1203                         *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
1204                         pdst++;
1205                         *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
1206                         pdst++;
1207                         *pdst = DoRRop((*pdst), piQxelAnd[2], piQxelXor[2]);
1208                         pdst++;
1209 #endif
1210                 }
1211                 switch(rightIndex){
1212                 case 0:
1213                   break;
1214                 case 1:
1215 #if RROP == GXcopy
1216                   *pdst++ = ((*pdst) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
1217 #endif
1218 #if RROP == GXxor
1219                   *pdst++ ^= (piQxelXor[0] & 0xFFFFFF);
1220 #endif
1221 #if RROP == GXand
1222                   *pdst++ &= (piQxelAnd[0] | 0xFF);
1223 #endif
1224 #if RROP == GXor
1225                   *pdst++ |= (piQxelOr[0] & 0xFFFFFF);
1226 #endif
1227 #if RROP == GXset
1228                   *pdst = DoMaskRRop((*pdst), piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
1229 #endif
1230                   break;
1231                 case 2:
1232 #if RROP == GXcopy
1233                   *pdst++ = piQxelXor[0];
1234                   *pdst++ = ((*pdst) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
1235 #endif
1236 #if RROP == GXxor
1237                   *pdst++ ^= piQxelXor[0];
1238                   *pdst++ ^= (piQxelXor[1] & 0xFFFF);
1239 #endif
1240 #if RROP == GXand
1241                   *pdst++ &= piQxelAnd[0];
1242                   *pdst++ &= (piQxelAnd[1] | 0xFFFF0000);
1243 #endif
1244 #if RROP == GXor
1245                   *pdst++ |= piQxelOr[0];
1246                   *pdst++ |= (piQxelOr[1] & 0xFFFF);
1247 #endif
1248 #if RROP == GXset
1249                   *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
1250                   *pdst++;
1251                   *pdst = DoMaskRRop((*pdst), piQxelAnd[1], piQxelXor[1], 0xFFFF);
1252                   *pdst++;
1253 #endif
1254                   break;
1255                 case 3:
1256 #if RROP == GXcopy
1257                   *pdst++ = piQxelXor[0];
1258                   *pdst++ = piQxelXor[1];
1259                   *pdst++ = ((*pdst) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
1260 #endif
1261 #if RROP == GXxor
1262                   *pdst++ ^= piQxelXor[0];
1263                   *pdst++ ^= piQxelXor[1];
1264                   *pdst++ ^= (piQxelXor[2] & 0xFF);
1265 #endif
1266 #if RROP == GXand
1267                   *pdst++ &= piQxelAnd[0];
1268                   *pdst++ &= piQxelAnd[1];
1269                   *pdst++ &= (piQxelAnd[2] | 0xFFFFFF00);
1270 #endif
1271 #if RROP == GXor
1272                   *pdst++ |= piQxelOr[0];
1273                   *pdst++ |= piQxelOr[1];
1274                   *pdst++ |= (piQxelOr[2] & 0xFF);
1275 #endif
1276 #if RROP == GXset
1277                   *pdst = DoRRop((*pdst), piQxelAnd[0], piQxelXor[0]);
1278                   pdst++;
1279                   *pdst = DoRRop((*pdst), piQxelAnd[1], piQxelXor[1]);
1280                   pdst++;
1281                   *pdst = DoMaskRRop((*pdst), piQxelAnd[2], piQxelXor[2], 0xFF);
1282                   pdst++;
1283 #endif
1284                   break;
1285                 }
1286         }
1287 }
1288 #else
1289 #if PSZ == 8
1290         if (w <= PGSZB)
1291         {
1292             register char   *addrb;
1293
1294             addrb = ((char *) pdst) + x;
1295             while (w--)
1296             {
1297                 RROP_SOLID (addrb);
1298                 addrb++;
1299             }
1300         }
1301 #else
1302         if ((x & PIM) + w <= PPW)
1303         {
1304             pdst += x >> PWSH;
1305             maskpartialbits (x, w, startmask);
1306             RROP_SOLID_MASK (pdst, startmask);
1307         }
1308 #endif
1309         else
1310         {
1311             pdst += x >> PWSH;
1312             maskbits (x, w, startmask, endmask, nlmiddle);
1313             if (startmask)
1314             {
1315                 RROP_SOLID_MASK (pdst, startmask);
1316                 ++pdst;
1317             }
1318
1319             RROP_SPAN(pdst,nlmiddle)
1320             if (endmask)
1321             {
1322                 RROP_SOLID_MASK (pdst, endmask);
1323             }
1324         }
1325 #endif
1326     }
1327     DEALLOCATE_LOCAL(pptFree);
1328     DEALLOCATE_LOCAL(pwidthFree);
1329 }