GIF.C

Go to the documentation of this file.

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

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif

#ifndef FILE_NAME_LENGTH
#define FILE_NAME_LENGTH 150
#endif

/* Maximum gif bitmap size allowed. */
#define BITMAP_X_SIZE 2048
#define BITMAP_Y_SIZE 2048

#define LOCAL static
#define IMPORT extern
#define FAST register
typedef short SWORD;
typedef unsigned short UWORD;
typedef char TEXT;
typedef unsigned char UTINY;
typedef long LONG;
typedef unsigned long ULONG;
typedef int INT;

typedef struct Colour_Struct COLOUR;
typedef struct Colour_Map_Entry COLOUR_MAP_ENTRY;
typedef struct Colour_Map_Struct COLOUR_MAP;
typedef struct Image_Struct IMAGE;

struct Colour_Struct
   {
   double Red, Green, Blue, Alpha;
   };


struct Colour_Map_Entry
   {
   double start, end;
   COLOUR Start_Colour, End_Colour;
   };


struct Colour_Map_Struct
   {
   int Number_Of_Entries;
   COLOUR_MAP_ENTRY *Colour_Map_Entries;
   };


struct Image_Struct
   {
   double width, height;
   int iwidth, iheight;
   unsigned char *red, *green, *blue;
   };

extern int out_line (unsigned char *pixels, int linelen);
int get_byte (void);

short read_gif_image(char * filename, short palette_only);

LOCAL SWORD init_exp (SWORD size);
LOCAL SWORD get_next_code (void);
LOCAL SWORD decoder (SWORD linewidth);

static FILE *Bit_File;

int colourmap_size,x_size,y_size,gif_iLace;
unsigned  char p_red[256],p_green[256],p_blue[256],*decoderline;


#define READ_ERROR -1

int get_byte(void){
  register int byte;
  if ((byte = getc(Bit_File)) != EOF)return (byte);
  else return -1;
  return 0;
}

short read_gif_image(char *filename, short palette_only){
   IMAGE IM,*Image;
   register int i, j, k,status;
   unsigned finished, planes;
   unsigned char buffer[16];
   Image=&IM;
   status = 0;
   if ((Bit_File = fopen(filename, "rb")) == NULL)return -1;
   /* zero out the full write-line */
   if ((decoderline = (unsigned char *) malloc (2049)) == NULL) {
     fclose (Bit_File);
     return -2;
   }
   for (i = 0; i < 2049; i++) decoderline[i] = (unsigned char) 0;
   /* Get the screen description */
   for (i = 0; i < 13; i++)
      buffer[i] = (unsigned char)get_byte();
   if (strncmp((char *)buffer,"GIF87a",3) ||
       buffer[3] < '0' || buffer[3] > '9' ||
       buffer[4] < '0' || buffer[4] > '9' ||
       buffer[5] < 'A' || buffer[5] > 'z' ) {
     fclose(Bit_File);
     return -3;
   }
   planes = ((unsigned)buffer[10] & 0x0F) + 1;
   colourmap_size = (int)(1 << planes);
   if ((buffer[10] & 0x80) == 0) {    /* color map (better be!) */
     fclose(Bit_File);
     return -4;
   }
   for(i=0;i<colourmap_size;i++){
    p_red[i]=get_byte()>>2;
    p_green[i]=get_byte()>>2;
    p_blue[i]=get_byte()>>2;
   }
 /* Now display one or more GIF objects */
   finished = FALSE;
   while (!finished) {
      switch (get_byte()) {
         case ';':                /* End of the GIF dataset */
            finished = TRUE;
            status = 0;
            break;

         case '!':                /* GIF Extension Block */
            get_byte();           /* read (and ignore) the ID */
            while ((i = get_byte()) > 0) /* get data len*/
            for (j = 0; j < i; j++)
                get_byte(); /* flush data */
            break;

         case ',': /* Start of image object. get description */
            for (i = 0; i < 9; i++) {
               buffer[i] = (unsigned char)get_byte();
            }
            if (status < 0) {
               finished = TRUE;
               break;
               }
            if((buffer[8] & 0x40) == 0x40)gif_iLace=1;
            else                          gif_iLace=0;
            Image->iwidth  = buffer[4] | (buffer[5] << 8);
            Image->iheight = buffer[6] | (buffer[7] << 8);
            Image->width = (double) Image->iwidth;
            Image->height = (double) Image->iheight;
            if (Image->iwidth > BITMAP_X_SIZE ||
                Image->iheight > BITMAP_Y_SIZE) {
               fclose(Bit_File);
               return -5;
            }
            x_size=Image->iwidth;
            y_size=Image->iheight;
            if(palette_only){
              fclose(Bit_File);
              return 1;
            }
            status = decoder((SWORD) Image->iwidth); /*put bytes in Buf*/
            finished = TRUE;
            break;
         default:
            status = -1;
            finished = TRUE;
            break;
         }
      }
   free (decoderline);
   fclose(Bit_File);
   return 0;
}


