#include "ztypes.h"
#include "pb_console.h"
#include <Quickdraw.h>
#include <QDOffscreen.h>

#define MAX_BIT 512 /* Must be less than or equal to CODE_TABLE_SIZE */
#define CODE_SIZE 8
#define CODE_TABLE_SIZE 4096
#define PREFIX 0
#define PIXEL 1
#define RED 0
#define GREEN 1
#define BLUE 2
#define CURRENT_VERSION "GIF87a"
#define HASH_SIZE 8192
#define HUFFMAN_FLAG 2                  /* flags */
#define HUFFMAN_ONEDICT 4               /* flags: One huffman dictionary?  Only Shogun has more */
#define TRANSPARENCY_FLAG 2             /* flags */
#define NOT_COLOR_DOUBLE 8  /* flags */
#define hashfunc(a, b) ((long) ((long) (a) + (long) (b)) % HASH_SIZE)

int unpack_image(unsigned char *in, unsigned char *out, int width, long numcodes, size_t booga);
void get_huffman_dictionary(void);

static short mask[16] = {
   0x0000, 0x0001, 0x0003, 0x0007,
   0x000f, 0x001f, 0x003f, 0x007f,
   0x00ff, 0x01ff, 0x03ff, 0x07ff,
   0x0fff, 0x1fff, 0x3fff, 0x7fff
};


typedef struct image_s {
   short width;
   short height;
   short colours;
   long pixels;
   unsigned char *image;
   unsigned char (*colourmap)[3];
} image_t;

typedef struct compress_s {
   short next_code;
   short slen;
   short sptr;
   short tlen;
   short tptr;
} compress_t;

typedef struct nlist_s {
   struct nlist *next;
   short prefix;
   short pixel;
   short code;
} nlist_t;

typedef struct header_s {
   unsigned char part;
   unsigned char flags;
   unsigned short unknown1;
   unsigned short images;
   unsigned short unknown2;
   unsigned char dir_size;
   unsigned char unknown3;
   unsigned short checksum;
   unsigned short unknown4;
   unsigned short version;
} header_t;

typedef unsigned char color_t[3];

typedef struct colormap_s {
       unsigned char num_colors;
       color_t table[1];
} colormap_t;

typedef struct pdirectory_s {
   short image_number;
   short image_width;
   short image_height;
   short image_flags;
   long image_data_addr;
   long image_cm_addr;
       short huffman_dict_addr;
} pdirectory_t;

static colormap_t *get_color_table(FILE *fp, pdirectory_t *directory);
static void *get_image (FILE *, pdirectory_t *);
static void decompress_image (FILE *, image_t *);
static short read_code (FILE *, compress_t *);

static header_t picfile_header;
static int max_pic_index;
static int *pic_index;
static pdirectory_t *picture_directory = NULL;
static short code_table[CODE_TABLE_SIZE][2];
static unsigned char buffer[CODE_TABLE_SIZE];
static unsigned char code_buffer[CODE_TABLE_SIZE];
static signed short *huffman_dictionary = NULL;
static FILE *picfile;

#if defined(__STDC__)
static unsigned char read_byte (FILE *fp)
#else
static unsigned char read_byte (fp)
FILE *fp;
#endif
{
   int c;

   if ((c = fgetc (fp)) == EOF) {
       perror ("fgetc");
       exit (EXIT_FAILURE);
   }

   return ((unsigned char) c);

}/* read_byte */

#if defined(__STDC__)
static unsigned short read_word (FILE *fp)
#else
static unsigned short read_word (fp)
FILE *fp;
#endif
{
   unsigned short w;

   w = (unsigned short) read_byte (fp) << 8;
   w += (unsigned short) read_byte (fp) ;

   return (w);

}/* read_word */


