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

   1 /***********************************************************
   2
   3 Copyright (c) 1987  X Consortium
   4
   5 Permission is hereby granted, free of charge, to any person obtaining a copy
   6 of this software and associated documentation files (the "Software"), to deal
   7 in the Software without restriction, including without limitation the rights
   8 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 copies of the Software, and to permit persons to whom the Software is
  10 furnished to do so, subject to the following conditions:
  11
  12 The above copyright notice and this permission notice shall be included in
  13 all copies or substantial portions of the Software.
  14
  15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  18 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  19 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  20 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21
  22 Except as contained in this notice, the name of the X Consortium shall not be
  23 used in advertising or otherwise to promote the sale, use or other dealings
  24 in this Software without prior written authorization from the X Consortium.
  25
  26
  27 Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
  28
  29                         All Rights Reserved
  30
  31 Permission to use, copy, modify, and distribute this software and its
  32 documentation for any purpose and without fee is hereby granted,
  33 provided that the above copyright notice appear in all copies and that
  34 both that copyright notice and this permission notice appear in
  35 supporting documentation, and that the name of Digital not be
  36 used in advertising or publicity pertaining to distribution of the
  37 software without specific, written prior permission.
  38
  39 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  40 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  41 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  42 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  43 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  44 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  45 SOFTWARE.
  46
  47 ******************************************************************/
  48 /* $XConsortium: cfbhrzvert.c,v 1.8 94/04/17 20:28:51 dpw Exp $ */
  49 /* $XFree86: xc/programs/Xserver/cfb/cfbhrzvert.c,v 3.2 1996/11/24 09:51:43 dawes Exp $ */
  50 #include "X.h"
  51
  52 #include "gc.h"
  53 #include "window.h"
  54 #include "pixmap.h"
  55 #include "region.h"
  56
  57 #include "cfb.h"
  58 #include "cfbmskbits.h"
  59
  60 /* horizontal solid line
  61    abs(len) > 1
  62 */
  63 cfbHorzS(rop, and, xor, addrl, nlwidth, x1, y1, len)
  64 register int rop;
  65 register unsigned long and;
  66 register unsigned long xor;
  67 register unsigned long *addrl;  /* pointer to base of bitmap */
  68 int nlwidth;            /* width in longwords of bitmap */
  69 int x1;                 /* initial point */
  70 int y1;
  71 int len;                /* length of line */
  72 {
  73     register int nlmiddle;
  74     register unsigned long startmask;
  75     register unsigned long endmask;
  76 #if PSZ == 24
  77     int leftIndex, rightIndex, xOffset;
  78     unsigned long piQxelAnd[3], piQxelXor[3];
  79     piQxelAnd[0] = (and & 0xFFFFFF) | ((and<<24)  & 0xFF000000);
  80     piQxelAnd[1] = ((and>>8)  & 0xFFFF)| ((and<<16) & 0xFFFF0000);
  81     piQxelAnd[2] = ((and<<8) & 0xFFFFFF00) | ((and>>16) & 0xFF);
  82
  83     piQxelXor[0] = (xor & 0xFFFFFF) | ((xor<<24) & 0xFF000000);
  84     piQxelXor[1] = ((xor>>8)  & 0xFFFF)| ((xor<<16) & 0xFFFF0000);
  85     piQxelXor[2] = ((xor<<8) & 0xFFFFFF00) | ((xor>>16) & 0xFF);
  86
  87     leftIndex = x1 & 3;
  88     rightIndex = ((x1 + len) < 5)?0:(x1 + len)&3;
  89     nlmiddle = len;
  90     if(leftIndex){
  91       nlmiddle -= (4 - leftIndex);
  92     }
  93     if(rightIndex){
  94       nlmiddle -= rightIndex;
  95     }
  96     if (nlmiddle < 0)
  97       nlmiddle = 0;
  98
  99     nlmiddle >>= 2;
 100
 101     addrl += (y1 * nlwidth) + (x1 >> 2)*3 + (leftIndex?leftIndex-1:0);
 102
 103     switch(leftIndex+len){
 104     case 4:
 105       switch(leftIndex){
 106       case 0:
 107         *addrl++ = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
 108         *addrl++ = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
 109         *addrl   = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
 110         break;
 111       case 1:
 112         *addrl++ = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
 113         *addrl++ = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
 114         *addrl   = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
 115         break;
 116       case 2:
 117         *addrl++ = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 118         *addrl   = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
 119         break;
 120       case 3:
 121         *addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
 122         break;
 123       }
 124       break;
 125     case 3:
 126       switch(leftIndex){
 127       case 0:
 128         *addrl++ = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
 129         *addrl++ = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
 130         *addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
 131         break;
 132       case 1:
 133         *addrl++ = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
 134         *addrl++ = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
 135         *addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
 136         break;
 137       case 2:
 138         *addrl++ = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 139         *addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
 140         break;
 141       }
 142       break;
 143     case 2:
 144       if(leftIndex){
 145         *addrl++ = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
 146       }
 147       else{
 148         *addrl++ = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
 149       }
 150       *addrl =  DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF);
 151       break;
 152     case 1: /*only if leftIndex = 0 and w = 1*/
 153       *addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
 154       break;
 155     case 0: /*never*/
 156       break;
 157     default:
 158       {
 159         if (rop == GXcopy){
 160           switch(leftIndex){
 161           case 0:
 162             break;
 163           case 1:
 164             *addrl++ = ((*addrl) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
 165             *addrl++ = piQxelXor[1];
 166             *addrl++ = piQxelXor[2];
 167             break;
 168           case 2:
 169             *addrl++ = ((*addrl) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
 170             *addrl++ = piQxelXor[2];
 171             break;
 172           case 3:
 173             *addrl++ = ((*addrl) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
 174             break;
 175           }
 176           while(nlmiddle--){
 177             *addrl++ = piQxelXor[0];
 178             *addrl++ = piQxelXor[1];
 179             *addrl++ = piQxelXor[2];
 180           }
 181           switch(rightIndex){
 182           case 0:
 183             break;
 184           case 1:
 185             *addrl = ((*addrl) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
 186             break;
 187           case 2:
 188             *addrl++ = piQxelXor[0];
 189             *addrl = ((*addrl) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
 190             break;
 191           case 3:
 192             *addrl++ = piQxelXor[0];
 193             *addrl++ = piQxelXor[1];
 194             *addrl = ((*addrl) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
 195             break;
 196           }
 197         }
 198         else{
 199           if(rop == GXxor){
 200           switch(leftIndex){
 201           case 0:
 202             break;
 203           case 1:
 204             *addrl++ ^= (piQxelXor[0]&0xFF000000);
 205             *addrl++ ^= piQxelXor[1];
 206             *addrl++ ^= piQxelXor[2];
 207             break;
 208           case 2:
 209             *addrl++ ^= (piQxelXor[1]& 0xFFFF0000);
 210             *addrl++ ^= piQxelXor[2];
 211             break;
 212           case 3:
 213             *addrl++ ^= (piQxelXor[2]& 0xFFFFFF00);
 214             break;
 215           }
 216           while(nlmiddle--){
 217             *addrl++ ^= piQxelXor[0];
 218             *addrl++ ^= piQxelXor[1];
 219             *addrl++ ^= piQxelXor[2];
 220           }
 221           switch(rightIndex){
 222           case 0:
 223             break;
 224           case 1:
 225             *addrl ^= (piQxelXor[0]& 0xFFFFFF);
 226             break;
 227           case 2:
 228             *addrl++ ^= piQxelXor[0];
 229             *addrl ^= (piQxelXor[1]&0xFFFF);
 230             break;
 231           case 3:
 232             *addrl++ ^= piQxelXor[0];
 233             *addrl++ ^= piQxelXor[1];
 234             *addrl ^= (piQxelXor[2]&0xFF);
 235             break;
 236           }
 237         }
 238           else{
 239             switch(leftIndex){
 240             case 0:
 241               break;
 242             case 1:
 243               *addrl++ = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
 244               *addrl++ = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
 245               *addrl++ = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
 246               break;
 247             case 2:
 248               *addrl++ = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
 249               *addrl++ = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
 250               break;
 251             case 3:
 252               *addrl++ = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
 253               break;
 254           }
 255           while(nlmiddle--){
 256             *addrl++ = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
 257             *addrl++ = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
 258             *addrl++ = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
 259           }
 260           switch(rightIndex){
 261           case 0:
 262             break;
 263           case 1:
 264             *addrl++ = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
 265             break;
 266           case 2:
 267             *addrl++ = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
 268             *addrl = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF);
 269             break;
 270           case 3:
 271             *addrl++ = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
 272             *addrl++ = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
 273             *addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
 274             break;
 275           }
 276
 277           }
 278         }
 279       }
 280     }
 281 #else
 282     addrl = addrl + (y1 * nlwidth) + (x1 >> PWSH);
 283
 284     /* all bits inside same longword */
 285     if ( ((x1 & PIM) + len) < PPW)
 286     {
 287         maskpartialbits(x1, len, startmask);
 288         *addrl = DoMaskRRop (*addrl, and, xor, startmask);
 289     }
 290     else
 291     {
 292         maskbits(x1, len, startmask, endmask, nlmiddle);
 293         if (rop == GXcopy)
 294         {
 295             if (startmask)
 296             {
 297                 *addrl = (*addrl & ~startmask) | (xor & startmask);
 298                 addrl++;
 299             }
 300             while (nlmiddle--)
 301                 *addrl++ = xor;
 302             if (endmask)
 303                 *addrl = (*addrl & ~endmask) | (xor & endmask);
 304         }
 305         else
 306         {
 307             if (startmask)
 308             {
 309                 *addrl = DoMaskRRop (*addrl, and, xor, startmask);
 310                 addrl++;
 311             }
 312             if (rop == GXxor)
 313             {
 314                 while (nlmiddle--)
 315                     *addrl++ ^= xor;
 316             }
 317             else
 318             {
 319                 while (nlmiddle--)
 320                 {
 321                     *addrl = DoRRop (*addrl, and, xor);
 322                     addrl++;
 323                 }
 324             }
 325             if (endmask)
 326                 *addrl = DoMaskRRop (*addrl, and, xor, endmask);
 327         }
 328     }
 329 #endif
 330 }
 331
 332 /* vertical solid line */
 333
 334 void
 335 cfbVertS(rop, and, xor, addrl, nlwidth, x1, y1, len)
 336 int rop;
 337 register unsigned long and, xor;
 338 register unsigned long *addrl;  /* pointer to base of bitmap */
 339 register int nlwidth;   /* width in longwords of bitmap */
 340 int x1, y1;             /* initial point */
 341 register int len;       /* length of line */
 342 {
 343 #if PSZ == 24
 344     int xIdx;
 345     unsigned long and2, xor2, offset, mask, mask2;
 346 #endif
 347 #ifdef PIXEL_ADDR
 348     register PixelType    *bits = (PixelType *) addrl;
 349
 350 #if PSZ == 24
 351     nlwidth <<= PWSH;
 352     xIdx = x1 & 3;
 353     bits = (PixelType *)(addrl + (y1 * nlwidth) + ((x1*3) >> 2));
 354 #else
 355     nlwidth <<= PWSH;
 356     bits = bits + (y1 * nlwidth) + x1;
 357 #endif
 358 #if PSZ == 24
 359     mask2 = 0;
 360     switch(xIdx){
 361       case 0:
 362         mask = 0xFF000000;
 363         xor &= 0xFFFFFF;
 364         and |= 0xFF000000;
 365         break;
 366       case 3:
 367         mask = 0xFF;
 368         xor &= 0xFFFFFF;
 369         xor <<= 8;
 370         and <<= 8;
 371         and |= 0xFF;
 372         break;
 373       case 1:
 374         mask = 0xFFFFFF;
 375         mask2 = 0xFFFF0000;
 376         xor2 = (xor>>8) & 0xFFFF;
 377         xor &= 0xFF;
 378         xor <<= 24;
 379         and2 = (and >> 8 ) | 0xFFFF0000;
 380         and <<= 24;
 381         and |= 0xFFFFFF;
 382         break;
 383       case 2:
 384         mask = 0x0000FFFF;
 385         mask2 = 0xFFFFFF00;
 386         xor2 = (xor >> 16) & 0xFF;
 387         xor <<= 16;
 388         xor &= 0xFFFF0000;
 389         and2 = (and >> 16) | 0xFFFFFF00;
 390         and <<= 16;
 391         and |= 0xFFFF;
 392         break;
 393       }
 394 #endif
 395
 396     /*
 397      * special case copy and xor to avoid a test per pixel
 398      */
 399     if (rop == GXcopy)
 400     {
 401 #if PSZ == 24
 402       switch(xIdx){
 403       case 0:
 404       case 3:
 405         while (len--){
 406           *bits = (*bits & mask)| xor;
 407           bits += nlwidth;
 408         }
 409         break;
 410       case 1:
 411       case 2:
 412         while (len--){
 413           *bits = (*bits & mask)| xor;
 414           bits++;
 415           *bits = (*bits & mask2)| xor2;
 416           bits--;
 417           bits += nlwidth;
 418         }
 419         break;
 420       }
 421 #else
 422         while (len--)
 423         {
 424             *bits = xor;
 425             bits += nlwidth;
 426         }
 427 #endif
 428     }
 429     else if (rop == GXxor)
 430     {
 431 #if PSZ == 24
 432       switch(xIdx){
 433       case 0:
 434       case 3:
 435         while (len--){
 436           *bits ^=  xor;
 437           bits += nlwidth;
 438         }
 439         break;
 440       case 1:
 441       case 2:
 442         while (len--){
 443           *bits ^= xor;
 444           bits++;
 445           *bits ^= xor2;
 446           bits--;
 447           bits += nlwidth;
 448         }
 449         break;
 450       }
 451 #else
 452         while (len--)
 453         {
 454             *bits ^= xor;
 455             bits += nlwidth;
 456         }
 457 #endif
 458     }
 459     else
 460     {
 461 #if PSZ == 24
 462       switch(xIdx){
 463       case 0:
 464         while (len--){
 465           *bits = DoMaskRRop(*bits, and, xor, 0x00FFFFFF);
 466           bits += nlwidth;
 467         }
 468         break;
 469       case 3:
 470         while (len--){
 471           *bits = DoMaskRRop(*bits, and, xor, 0xFFFFFF00);
 472           bits += nlwidth;
 473         }
 474         break;
 475       case 1:
 476         while (len--){
 477           *bits = DoMaskRRop(*bits, and, xor, 0xFF000000);
 478           bits++;
 479           *bits = DoMaskRRop(*bits, and2, xor2, 0x0000FFFF);
 480           bits--;
 481           bits += nlwidth;
 482         }
 483         break;
 484       case 2:
 485         while (len--){
 486           *bits = DoMaskRRop(*bits, and, xor, 0xFFFF0000);
 487           bits++;
 488           *bits = DoMaskRRop(*bits, and2, xor2, 0x000000FF);
 489           bits--;
 490           bits += nlwidth;
 491         }
 492         break;
 493       }
 494 #else
 495         while (len--)
 496         {
 497             *bits = DoRRop(*bits, and, xor);
 498             bits += nlwidth;
 499         }
 500 #endif
 501     }
 502 #else /* !PIXEL_ADDR */
 503 #if PSZ == 24
 504     addrl = addrl + (y1 * nlwidth) + ((x1*3) >>2);
 505
 506     and |= ~cfbmask[(x1 & 3)<<1];
 507     xor &= cfbmask[(x1 & 3)<<1];
 508 #else
 509     addrl = addrl + (y1 * nlwidth) + (x1 >> PWSH);
 510
 511     and |= ~cfbmask[x1 & PIM];
 512     xor &= cfbmask[x1 & PIM];
 513 #endif
 514
 515     while (len--)
 516     {
 517         *addrl = DoRRop (*addrl, and, xor);
 518         addrl += nlwidth;
 519     }
 520 #endif
 521 }