git.sesse.net Git - rdpsrv/blob - Xserver/programs/Xserver/cfb/cfbbres.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: cfbbres.c,v 1.15 94/04/17 20:28:45 dpw Exp $ */
  49 /* $XFree86: xc/programs/Xserver/cfb/cfbbres.c,v 3.1 1996/08/25 14:05:40 dawes Exp $ */
  50 #include "X.h"
  51 #include "misc.h"
  52 #include "cfb.h"
  53 #include "cfbmskbits.h"
  54 #include "servermd.h"
  55 #include "miline.h"
  56
  57 /* Solid bresenham line */
  58 /* NOTES
  59    e2 is used less often than e1, so it's not in a register
  60 */
  61
  62 void
  63 cfbBresS(rop, and, xor, addrl, nlwidth, signdx, signdy, axis, x1, y1, e, e1,
  64          e2, len)
  65     int             rop;
  66     unsigned long   and, xor;
  67     unsigned long   *addrl;             /* pointer to base of bitmap */
  68     int             nlwidth;            /* width in longwords of bitmap */
  69     register int    signdx;
  70     int             signdy;             /* signs of directions */
  71     int             axis;               /* major axis (Y_AXIS or X_AXIS) */
  72     int             x1, y1;             /* initial point */
  73     register int    e;                  /* error accumulator */
  74     register int    e1;                 /* bresenham increments */
  75     int             e2;
  76     int             len;                /* length of line */
  77 {
  78     register int        e3 = e2-e1;
  79 #if PSZ == 24
  80     unsigned long piQxelXor[3],piQxelAnd[3];
  81     char *addrb;
  82     int nlwidth3, signdx3;
  83 #endif
  84 #ifdef PIXEL_ADDR
  85     register PixelType  *addrp;         /* Pixel pointer */
  86
  87     if (len == 0)
  88         return;
  89     /* point to first point */
  90     nlwidth <<= PWSH;
  91 #if PSZ == 24
  92     addrp = (PixelType *)(addrl) + (y1 * nlwidth);
  93     addrb = (char *)addrp + x1 * 3;
  94
  95     piQxelXor[0] = (xor << 24) | xor;
  96     piQxelXor[1] = (xor << 16)| (xor >> 8);
  97     piQxelXor[2] = (xor << 8) | (xor >> 16);
  98     piQxelAnd[0] = (and << 24) | and;
  99     piQxelAnd[1] = (and << 16)| (and >> 8);
 100     piQxelAnd[2] = (and << 8) | (and >> 16);
 101 #else
 102     addrp = (PixelType *)(addrl) + (y1 * nlwidth) + x1;
 103 #endif
 104     if (signdy < 0)
 105         nlwidth = -nlwidth;
 106     e = e-e1;                   /* to make looping easier */
 107 #if PSZ == 24
 108     nlwidth3 = nlwidth * sizeof (long);
 109     signdx3 = signdx * 3;
 110 #endif
 111
 112     if (axis == Y_AXIS)
 113     {
 114         int     t;
 115
 116         t = nlwidth;
 117         nlwidth = signdx;
 118         signdx = t;
 119 #if PSZ == 24
 120         t = nlwidth3;
 121         nlwidth3 = signdx3;
 122         signdx3 = t;
 123 #endif
 124     }
 125     if (rop == GXcopy)
 126     {
 127         --len;
 128 #if PSZ == 24
 129 #define body_copy \
 130             addrp = (PixelType *)((unsigned long)addrb & ~0x03); \
 131             switch((unsigned long)addrb & 3){ \
 132             case 0: \
 133               *addrp = ((*addrp)&0xFF000000)|(piQxelXor[0] & 0xFFFFFF); \
 134               break; \
 135             case 1: \
 136               *addrp = ((*addrp)&0xFF)|(piQxelXor[2] & 0xFFFFFF00); \
 137               break; \
 138             case 3: \
 139               *addrp = ((*addrp)&0xFFFFFF)|(piQxelXor[0] & 0xFF000000); \
 140               *(addrp+1) = ((*(addrp+1))&0xFFFF0000)|(piQxelXor[1] & 0xFFFF); \
 141               break; \
 142             case 2: \
 143               *addrp = ((*addrp)&0xFFFF)|(piQxelXor[1] & 0xFFFF0000); \
 144               *(addrp+1) = ((*(addrp+1))&0xFFFFFF00)|(piQxelXor[2] & 0xFF); \
 145               break; \
 146             }
 147 #define body {\
 148             body_copy \
 149             addrb += signdx3; \
 150             e += e1; \
 151             if (e >= 0) \
 152             { \
 153                 addrb += nlwidth3; \
 154                 e += e3; \
 155              } \
 156             }
 157 #else /* PSZ == 24 */
 158 #define body {\
 159             *addrp = xor; \
 160             addrp += signdx; \
 161             e += e1; \
 162             if (e >= 0) \
 163             { \
 164                 addrp += nlwidth; \
 165                 e += e3; \
 166             } \
 167         }
 168 #endif /* PSZ == 24 */
 169         while (len >= 4)
 170         {
 171             body body body body
 172             len -= 4;
 173         }
 174         switch (len)
 175         {
 176         case  3: body case  2: body case  1: body
 177         }
 178 #undef body
 179 #if PSZ == 24
 180         body_copy
 181 # undef body_copy
 182 #else
 183         *addrp = xor;
 184 #endif
 185     }
 186     else /* not GXcopy */
 187     {
 188         while(len--)
 189         {
 190 #if PSZ == 24
 191             addrp = (PixelType *)((unsigned long)addrb & ~0x03);
 192             switch((unsigned long)addrb & 3){
 193             case 0:
 194               *addrp = (*addrp & (piQxelAnd[0]|0xFF000000))
 195                         ^ (piQxelXor[0] & 0xFFFFFF);
 196               break;
 197             case 1:
 198               *addrp = (*addrp & (piQxelAnd[2]|0xFF))
 199                         ^ (piQxelXor[2] & 0xFFFFFF00);
 200               break;
 201             case 3:
 202               *addrp = (*addrp & (piQxelAnd[0]|0xFFFFFF))
 203                         ^ (piQxelXor[0] & 0xFF000000);
 204               *(addrp+1) = (*(addrp+1) & (piQxelAnd[1]|0xFFFF0000))
 205                         ^ (piQxelXor[1] & 0xFFFF);
 206               break;
 207             case 2:
 208               *addrp = (*addrp & (piQxelAnd[1]|0xFFFF))
 209                         ^ (piQxelXor[1] & 0xFFFF0000);
 210               *(addrp+1) = (*(addrp+1) & (piQxelAnd[2]|0xFFFFFF00))
 211                         ^ (piQxelXor[2] & 0xFF);
 212               break;
 213             }
 214             e += e1;
 215             if (e >= 0)
 216             {
 217                 addrb += nlwidth3;
 218                 e += e3;
 219             }
 220             addrb += signdx3;
 221 #else /* PSZ == 24 */
 222             *addrp = DoRRop (*addrp, and, xor);
 223             e += e1;
 224             if (e >= 0)
 225             {
 226                 addrp += nlwidth;
 227                 e += e3;
 228             }
 229             addrp += signdx;
 230 #endif /* PSZ == 24 */
 231         }
 232     }
 233 #else /* !PIXEL_ADDR */
 234     register unsigned long   tmp, bit;
 235     unsigned long leftbit, rightbit;
 236
 237     /* point to longword containing first point */
 238 #if PSZ == 24
 239     addrl = (addrl + (y1 * nlwidth) + ((x1 * 3) >>2);
 240 #else
 241     addrl = (addrl + (y1 * nlwidth) + (x1 >> PWSH));
 242 #endif
 243     if (signdy < 0)
 244             nlwidth = -nlwidth;
 245     e = e-e1;                   /* to make looping easier */
 246
 247     leftbit = cfbmask[0];
 248 #if PSZ == 24
 249     rightbit = cfbmask[(PPW-1)<<1];
 250     bit = cfbmask[(x1 & 3)<<1];
 251 #else
 252     rightbit = cfbmask[PPW-1];
 253     bit = cfbmask[x1 & PIM];
 254 #endif
 255
 256     if (axis == X_AXIS)
 257     {
 258         if (signdx > 0)
 259         {
 260             while (len--)
 261             {
 262                 *addrl = DoMaskRRop (*addrl, and, xor, bit);
 263                 bit = SCRRIGHT(bit,1);
 264                 e += e1;
 265                 if (e >= 0)
 266                 {
 267                     addrl += nlwidth;
 268                     e += e3;
 269                 }
 270                 if (!bit)
 271                 {
 272                     bit = leftbit;
 273                     addrl++;
 274                 }
 275             }
 276         }
 277         else
 278         {
 279             while (len--)
 280             {
 281                 *addrl = DoMaskRRop (*addrl, and, xor, bit);
 282                 e += e1;
 283                 bit = SCRLEFT(bit,1);
 284                 if (e >= 0)
 285                 {
 286                     addrl += nlwidth;
 287                     e += e3;
 288                 }
 289                 if (!bit)
 290                 {
 291                     bit = rightbit;
 292                     addrl--;
 293                 }
 294             }
 295         }
 296     } /* if X_AXIS */
 297     else
 298     {
 299         if (signdx > 0)
 300         {
 301             while(len--)
 302             {
 303                 *addrl = DoMaskRRop (*addrl, and, xor, bit);
 304                 e += e1;
 305                 if (e >= 0)
 306                 {
 307                     bit = SCRRIGHT(bit,1);
 308                     if (!bit)
 309                     {
 310                         bit = leftbit;
 311                         addrl++;
 312                     }
 313                     e += e3;
 314                 }
 315                 addrl += nlwidth;
 316             }
 317         }
 318         else
 319         {
 320             while(len--)
 321             {
 322                 *addrl = DoMaskRRop (*addrl, and, xor, bit);
 323                 e += e1;
 324                 if (e >= 0)
 325                 {
 326                     bit = SCRLEFT(bit,1);
 327                     if (!bit)
 328                     {
 329                         bit = rightbit;
 330                         addrl--;
 331                     }
 332                     e += e3;
 333                 }
 334                 addrl += nlwidth;
 335             }
 336         }
 337     } /* else Y_AXIS */
 338 #endif
 339 }