#if defined(__STDC__)
int read_picture_data (void)
#else
int read_picture_data ()
#endif
{
   int i;
   char linebuf[80];
   FILE *fp;
       long dir_pos;

   if ((fp = fopen ("CPIC.DATA", "rb")) == NULL) {
       fatal ("Couldn't open picture file");
   }

   picfile_header.part = read_byte (fp);
   picfile_header.flags = read_byte (fp);
   picfile_header.unknown1 = read_word (fp);
   picfile_header.images = read_word (fp);
   picfile_header.unknown2 = read_word (fp);
   picfile_header.dir_size = read_byte (fp);
   picfile_header.unknown3 = read_byte (fp);
   picfile_header.checksum = read_word (fp);
   picfile_header.unknown4 = read_word (fp);
   picfile_header.version = read_word (fp);

   sprintf (linebuf, "Total number of images = %d", (int) picfile_header.images);
#ifdef V6_DEBUG
   output_string(linebuf);
   new_line();
#endif
   if ((picture_directory = (pdirectory_t *) NewPtr (picfile_header.images * sizeof (pdirectory_t))) == NULL) {
       fatal("Insufficient memory\n");
   }
       dir_pos = ftell(fp);

       max_pic_index = 0;
       for (i = 0; (unsigned int) i < picfile_header.images; i++) {
       picture_directory[i].image_number = read_word (fp);
       if (picture_directory[i].image_number > max_pic_index) {
               max_pic_index = picture_directory[i].image_number;
       }
       picture_directory[i].image_width = read_word (fp);
       picture_directory[i].image_height = read_word (fp);
       picture_directory[i].image_flags = read_word (fp);
       picture_directory[i].image_data_addr = (unsigned long) read_byte (fp) << 16;
       picture_directory[i].image_data_addr += (unsigned long) read_byte (fp) << 8;
       picture_directory[i].image_data_addr += (unsigned long) read_byte (fp);
       if (picfile_header.dir_size >= 14) {
           picture_directory[i].image_cm_addr = (unsigned long) read_byte (fp) << 16;
           picture_directory[i].image_cm_addr += (unsigned long) read_byte (fp) << 8;
           picture_directory[i].image_cm_addr += (unsigned long) read_byte (fp);
       } else {
           picture_directory[i].image_cm_addr = 0;
           /* (void) read_byte (fp); */
       }
       if (picfile_header.dir_size >= 16) {
                       picture_directory[i].huffman_dict_addr = read_word(fp);
               }
               fseek(fp,dir_pos += picfile_header.dir_size,SEEK_SET);
   }

   picfile = fp;
       if (picfile_header.flags & HUFFMAN_ONEDICT)
               get_huffman_dictionary();

       pic_index = (void *)NewPtr((max_pic_index + 1) * sizeof(int));
       memset(pic_index, 0xFF, (max_pic_index + 1) * sizeof(int));
       for (i = 0; (unsigned int) i < picfile_header.images; i++) {
               pic_index[picture_directory[i].image_number] = i;
       }
   return (0);

}/* read_picture_data */


void get_huffman_dictionary()
{
       unsigned long fpos;
       int maxentry, curentry;
       short entry;
       short *entryptr;

       fpos = ftell(picfile);
       maxentry = 1;
       curentry = 0;
       while (curentry++ <= maxentry) {
               entry = (signed char)read_byte(picfile);
               if (entry > 0) {
                       maxentry = MAX(maxentry,entry + entry + 1);
               }
       }
       fseek(picfile, fpos, SEEK_SET);
       if (huffman_dictionary)
               DisposPtr((Ptr)huffman_dictionary);
       entryptr = huffman_dictionary = (void *)NewPtr(sizeof(short) * (maxentry+1));
       while (maxentry-- >= 0) {
               *entryptr++ = (signed char)read_byte(picfile);
       }
}

get_num_pictures(void)
{
       return max_pic_index;
} /* get_num_pictures */

int get_picture_size(zword_t picture_number, zword_t *w, zword_t *h)
{
       int picture_sequence;

       if (picture_directory == NULL)
               read_picture_data();

       if ((picture_number <= max_pic_index) &&
               ((picture_sequence = pic_index[picture_number]) != -1)) {

               if (picture_directory[picture_sequence].image_number != picture_number)
                       DebugStr("\pMisindexed pictures");
               *w = picture_directory[picture_sequence].image_width;
               *h = picture_directory[picture_sequence].image_height;
               if (!(picture_directory[picture_sequence].image_flags&NOT_COLOR_DOUBLE)) {
                       *w <<= 1;
                       *h <<= 1;
               }
       }
       else {
               return FALSE;
       }
       return TRUE;
} /* get_picture_size */