#define OUT_OF_MEMORY -10
#define BAD_CODE_SIZE -20
#define READ_ERROR -1
#define WRITE_ERROR -2
#define OPEN_ERROR -3
#define CREATE_ERROR -4


INT bad_code_count;

#define MAX_CODES   4095


/* Static variables */
LOCAL SWORD curr_size;                     /* The current code size */
LOCAL SWORD clear;                         /* Value for a clear code */
LOCAL SWORD ending;                        /* Value for a ending code */
LOCAL SWORD newcodes;                      /* First available code */
LOCAL SWORD top_slot;                      /* Highest code for current size */
LOCAL SWORD slot;                          /* Last read code */

LOCAL SWORD navail_bytes = 0;              /* # bytes left in block */
LOCAL SWORD nbits_left = 0;                /* # bits left in current byte */
LOCAL UTINY b1;                           /* Current byte */
LOCAL UTINY byte_buff[257];               /* Current block */
LOCAL UTINY *pbytes;                      /* Pointer to next byte in block */

LOCAL LONG code_mask[13] = {
     0,
     0x0001, 0x0003,
     0x0007, 0x000F,
     0x001F, 0x003F,
     0x007F, 0x00FF,
     0x01FF, 0x03FF,
     0x07FF, 0x0FFF
     };


LOCAL SWORD init_exp(SWORD size){
   curr_size = size + 1;
   top_slot = 1 << curr_size;
   clear = 1 << size;
   ending = clear + 1;
   slot = newcodes = ending + 1;
   navail_bytes = nbits_left = 0;
   return(0);
   }

LOCAL SWORD get_next_code(void){
   SWORD i, x;
   ULONG ret;

   if (nbits_left == 0)
      {
      if (navail_bytes <= 0)
         {

         /* Out of bytes in current block, so read next block
          */
         pbytes = byte_buff;
         if ((navail_bytes = get_byte()) < 0)
            return(navail_bytes);
         else if (navail_bytes)
            {
            for (i = 0; i < navail_bytes; ++i)
               {
               if ((x = get_byte()) < 0)
                  return(x);
               byte_buff[i] = x;
               }
            }
         }
      b1 = *pbytes++;
      nbits_left = 8;
      --navail_bytes;
      }

   ret = b1 >> (8 - nbits_left);
   while (curr_size > nbits_left)
      {
      if (navail_bytes <= 0)
         {

         /* Out of bytes in current block, so read next block
          */
         pbytes = byte_buff;
         if ((navail_bytes = get_byte()) < 0)
            return(navail_bytes);
         else if (navail_bytes)
            {
            for (i = 0; i < navail_bytes; ++i)
               {
               if ((x = get_byte()) < 0)
                  return(x);
               byte_buff[i] = x;
               }
            }
         }
      b1 = *pbytes++;
      ret |= b1 << nbits_left;
      nbits_left += 8;
      --navail_bytes;
      }
   nbits_left -= curr_size;
   ret &= code_mask[curr_size];
   return((SWORD)(ret));
   }


/* The reason we have these seperated like this instead of using
 * a structure like the original Wilhite code did, is because this
 * stuff generally produces significantly faster code when compiled...
 * This code is full of similar speedups...  (For a good book on writing
 * C for speed or for space optomisation, see Efficient C by Tom Plum,
 * published by Plum-Hall Associates...)
 */

/*
I removed the LOCAL identifiers in the arrays below and replaced them
with 'extern's so as to declare (and re-use) the space elsewhere.
The arrays are actually declared in the assembler source.
                                                    Bert Tyler
*/

LOCAL UTINY dstack[MAX_CODES + 1];      /* Stack for storing pixels */
LOCAL UTINY suffix[MAX_CODES + 1];      /* Suffix table */
LOCAL UWORD prefix[MAX_CODES + 1];      /* Prefix linked list */

/* SWORD decoder(linewidth)
 *    SWORD linewidth;               * Pixels per line of image *
 *
 * - This function decodes an LZW image, according to the method used
 * in the GIF spec.  Every *linewidth* "characters" (ie. pixels) decoded
 * will generate a call to out_line(), which is a user specific function
 * to display a line of pixels.  The function gets its codes from
 * get_next_code() which is responsible for reading blocks of data and
 * seperating them into the proper size codes.  Finally, get_byte() is
 * the global routine to read the next byte from the GIF file.
 *
 * It is generally a good idea to have linewidth correspond to the actual
 * width of a line (as specified in the Image header) to make your own
 * code a bit simpler, but it isn't absolutely necessary.
 *
 * Returns: 0 if successful, else negative.  (See ERRS.H)
 *
 */

