#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pcx.h>

static RGB egapal[16] = {
   {0, 0, 0}, {0, 0, 170}, {0, 170, 0}, {0, 170, 170},
   {170, 0, 0}, {170, 0, 170}, {170, 85, 0}, {170, 170, 170},
   {85, 85, 85}, {85, 85, 255}, {85, 255, 85}, {85, 255, 255},
   {255, 85, 85}, {255, 85, 255}, {255, 255, 85}, {255, 255, 255}
};

static RGB monopal[2] = {{0, 0, 0}, {255, 255, 255}};


static void planes_to_pixels(unsigned char *pixels, unsigned char *bitplanes,
       int bytesperline, int planes, int bitsperpixel)
{
   int i, j;
   int npixels;
   unsigned char *p;

   /* truecolor */
   if (bitsperpixel == 8) {
       unsigned char *bp = bitplanes;
       for (i = 0; i < 3; i++) {
           p = pixels + i;
           for (j = 0; j < bytesperline; j++, p += 3)
               *p = *(bp++);
       }
       return;
   }

  /* clear the pixel buffer */
   npixels = (bytesperline * 8) / bitsperpixel;
   p = pixels;
   while (--npixels >= 0)
       *p++ = 0;

  /* do the format conversion */
   for (i = 0; i < planes; i++) {
       int pixbit, bits, mask;

       p = pixels;
       pixbit = (1 << i);
       for (j = 0; j < bytesperline; j++) {
           bits = *bitplanes++;
           for (mask = 0x80; mask != 0; mask >>= 1, p++) {
               if (bits & mask)
                   *p |= pixbit;
           }
       }
   }
}

static void unpack_pixels(unsigned char *pixels, unsigned char *bitplanes,
       int bytesperline, int bitsperpixel)
{
   register int bits;

   if (bitsperpixel == 8) {
       while (--bytesperline >= 0)
           *pixels++ = *bitplanes++;
   } else if (bitsperpixel == 4) {
       while (--bytesperline >= 0) {
           bits = *bitplanes++;
           *pixels++ = (bits >> 4) & 0x0f;
           *pixels++ = bits & 0x0f;
       }
   } else if (bitsperpixel == 2) {
       while (--bytesperline >= 0) {
           bits = *bitplanes++;
           *pixels++ = (bits >> 6) & 0x03;
           *pixels++ = (bits >> 4) & 0x03;
           *pixels++ = (bits >> 2) & 0x03;
           *pixels++ = bits & 0x03;
       }
   } else if (bitsperpixel == 1) {
       while (--bytesperline >= 0) {
           bits = *bitplanes++;
           *pixels++ = ((bits & 0x80) != 0);
           *pixels++ = ((bits & 0x40) != 0);
           *pixels++ = ((bits & 0x20) != 0);
           *pixels++ = ((bits & 0x10) != 0);
           *pixels++ = ((bits & 0x08) != 0);
           *pixels++ = ((bits & 0x04) != 0);
           *pixels++ = ((bits & 0x02) != 0);
           *pixels++ = ((bits & 0x01) != 0);
       }
   }
}

static unsigned char *read_image(FILE *fp, int totbytes)
{
   unsigned char *buf, *bp;
   int c, count;

   buf = bp = (unsigned char *)malloc(totbytes);

   while (totbytes > 0) {
       if ((c = getc(fp)) == EOF) {
           fprintf(stderr, "Premature end of file\n");
           return NULL;
       }
       if ((c & 0xc0) != 0xc0) {
           *(bp++) = c;
            --totbytes;
           continue;
       }
       count = c & 0x3f;
       if ((c = getc(fp)) == EOF) {
           fprintf(stderr, "Premature end of file\n");
           return NULL;
       }
       if (count > totbytes) {
           fprintf(stderr, "Repeat count spans end of image, "
                   "count = %d, totbytes = %d\n", count, totbytes);
           return NULL;
       }
       totbytes -= count;
       while (--count >= 0)
           *(bp++) = c;
   }

   return buf;
}

RGB *read_pcx(char *filename, int *width, int *height)
{
   FILE *f;
   PCXHDR hdr;
   int w, h;
   RGB pal256[256], *pal = NULL;
   int truecolor = 0;
   unsigned char *image = NULL, *pixels = NULL;
   int linebytes;
   RGB *buf = NULL, *bp;
   int x, y;

   if (! (f = fopen(filename,"r")))
       return (0);

   if (fread(&hdr, 1, sizeof(PCXHDR), f) < sizeof(PCXHDR)) {
       fprintf(stderr, "Premature end of file\n");
       goto err;
   }

   switch (hdr.bitsperpixel) {
       case 1:
           if (hdr.planes > 4)
               goto fail;
           break;
       case 2:
       case 4:
           if (hdr.planes != 1)
               goto fail;
           break;
       case 8:
           if (hdr.planes != 1) {
               if (hdr.planes == 3 || hdr.planes == 4)
                   truecolor++;
               else
                   goto fail;
           }
           break;
       default:
          fail:
           fprintf(stderr, "Can't handle %d bits per pixel image with "
                   "%d planes\n", hdr.bitsperpixel, hdr.planes);
           goto err;
   }

   if (! truecolor) {
       if (hdr.bitsperpixel == 8) {
           fseek(f, -(sizeof(pal256) + 1), SEEK_END);
           if (getc(f) != 0x0c) {
               fprintf(stderr, "Bad color map signature\n");
               goto err;
           }
           fread(pal256, 1, sizeof(pal256), f);
           fseek(f, sizeof(PCXHDR), SEEK_SET);
           pal = pal256;
       } else {
           pal = (hdr.bitsperpixel == 1 && hdr.planes == 1 ? monopal :
                   (hdr.version == 0 || hdr.version == 3 ? egapal :
                   hdr.palette));
       }
   }

   w = (hdr.xmax - hdr.xmin) + 1; h = (hdr.ymax - hdr.ymin) + 1;

   linebytes = hdr.bytesperline * hdr.planes;

   if (! (image = read_image(f, linebytes * h)))
       goto err;

   buf = bp = (RGB *)malloc(w * sizeof(RGB) * h);

   pixels = (unsigned char *)malloc(truecolor ? hdr.bytesperline * 3 :
           hdr.bytesperline * 8 / hdr.bitsperpixel);

   for (y = 0; y < h; y++) {
       if (hdr.planes == 1)
           unpack_pixels(pixels, image + y * linebytes, hdr.bytesperline,
                   hdr.bitsperpixel);
       else
           planes_to_pixels(pixels, image + y * linebytes, hdr.bytesperline,
                   hdr.planes, hdr.bitsperpixel);
       if (truecolor) {
           RGB *p = (RGB *)pixels;
           for (x = 0; x < w; x++)
               *(bp++) = *(p++);
       } else {
           for (x = 0; x < w; x++)
               *(bp++) = pal[pixels[x]];
       }
   }

   *width = w; *height = h;

err:
   if (image) free(image);
   if (pixels) free(pixels);
   fclose(f);
   return buf;
}

You are viewing proxied material from bitreich.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.