RgnHandle pixmaptorgn(unsigned char *pixmap, int width, int height)
/* constructs a region containing the non-zero areas in the pixmap */
/* The region originates at 0,0 */
{
       unsigned char *row;
       unsigned char *rowflags;
       unsigned char current = 0;
       unsigned char row_num_flag;
       unsigned char emptyflag = 1;
       RgnHandle outputrgn;
       RgnPtr rgnptr;
       unsigned short *curptr;
       int i,j;
       int rgnleft, rgnright, rgntop, rgnbottom;

#define OUTPUT(w) { \
       if (((unsigned long)curptr - (unsigned long)rgnptr) == rgnptr->rgnSize) { \
               HUnlock((Handle)outputrgn); \
               SetHandleSize((Handle)outputrgn, rgnptr->rgnSize + 1024L); \
               HLock((Handle)outputrgn); \
               rgnptr = *outputrgn; \
               curptr = (unsigned short *)((unsigned long)rgnptr + rgnptr->rgnSize); \
               rgnptr->rgnSize += 1024L; \
       } \
       *curptr++ = w; \
}
       row = pixmap;
       rowflags = (unsigned char *)NewPtrClear((size_t)width + 1);

       outputrgn = (RgnHandle)NewHandle(sizeof(Region));
       HLock((Handle)outputrgn);
       rgnptr = *outputrgn;
       rgnptr->rgnBBox.top = 0;
       rgnptr->rgnBBox.left = 0;
       rgnptr->rgnBBox.bottom = height;
       rgnptr->rgnBBox.right = width;
       rgnleft = width;
       rgnright = 0;
       rgntop = height;
       rgnbottom = 0;
       rgnptr->rgnSize = sizeof(Region);
       curptr = (unsigned short *)(rgnptr+1);
       for (j = 0; j <= height; j++) {
               row_num_flag = 0;
               for (i = 0; i <= width; i++) {
                       if (rowflags[i])
                               current = !current;
                       if ((((j == height) || (i == width))?0:(row[i]!=0)) != (current != 0)) {
                               if (!row_num_flag) {
                                       OUTPUT(j);
                                       row_num_flag = 1;
                                       emptyflag = 0;
                               }
                               OUTPUT(i);
                               if (i > rgnright) rgnright = i;
                               if (i < rgnleft) rgnleft = i;
                               if (j < rgntop) rgntop = j;
                               if (j > rgnbottom) rgnbottom = j;
                               current = !current;
                               rowflags[i] = !rowflags[i];
                       }
               }
               if (row_num_flag)
                       OUTPUT(0x7FFF);
               row += width;
       }

       if (!emptyflag) {
               OUTPUT(0x7FFF);
               rgnptr->rgnBBox.top = rgntop;
               rgnptr->rgnBBox.left = rgnleft;
               rgnptr->rgnBBox.bottom = rgnbottom;
               rgnptr->rgnBBox.right = rgnright;
       }
       DisposPtr((Ptr)rowflags);
       rgnptr->rgnSize = ((unsigned long)curptr - (unsigned long)rgnptr);
       SetHandleSize((Handle)outputrgn, (size_t)rgnptr->rgnSize);
       HUnlock((Handle)outputrgn);
       return outputrgn;
#undef OUTPUT
}

