driver/pack.c

   1 /*
   2  * "$Id$"
   3  *
   4  *   Bit packing routines for CUPS.
   5  *
   6  *   Copyright 2007 by Apple Inc.
   7  *   Copyright 1993-2005 by Easy Software Products.
   8  *
   9  *   These coded instructions, statements, and computer programs are the
  10  *   property of Apple Inc. and are protected by Federal copyright
  11  *   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  12  *   which should have been included with this file.  If this file is
  13  *   file is missing or damaged, see the license at "http://www.cups.org/".
  14  *
  15  * Contents:
  16  *
  17  *   cupsPackHorizontal()    - Pack pixels horizontally...
  18  *   cupsPackHorizontal2()   - Pack 2-bit pixels horizontally...
  19  *   cupsPackHorizontalBit() - Pack pixels horizontally by bit...
  20  *   cupsPackVertical()      - Pack pixels vertically...
  21  */
  22
  23 /*
  24  * Include necessary headers...
  25  */
  26
  27 #include "driver.h"
  28
  29
  30 /*
  31  * 'cupsPackHorizontal()' - Pack pixels horizontally...
  32  */
  33
  34 void
  35 cupsPackHorizontal(const unsigned char *ipixels,/* I - Input pixels */
  36                    unsigned char       *obytes, /* O - Output bytes */
  37                    int                 width,   /* I - Number of pixels */
  38                    const unsigned char clearto, /* I - Initial value of bytes */
  39                    const int           step)    /* I - Step value between pixels */
  40 {
  41   register unsigned char        b;              /* Current byte */
  42
  43
  44  /*
  45   * Do whole bytes first...
  46   */
  47
  48   while (width > 7)
  49   {
  50     b = clearto;
  51
  52     if (*ipixels)
  53       b ^= 0x80;
  54     ipixels += step;
  55     if (*ipixels)
  56       b ^= 0x40;
  57     ipixels += step;
  58     if (*ipixels)
  59       b ^= 0x20;
  60     ipixels += step;
  61     if (*ipixels)
  62       b ^= 0x10;
  63     ipixels += step;
  64     if (*ipixels)
  65       b ^= 0x08;
  66     ipixels += step;
  67     if (*ipixels)
  68       b ^= 0x04;
  69     ipixels += step;
  70     if (*ipixels)
  71       b ^= 0x02;
  72     ipixels += step;
  73     if (*ipixels)
  74       b ^= 0x01;
  75     ipixels += step;
  76
  77     *obytes++ = b;
  78
  79     width -= 8;
  80   }
  81
  82  /*
  83   * Then do the last N bytes (N < 8)...
  84   */
  85
  86   b = clearto;
  87
  88   switch (width)
  89   {
  90     case 7 :
  91         if (ipixels[6 * step])
  92           b ^= 0x02;
  93     case 6 :
  94         if (ipixels[5 * step])
  95           b ^= 0x04;
  96     case 5 :
  97         if (ipixels[4 * step])
  98           b ^= 0x08;
  99     case 4 :
 100         if (ipixels[3 * step])
 101           b ^= 0x10;
 102     case 3 :
 103         if (ipixels[2 * step])
 104           b ^= 0x20;
 105     case 2 :
 106         if (ipixels[1 * step])
 107           b ^= 0x40;
 108     case 1 :
 109         if (ipixels[0])
 110           b ^= 0x80;
 111         *obytes = b;
 112         break;
 113   }
 114 }
 115
 116
 117 /*
 118  * 'cupsPackHorizontal2()' - Pack 2-bit pixels horizontally...
 119  */
 120
 121 void
 122 cupsPackHorizontal2(const unsigned char *ipixels,       /* I - Input pixels */
 123                     unsigned char       *obytes,        /* O - Output bytes */
 124                     int                 width,          /* I - Number of pixels */
 125                     const int           step)           /* I - Stepping value */
 126 {
 127   register unsigned char        b;                      /* Current byte */
 128
 129
 130  /*
 131   * Do whole bytes first...
 132   */
 133
 134   while (width > 3)
 135   {
 136     b = *ipixels;
 137     ipixels += step;
 138     b = (b << 2) | *ipixels;
 139     ipixels += step;
 140     b = (b << 2) | *ipixels;
 141     ipixels += step;
 142     b = (b << 2) | *ipixels;
 143     ipixels += step;
 144
 145     *obytes++ = b;
 146
 147     width -= 4;
 148   }
 149
 150  /*
 151   * Then do the last N bytes (N < 4)...
 152   */
 153
 154   b = 0;
 155
 156   switch (width)
 157   {
 158     case 3 :
 159         b = ipixels[2 * step];
 160     case 2 :
 161         b = (b << 2) | ipixels[step];
 162     case 1 :
 163         b = (b << 2) | ipixels[0];
 164         *obytes = b << (8 - 2 * width);
 165         break;
 166   }
 167 }
 168
 169
 170 /*
 171  * 'cupsPackHorizontalBit()' - Pack pixels horizontally by bit...
 172  */
 173
 174 void
 175 cupsPackHorizontalBit(const unsigned char *ipixels,     /* I - Input pixels */
 176                       unsigned char       *obytes,      /* O - Output bytes */
 177                       int                 width,        /* I - Number of pixels */
 178                       const unsigned char clearto,      /* I - Initial value of bytes */
 179                       const unsigned char bit)          /* I - Bit to check */
 180 {
 181   register unsigned char        b;                      /* Current byte */
 182
 183
 184  /*
 185   * Do whole bytes first...
 186   */
 187
 188   while (width > 7)
 189   {
 190     b = clearto;
 191
 192     if (*ipixels++ & bit)
 193       b ^= 0x80;
 194     if (*ipixels++ & bit)
 195       b ^= 0x40;
 196     if (*ipixels++ & bit)
 197       b ^= 0x20;
 198     if (*ipixels++ & bit)
 199       b ^= 0x10;
 200     if (*ipixels++ & bit)
 201       b ^= 0x08;
 202     if (*ipixels++ & bit)
 203       b ^= 0x04;
 204     if (*ipixels++ & bit)
 205       b ^= 0x02;
 206     if (*ipixels++ & bit)
 207       b ^= 0x01;
 208
 209     *obytes++ = b;
 210
 211     width -= 8;
 212   }
 213
 214  /*
 215   * Then do the last N bytes (N < 8)...
 216   */
 217
 218   b = clearto;
 219
 220   switch (width)
 221   {
 222     case 7 :
 223         if (ipixels[6] & bit)
 224           b ^= 0x02;
 225     case 6 :
 226         if (ipixels[5] & bit)
 227           b ^= 0x04;
 228     case 5 :
 229         if (ipixels[4] & bit)
 230           b ^= 0x08;
 231     case 4 :
 232         if (ipixels[3] & bit)
 233           b ^= 0x10;
 234     case 3 :
 235         if (ipixels[2] & bit)
 236           b ^= 0x20;
 237     case 2 :
 238         if (ipixels[1] & bit)
 239           b ^= 0x40;
 240     case 1 :
 241         if (ipixels[0] & bit)
 242           b ^= 0x80;
 243         *obytes = b;
 244         break;
 245   }
 246 }
 247
 248
 249 /*
 250  * 'cupsPackVertical()' - Pack pixels vertically...
 251  */
 252
 253 void
 254 cupsPackVertical(const unsigned char *ipixels,  /* I - Input pixels */
 255                  unsigned char       *obytes,   /* O - Output bytes */
 256                  int                 width,     /* I - Number of input pixels */
 257                  const unsigned char bit,       /* I - Output bit */
 258                  const int           step)      /* I - Number of bytes between columns */
 259 {
 260  /*
 261   * Loop through the entire array...
 262   */
 263
 264   while (width > 7)
 265   {
 266     if (*ipixels++)
 267       *obytes ^= bit;
 268     obytes += step;
 269     if (*ipixels++)
 270       *obytes ^= bit;
 271     obytes += step;
 272     if (*ipixels++)
 273       *obytes ^= bit;
 274     obytes += step;
 275     if (*ipixels++)
 276       *obytes ^= bit;
 277     obytes += step;
 278     if (*ipixels++)
 279       *obytes ^= bit;
 280     obytes += step;
 281     if (*ipixels++)
 282       *obytes ^= bit;
 283     obytes += step;
 284     if (*ipixels++)
 285       *obytes ^= bit;
 286     obytes += step;
 287     if (*ipixels++)
 288       *obytes ^= bit;
 289     obytes += step;
 290
 291     width -= 8;
 292   }
 293
 294   while (width > 0)
 295   {
 296     if (*ipixels++)
 297       *obytes ^= bit;
 298
 299     obytes += step;
 300     width --;
 301   }
 302 }
 303
 304
 305 /*
 306  * End of "$Id$".
 307  */