LOCAL SWORD decoder(SWORD linewidth)
//   SWORD linewidth;
   {
   FAST UTINY *sp, *bufptr;
   UTINY *buf;
   FAST SWORD code, fc, oc, bufcnt;
   SWORD c, size, ret;

   /* Initialize for decoding a new image...
    */
   if ((size = get_byte()) < 0)
      return(size);
   if (size < 2 || 9 < size)
      return(BAD_CODE_SIZE);
   init_exp(size);

   /* Initialize in case they forgot to put in a clear code.
    * (This shouldn't happen, but we'll try and decode it anyway...)
    */
   oc = fc = 0;

   buf = decoderline;

   /* Set up the stack pointer and decode buffer pointer
    */
   sp = dstack;
   bufptr = buf;
   bufcnt = linewidth;

   /* This is the main loop.  For each code we get we pass through the
    * linked list of prefix codes, pushing the corresponding "character" for
    * each code onto the stack.  When the list reaches a single "character"
    * we push that on the stack too, and then start unstacking each
    * character for output in the correct order.  Special handling is
    * included for the clear code, and the whole thing ends when we get
    * an ending code.
    */
   while ((c = get_next_code()) != ending)
      {

      /* If we had a file error, return without completing the decode
       */
      if (c < 0)
         return(0);

      /* If the code is a clear code, reinitialize all necessary items.
       */
      if (c == clear)
         {
         curr_size = size + 1;
         slot = newcodes;
         top_slot = 1 << curr_size;

         /* Continue reading codes until we get a non-clear code
          * (Another unlikely, but possible case...)
          */
         while ((c = get_next_code()) == clear)
            ;

         /* If we get an ending code immediately after a clear code
          * (Yet another unlikely case), then break out of the loop.
          */
         if (c == ending)
            break;

         /* Finally, if the code is beyond the range of already set codes,
          * (This one had better NOT happen...  I have no idea what will
          * result from this, but I doubt it will look good...) then set it
          * to color zero.
          */
         if (c >= slot)
            c = 0;

         oc = fc = c;

         /* And let us not forget to put the char into the buffer... And
          * if, on the off chance, we were exactly one pixel from the end
          * of the line, we have to send the buffer to the out_line()
          * routine...
          */
         *bufptr++ = c;
         if (--bufcnt == 0)
            {
            if ((ret = out_line(buf, linewidth)) < 0)
               return(ret);
            bufptr = buf;
            bufcnt = linewidth;
            }
         }
      else
         {

         /* In this case, it's not a clear code or an ending code, so
          * it must be a code code...  So we can now decode the code into
          * a stack of character codes. (Clear as mud, right?)
          */
         code = c;

         /* Here we go again with one of those off chances...  If, on the
          * off chance, the code we got is beyond the range of those already
          * set up (Another thing which had better NOT happen...) we trick
          * the decoder into thinking it actually got the last code read.
          * (Hmmn... I'm not sure why this works...  But it does...)
          */
         if (code >= slot)
            {
            if (code > slot)
               ++bad_code_count;
            code = oc;
            *sp++ = fc;
            }

         /* Here we scan back along the linked list of prefixes, pushing
          * helpless characters (ie. suffixes) onto the stack as we do so.
          */
         while (code >= newcodes)
            {
            *sp++ = suffix[code];
            code = prefix[code];
            }

         /* Push the last character on the stack, and set up the new
          * prefix and suffix, and if the required slot number is greater
          * than that allowed by the current bit size, increase the bit
          * size.  (NOTE - If we are all full, we *don't* save the new
          * suffix and prefix...  I'm not certain if this is correct...
          * it might be more proper to overwrite the last code...
          */
         *sp++ = code;
         if (slot < top_slot)
            {
            suffix[slot] = fc = code;
            prefix[slot++] = oc;
            oc = c;
            }
         if (slot >= top_slot)
            if (curr_size < 12)
               {
               top_slot <<= 1;
               ++curr_size;
               }

         /* Now that we've pushed the decoded string (in reverse order)
          * onto the stack, lets pop it off and put it into our decode
          * buffer...  And when the decode buffer is full, write another
          * line...
          */
         while (sp > dstack)
            {
            *bufptr++ = *(--sp);
            if (--bufcnt == 0)
               {
               if ((ret = out_line(buf, linewidth)) < 0)
                  return(ret);
               bufptr = buf;
               bufcnt = linewidth;
               }
            }
         }
      }
   ret = 0;
   if (bufcnt != linewidth)
      ret = out_line(buf, (linewidth - bufcnt));
   return(ret);
   }