void os_draw_picture(x, y, n, reverse)
int x,y,n;
{
       zword_t w,h;
       int i,j,err;
       Rect r;
       BitMap bm;
       GrafPtr saveport;
       PenState p;
       RgnHandle rgn;
       RGBColor saved_fg, saved_bg;
       PixMapHandle mypmh;
   unsigned char *mypixels, *ipixels, *image;
       unsigned long rowbytes;
       GWorldPtr mygworld;
       CTabHandle myctab;
       colormap_t *colormap;
       RgnHandle maskrgn;

       w = picture_directory[pic_index[n]].image_width;
       h = picture_directory[pic_index[n]].image_height;
       r.left = x - 1 ;
       r.right = x - 1 + w;
       r.top = y - 1;
       r.bottom = y - 1 + h;
       GetPort(&saveport);
       SetPort(FrontWindow());
       bm.bounds = r;
       ipixels = image = get_image(picfile, &picture_directory[pic_index[n]]);
       bm.rowBytes = ((w+15)>>3)&~1;

#if 1
       maskrgn = pixmaptorgn(ipixels, w, h);
#else
       maskrgn = NewRgn();
       SetRectRgn(maskrgn, 0, 0, w, h);
#endif
       OffsetRgn(maskrgn, r.left, r.top);
       if (picfile_header.flags&NOT_COLOR_DOUBLE){
               bm.baseAddr = (void *)NewPtrClear(bm.rowBytes * (long)h);
           for (i = 0, mypixels = (unsigned char *)bm.baseAddr; i < h; i++, ipixels+=w, mypixels+=bm.rowBytes) {
                       for (j = 0; j < w; j++)
                               mypixels[j/8] |= (ipixels[j]&1) << (7-(j&7));
           }
       }
       else {
               colormap = get_color_table(picfile, &picture_directory[pic_index[n]]);

               if (colormap != NULL) {
                       myctab = (CTabHandle)NewHandleClear(sizeof(ColorTable) + sizeof(CSpecArray)*(colormap->num_colors+1));
                       (**myctab).ctSeed = GetCTSeed();
                       (**myctab).ctSize = colormap->num_colors + 1;
                       (**myctab).ctFlags |= 0x8000;
                       (**myctab).ctTable[0].rgb.red   =   0xFFFF;
                       (**myctab).ctTable[0].rgb.green =   0xFFFF;
                       (**myctab).ctTable[0].rgb.blue  =   0xFFFF;
                       (**myctab).ctTable[1].rgb.red   =   0;
                       (**myctab).ctTable[1].rgb.green =   0;
                       (**myctab).ctTable[1].rgb.blue  =   0;
                       for (i = 2; i < (colormap->num_colors + 2); i++) {
                               (**myctab).ctTable[i].rgb.red   =   colormap->table[i-2][RED]<<8;
                               (**myctab).ctTable[i].rgb.green =   colormap->table[i-2][GREEN]<<8;
                               (**myctab).ctTable[i].rgb.blue  =   colormap->table[i-2][BLUE]<<8;
                       }
                       DisposPtr((Ptr)colormap);
               }
               else {
                       myctab = NULL;
               }

               err = NewGWorld(&mygworld, 8, &r, myctab /*CTable*/,
               /*GDevice*/NULL, keepLocal|useTempMem);

           DisposHandle((Handle)myctab);
           mypmh = GetGWorldPixMap(mygworld);
               LockPixels(mypmh);
               rowbytes = (**mypmh).rowBytes&0x3FFF;
           mypixels = (unsigned char *)GetPixBaseAddr(mypmh);

           for (i = 0; i < h; i++, ipixels+=w, mypixels+=rowbytes) {
                       memcpy(mypixels, ipixels, w);
           }
       }
   DisposPtr((Ptr)image);
       get_picture_size(n, &w, &h); /* this takes any doubling into account.  Who made up this stuff? */
       r.left = x - 1 ;
       r.right = x - 1 + w;
       r.top = y - 1;
       r.bottom = y - 1 + h;


   GetForeColor(&saved_fg);
   GetBackColor(&saved_bg);
   ForeColor(blackColor);
   BackColor(whiteColor);
       OffsetRect(&r, BORDER, BORDER);
       MapRgn(maskrgn, &bm.bounds, &r);
       if (picfile_header.flags&NOT_COLOR_DOUBLE){
               CopyBits(&bm, &qd.thePort->portBits, &bm.bounds, &r, srcCopy, maskrgn);
       }
       else {
               CopyBits((BitMap *)*mypmh, &qd.thePort->portBits, &bm.bounds, &r, srcCopy, maskrgn);
       }
       ValidRect(&r);
#if 0
       GetPenState(&p);
       PenMode(patCopy);
       rgn = NewRgn();
       RectRgn(rgn, &r);
       FillRgn(rgn, qd.gray);
       FrameRgn(rgn);
       DisposeRgn(rgn);
       SetPenState(&p);
#endif
   RGBForeColor(&saved_fg);
   RGBBackColor(&saved_bg);
       DisposeHandle((Handle)maskrgn);
       if (picfile_header.flags&NOT_COLOR_DOUBLE) {
               DisposPtr(bm.baseAddr);
       }
       else {
               UnlockPixels(mypmh);
               DisposeGWorld(mygworld);
       }
       SetPort(saveport);
}

void os_erase_picture(x, y, n)
int x,y,n;
{
       zword_t w,h;
       Rect r;
       GrafPtr saveport;
       PenState p;

       get_picture_size(n, &w, &h);
       r.left = x - 1 ;
       r.right = x - 1 + w;
       r.top = y - 1;
       r.bottom = y - 1 + h;
       GetPort(&saveport);
       SetPort(FrontWindow());
       GetPenState(&p);
       PenMode(patCopy);
       OffsetRect(&r, BORDER, BORDER);
       EraseRect(&r);
       SetPenState(&p);
       SetPort(saveport);
}

