xorg-server-1.4/mfb/mfbbres.c

   1 /* Combined Purdue/PurduePlus patches, level 2.0, 1/17/89 */
   2 /***********************************************************
   3
   4 Copyright 1987, 1998  The Open Group
   5
   6 Permission to use, copy, modify, distribute, and sell this software and its
   7 documentation for any purpose is hereby granted without fee, provided that
   8 the above copyright notice appear in all copies and that both that
   9 copyright notice and this permission notice appear in supporting
  10 documentation.
  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 OPEN GROUP 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 Open Group 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 Open Group.
  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 #ifdef HAVE_DIX_CONFIG_H
  49 #include <dix-config.h>
  50 #endif
  51
  52 #include <X11/X.h>
  53 #include "misc.h"
  54 #include "mfb.h"
  55 #include "maskbits.h"
  56 #include "miline.h"
  57
  58 /* Solid bresenham line */
  59 /* NOTES
  60    e2 is used less often than e1, so it's not in a register
  61 */
  62
  63 void
  64 mfbBresS(rop, addrlbase, nlwidth, signdx, signdy, axis, x1, y1, e, e1, e2, len)
  65 int rop;                /* a reduced rasterop */
  66 PixelType *addrlbase;   /* pointer to base of bitmap */
  67 int nlwidth;            /* width in longwords of bitmap */
  68 int signdx, signdy;     /* signs of directions */
  69 int axis;               /* major axis (Y_AXIS or X_AXIS) */
  70 int x1, y1;             /* initial point */
  71 register int e;         /* error accumulator */
  72 register int e1;        /* bresenham increments */
  73 int e2;
  74 int len;                /* length of line */
  75 {
  76     register int yinc;  /* increment to next scanline, in bytes */
  77     register PixelType *addrl;  /* bitmask 32-bit pointer */
  78     register PixelType bit;     /* current bit being set/cleared/etc.  */
  79     PixelType leftbit = mask[0]; /* leftmost bit to process in new word */
  80     PixelType rightbit = mask[PPW-1]; /* rightmost bit to process in new word */
  81
  82     register int e3 = e2-e1;
  83     PixelType   tmp;
  84
  85     /* point to longword containing first point */
  86     addrl = mfbScanline(addrlbase, x1, y1, nlwidth);
  87     yinc = signdy * nlwidth;
  88     e = e-e1;                   /* to make looping easier */
  89     bit = mask[x1 & PIM];
  90
  91     if (!len)
  92         return;
  93     if (rop == RROP_BLACK)
  94     {
  95         if (axis == X_AXIS)
  96         {
  97             if (signdx > 0)
  98             {
  99                 tmp = *addrl;
 100                 for (;;)
 101                 {
 102                     tmp &= ~bit;
 103                     if (!--len)
 104                         break;
 105                     bit = SCRRIGHT(bit,1);
 106                     e += e1;
 107                     if (e >= 0)
 108                     {
 109                         *addrl = tmp;
 110                         mfbScanlineInc(addrl, yinc);
 111                         e += e3;
 112                         if (!bit)
 113                         {
 114                             bit = leftbit;
 115                             addrl ++;
 116                         }
 117                         tmp = *addrl;
 118                     }
 119                     else if (!bit)
 120                     {
 121                         *addrl = tmp;
 122                         bit = leftbit;
 123                         addrl ++;
 124                         tmp = *addrl;
 125                     }
 126                 }
 127                 *addrl = tmp;
 128             }
 129             else
 130             {
 131                 tmp = *addrl;
 132                 for (;;)
 133                 {
 134                     tmp &= ~bit;
 135                     if (!--len)
 136                         break;
 137                     e += e1;
 138                     bit = SCRLEFT(bit,1);
 139                     if (e >= 0)
 140                     {
 141                         *addrl = tmp;
 142                         mfbScanlineInc(addrl, yinc);
 143                         e += e3;
 144                         if (!bit)
 145                         {
 146                             bit = rightbit;
 147                             addrl --;
 148                         }
 149                         tmp = *addrl;
 150                     }
 151                     else if (!bit)
 152                     {
 153                         *addrl = tmp;
 154                         bit = rightbit;
 155                         addrl --;
 156                         tmp = *addrl;
 157                     }
 158                 }
 159                 *addrl = tmp;
 160             }
 161         } /* if X_AXIS */
 162         else
 163         {
 164             if (signdx > 0)
 165             {
 166                 while(len--)
 167                 {
 168                     *addrl &= ~bit;
 169                     e += e1;
 170                     if (e >= 0)
 171                     {
 172                         bit = SCRRIGHT(bit,1);
 173                         if (!bit) { bit = leftbit;addrl ++; }
 174                         e += e3;
 175                     }
 176                     mfbScanlineInc(addrl, yinc);
 177                 }
 178             }
 179             else
 180             {
 181                 while(len--)
 182                 {
 183                     *addrl &= ~bit;
 184                     e += e1;
 185                     if (e >= 0)
 186                     {
 187                         bit = SCRLEFT(bit,1);
 188                         if (!bit) { bit = rightbit;addrl --; }
 189                         e += e3;
 190                     }
 191                     mfbScanlineInc(addrl, yinc);
 192                 }
 193             }
 194         } /* else Y_AXIS */
 195     }
 196     else if (rop == RROP_WHITE)
 197     {
 198         if (axis == X_AXIS)
 199         {
 200             if (signdx > 0)
 201             {
 202                 tmp = *addrl;
 203                 for (;;)
 204                 {
 205                     tmp |= bit;
 206                     if (!--len)
 207                         break;
 208                     e += e1;
 209                     bit = SCRRIGHT(bit,1);
 210                     if (e >= 0)
 211                     {
 212                         *addrl = tmp;
 213                         mfbScanlineInc(addrl, yinc);
 214                         e += e3;
 215                         if (!bit)
 216                         {
 217                             bit = leftbit;
 218                             addrl ++;
 219                         }
 220                         tmp = *addrl;
 221                     }
 222                     else if (!bit)
 223                     {
 224                         *addrl = tmp;
 225                         bit = leftbit;
 226                         addrl ++;
 227                         tmp = *addrl;
 228                     }
 229                 }
 230                 *addrl = tmp;
 231             }
 232             else
 233             {
 234                 tmp = *addrl;
 235                 for (;;)
 236                 {
 237                     tmp |= bit;
 238                     if (!--len)
 239                         break;
 240                     e += e1;
 241                     bit = SCRLEFT(bit,1);
 242                     if (e >= 0)
 243                     {
 244                         *addrl = tmp;
 245                         mfbScanlineInc(addrl, yinc);
 246                         e += e3;
 247                         if (!bit)
 248                         {
 249                             bit = rightbit;
 250                             addrl --;
 251                         }
 252                         tmp = *addrl;
 253                     }
 254                     else if (!bit)
 255                     {
 256                         *addrl = tmp;
 257                         bit = rightbit;
 258                         addrl --;
 259                         tmp = *addrl;
 260                     }
 261                 }
 262                 *addrl = tmp;
 263             }
 264         } /* if X_AXIS */
 265         else
 266         {
 267             if (signdx > 0)
 268             {
 269                 while(len--)
 270                 {
 271                     *addrl |= bit;
 272                     e += e1;
 273                     if (e >= 0)
 274                     {
 275                         bit = SCRRIGHT(bit,1);
 276                         if (!bit) { bit = leftbit;addrl ++; }
 277                         e += e3;
 278                     }
 279                     mfbScanlineInc(addrl, yinc);
 280                 }
 281             }
 282             else
 283             {
 284                 while(len--)
 285                 {
 286                     *addrl |= bit;
 287                     e += e1;
 288                     if (e >= 0)
 289                     {
 290                         bit = SCRLEFT(bit,1);
 291                         if (!bit) { bit = rightbit;addrl --; }
 292                         e += e3;
 293                     }
 294                     mfbScanlineInc(addrl, yinc);
 295                 }
 296             }
 297         } /* else Y_AXIS */
 298     }
 299     else if (rop == RROP_INVERT)
 300     {
 301         if (axis == X_AXIS)
 302         {
 303             if (signdx > 0)
 304             {
 305                 while(len--)
 306                 {
 307                     *addrl ^= bit;
 308                     e += e1;
 309                     if (e >= 0)
 310                     {
 311                         mfbScanlineInc(addrl, yinc);
 312                         e += e3;
 313                     }
 314                     bit = SCRRIGHT(bit,1);
 315                     if (!bit) { bit = leftbit;addrl ++; }
 316                 }
 317             }
 318             else
 319             {
 320                 while(len--)
 321                 {
 322                     *addrl ^= bit;
 323                     e += e1;
 324                     if (e >= 0)
 325                     {
 326                         mfbScanlineInc(addrl, yinc);
 327                         e += e3;
 328                     }
 329                     bit = SCRLEFT(bit,1);
 330                     if (!bit) { bit = rightbit;addrl --; }
 331                 }
 332             }
 333         } /* if X_AXIS */
 334         else
 335         {
 336             if (signdx > 0)
 337             {
 338                 while(len--)
 339                 {
 340                     *addrl ^= bit;
 341                     e += e1;
 342                     if (e >= 0)
 343                     {
 344                         bit = SCRRIGHT(bit,1);
 345                         if (!bit) { bit = leftbit;addrl ++; }
 346                         e += e3;
 347                     }
 348                     mfbScanlineInc(addrl, yinc);
 349                 }
 350             }
 351             else
 352             {
 353                 while(len--)
 354                 {
 355                     *addrl ^= bit;
 356                     e += e1;
 357                     if (e >= 0)
 358                     {
 359                         bit = SCRLEFT(bit,1);
 360                         if (!bit) { bit = rightbit; addrl --; }
 361                         e += e3;
 362                     }
 363                     mfbScanlineInc(addrl, yinc);
 364                 }
 365             }
 366         } /* else Y_AXIS */
 367     }
 368 }