#if defined(__STDC__)
static colormap_t *get_color_table(FILE *fp, pdirectory_t *directory)
#else
static colormap_t *get_color_table (fp, directory)
FILE *fp;
pdirectory_t *directory;
#endif
{
       colormap_t *result = NULL;
       unsigned char num_colors;
       int i;
       static unsigned char last_colourmap[16][3] = {
                 0,  0,  0,
                 0,  0,170,
                 0,170,  0,
                 0,170,170,
               170,  0,  0,
               170,  0,170,
               170,170,  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
       };

       num_colors=0;
       if (directory->image_cm_addr) {
       if (fseek (fp, directory->image_cm_addr, SEEK_SET) != 0) {
           perror ("fseek");
           exit (EXIT_FAILURE);
       }
       num_colors = read_byte (fp);
   }
       result = (void *)NewPtr(sizeof(colormap_t) + (sizeof(color_t) * ((short)MAX(num_colors,16) - 1)));
   for (i = 0; i < num_colors; i++) {
               result->table[i][RED] = read_byte (fp);
       result->table[i][GREEN] = read_byte (fp);
       result->table[i][BLUE] = read_byte (fp);
       if (i < 16) {
               last_colourmap[i][RED] = result->table[i][RED];
               last_colourmap[i][GREEN] = result->table[i][GREEN];
               last_colourmap[i][BLUE] = result->table[i][BLUE];
       }
       }
       for (i = num_colors; i < 16; i++) {
       result->table[i][RED] = last_colourmap[i][RED];
       result->table[i][GREEN] = last_colourmap[i][GREEN];
       result->table[i][BLUE] = last_colourmap[i][BLUE];
   }
   result->num_colors = (num_colors<16)?16:num_colors;
   return result;
}

#if defined(__STDC__)
static void *get_image (FILE *fp, pdirectory_t *directory)
#else
static void *get_image (fp, directory)
FILE *fp;
pdirectory_t *directory;
#endif
{
   int colours = 18, i;
   image_t image;
   unsigned long image_compsize, image_numcodes;
   char *comp_image;

#if 0
   for (i = 0; i < 32; i++) {
       colourmap[i][RED] = ega_colourmap[i][RED];
       colourmap[i][GREEN] = ega_colourmap[i][GREEN];
       colourmap[i][BLUE] = ega_colourmap[i][BLUE];
   }
   if (directory->image_cm_addr) {
       if (fseek (fp, directory->image_cm_addr, SEEK_SET) != 0) {
           perror ("fseek");
           exit (EXIT_FAILURE);
       }
       colours = read_byte (fp);
       read_bytes (fp, colours * 3, &colourmap[2][RED]);
       colours += 2;
   }

#endif
/*    fprintf (stderr, "Number = %5d, width = %5d, height = %5d, flags = %4x, colourmap = %6ld, data = %6ld, colours = %2d\n",
           (int) directory->image_number, (int) directory->image_width, (int) directory->image_height,
           (int) directory->image_flags, directory->image_cm_addr, directory->image_data_addr, colours);
*/
   if (directory->image_data_addr == 0)
       return;

   image.width = directory->image_width;
   image.height = directory->image_height;
   image.colours = colours;
   image.pixels = 0;
   if ((image.image = (unsigned char *) NewPtr ((size_t)directory->image_width * directory->image_height)) == NULL) {
       fprintf (stderr, "Insufficient memory\n");
       exit (EXIT_FAILURE);
   }
#if 0
   image.colourmap = colourmap;
#endif


       if (directory->image_flags & HUFFMAN_FLAG) {
               if (!(picfile_header.flags & HUFFMAN_ONEDICT)) {
               if (fseek (fp, 2L * directory->huffman_dict_addr, SEEK_SET) != 0) {
                   perror ("fseek");
                               exit (EXIT_FAILURE);
                       }
                       get_huffman_dictionary();
               }
           if (fseek (fp, directory->image_data_addr, SEEK_SET) != 0) {
               perror ("fseek");
               exit (EXIT_FAILURE);
           }
           if (fseek (fp, directory->image_data_addr, SEEK_SET) != 0) {
               perror ("fseek");
               exit (EXIT_FAILURE);
           }
               image_compsize = 0;
               image_numcodes = 0;
               fread((char *)&image_compsize + 1, 3, 1, fp);
               fread((char *)&image_numcodes + 1, 3, 1, fp);
               comp_image = (void *)NewPtr(image_compsize);
               fread((char *)comp_image, 1, image_compsize, fp);

               unpack_image((unsigned char *)comp_image, (unsigned char *)image.image,
                                               directory->image_width, image_numcodes, (size_t)directory->image_width * directory->image_height);
       /*    decompress_image (fp, &image);*/
               DisposPtr((Ptr)comp_image);
       }
   return (image.image);

}/* get image */

#define GETBIT(b,p) ((((unsigned char *)(p))[(b)>>3])&(1<<(7-((b)&7))))
unpack_image(unsigned char *in, unsigned char *out, int width, long numcodes, size_t booga)
{
       unsigned long bit=0;
       signed char entry, temp;
       signed char state = 0;
       char *lines, *lastptr, *curptr;

       lines = (void *)NewPtrClear(2 * width);
       lastptr = lines;
       curptr = lines+width;
       entry = 0;
       do {
               if (GETBIT(bit, in))
                       entry++;
               entry = huffman_dictionary[((unsigned char)entry)];
               if (entry >= 0) {
                       entry += entry;
               }
               else {
                       entry -= 0x90;
                       if (entry < 0) {
                               entry += 0x10;
                               /* here's the wierd XOR with entry */
                               temp = entry ^ *lastptr++;
                               *out++ = temp;
                               *curptr++ = temp;
                               if (lastptr == lines+width) {
                                       lastptr = lines;
                                       curptr = lines+width;
                                       memcpy(lastptr, curptr, width);
                               }
                               state = entry;
                       }
                       else {
                               do {
                               /* here's the wierd XOR with state */
                                       temp = state ^ *lastptr++;
                                       *curptr++ = temp;
                                       *out++ = temp;
                                       if (lastptr == lines+width) {
                                               lastptr = lines;
                                               curptr = lines+width;
                                               memcpy(lastptr, curptr, width);
                                       }
                               } while (--entry != -1);
                       }
                       entry = 0;
                       numcodes--;
               }
               bit++;
       }
       while (numcodes > 0);
       DisposPtr((Ptr)lines);
}

#if defined(__STDC__)
static void decompress_image (FILE *fp, image_t *image)
#else
static void decompress_image (fp, image)
FILE *fp;
image_t *image;
#endif
{
   int i;
   short code, old = 0, first, clear_code;
   compress_t comp;

   clear_code = 1 << CODE_SIZE;
   comp.next_code = clear_code + 2;
   comp.slen = 0;
   comp.sptr = 0;
   comp.tlen = CODE_SIZE + 1;
   comp.tptr = 0;

   for (i = 0; i < CODE_TABLE_SIZE; i++) {
       code_table[i][PREFIX] = CODE_TABLE_SIZE;
       code_table[i][PIXEL] = i;
   }

   for (;;) {
       if ((code = read_code (fp, &comp)) == (clear_code + 1))
           return;
       if (code == clear_code) {
           comp.tlen = CODE_SIZE + 1;
           comp.next_code = clear_code + 2;
           code = read_code (fp, &comp);
       } else {
           first = (code == comp.next_code) ? old : code;
           while (code_table[first][PREFIX] != CODE_TABLE_SIZE)
               first = code_table[first][PREFIX];
           code_table[comp.next_code][PREFIX] = old;
           code_table[comp.next_code++][PIXEL] = code_table[first][PIXEL];
       }
       old = code;
       i = 0;
       do
           buffer[i++] = (unsigned char) code_table[code][PIXEL];
       while ((code = code_table[code][PREFIX]) != CODE_TABLE_SIZE);
       do
           image->image[image->pixels++] = buffer[--i];
       while (i > 0);
   }

}/* decompress_image */

#if defined(__STDC__)
static short read_code (FILE *fp, compress_t *comp)
#else
static short read_code (fp, comp)
FILE *fp;
compress_t *comp;
#endif
{
   short code, bsize, tlen, tptr;
   int i;
   short sw;

   code = 0;
   tlen = comp->tlen;
   tptr = 0;

   while (tlen) {
       if (comp->slen == 0) {
           if ((comp->slen = fread (code_buffer, 1, MAX_BIT, fp)) == 0) {
               perror ("fread");
               exit (EXIT_FAILURE);
           }
           comp->slen *= 8;
           comp->sptr = 0;
       }
       bsize = ((comp->sptr + 8) & ~7) - comp->sptr;
       bsize = (tlen > bsize) ? bsize : tlen;
       code |= ((code_buffer[comp->sptr >> 3] >> (comp->sptr & 7)) & mask[bsize]) << tptr;

       tlen -= bsize;
       tptr += bsize;
       comp->slen -= bsize;
       comp->sptr += bsize;
   }
   if ((comp->next_code == mask[comp->tlen]) && (comp->tlen < 12))
       comp->tlen++;

   return (code);

}/* read_code */

You are viewing proxied material from mercury.661.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.