Back to index

tetex-bin  3.0
Defines | Functions
gd_gif_in.c File Reference
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "gd.h"

Go to the source code of this file.

Defines

#define VERBOSE   0
#define MAXCOLORMAPSIZE   256
#define TRUE   1
#define FALSE   0
#define CM_RED   0
#define CM_GREEN   1
#define CM_BLUE   2
#define MAX_LWZ_BITS   12
#define INTERLACE   0x40
#define LOCALCOLORMAP   0x80
#define BitSet(byte, bit)   (((byte) & (bit)) == (bit))
#define ReadOK(file, buffer, len)   (gdGetBuf(buffer, len, file) != 0)
#define LM_to_uint(a, b)   (((b)<<8)|(a))
#define STACK_SIZE   ((1<<(MAX_LWZ_BITS))*2)

Functions

static int ReadColorMap (gdIOCtx *fd, int number, unsigned char(*buffer)[256])
static int DoExtension (gdIOCtx *fd, int label, int *Transparent, int *ZeroDataBlockP)
static int GetDataBlock (gdIOCtx *fd, unsigned char *buf, int *ZeroDataBlockP)
static int GetCode (gdIOCtx *fd, int code_size, int flag, int *ZeroDataBlockP)
static int LWZReadByte (gdIOCtx *fd, int flag, int input_code_size, int *ZeroDataBlockP)
static void ReadImage (gdImagePtr im, gdIOCtx *fd, int len, int height, unsigned char(*cmap)[256], int interlace, int *ZeroDataBlockP)
 BGD_DECLARE (gdImagePtr)
static int GetDataBlock_ (gdIOCtx *fd, unsigned char *buf, int *ZeroDataBlockP)
static int GetCode_ (gdIOCtx *fd, int code_size, int flag, int *ZeroDataBlockP)
static int LWZReadByte_ (gdIOCtx *fd, int flag, int input_code_size, int *ZeroDataBlockP)

Define Documentation

#define BitSet (   byte,
  bit 
)    (((byte) & (bit)) == (bit))

Definition at line 43 of file gd_gif_in.c.

#define CM_BLUE   2

Definition at line 37 of file gd_gif_in.c.

#define CM_GREEN   1

Definition at line 36 of file gd_gif_in.c.

#define CM_RED   0

Definition at line 35 of file gd_gif_in.c.

#define FALSE   0

Definition at line 33 of file gd_gif_in.c.

#define INTERLACE   0x40

Definition at line 41 of file gd_gif_in.c.

#define LM_to_uint (   a,
  b 
)    (((b)<<8)|(a))

Definition at line 47 of file gd_gif_in.c.

#define LOCALCOLORMAP   0x80

Definition at line 42 of file gd_gif_in.c.

#define MAX_LWZ_BITS   12

Definition at line 39 of file gd_gif_in.c.

#define MAXCOLORMAPSIZE   256

Definition at line 30 of file gd_gif_in.c.

#define ReadOK (   file,
  buffer,
  len 
)    (gdGetBuf(buffer, len, file) != 0)

Definition at line 45 of file gd_gif_in.c.

#define STACK_SIZE   ((1<<(MAX_LWZ_BITS))*2)

Definition at line 356 of file gd_gif_in.c.

#define TRUE   1

Definition at line 32 of file gd_gif_in.c.

#define VERBOSE   0

Definition at line 25 of file gd_gif_in.c.


Function Documentation

Definition at line 79 of file gd_gif_in.c.

{
        gdIOCtx             *fd = gdNewFileCtx(fdFile);
        gdImagePtr          im = 0;

        im = gdImageCreateFromGifCtx(fd);

        fd->gd_free(fd);

        return im;
}
static int DoExtension ( gdIOCtx fd,
int  label,
int Transparent,
int ZeroDataBlockP 
) [static]

Definition at line 242 of file gd_gif_in.c.

{
       static unsigned char     buf[256];

       switch (label) {
       case 0xf9:              /* Graphic Control Extension */
               (void) GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP);
#if 0
               Gif89.disposal    = (buf[0] >> 2) & 0x7;
               Gif89.inputFlag   = (buf[0] >> 1) & 0x1;
               Gif89.delayTime   = LM_to_uint(buf[1],buf[2]);
#endif
               if ((buf[0] & 0x1) != 0)
                       *Transparent = buf[3];

               while (GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP) != 0)
                       ;
               return FALSE;
       default:
               break;
       }
       while (GetDataBlock(fd, (unsigned char*) buf, ZeroDataBlockP) != 0)
               ;

       return FALSE;
}

Here is the call graph for this function:

static int GetCode ( gdIOCtx fd,
int  code_size,
int  flag,
int ZeroDataBlockP 
) [static]

Definition at line 347 of file gd_gif_in.c.

{
 int rv;

 rv = GetCode_(fd,code_size,flag, ZeroDataBlockP);
 if (VERBOSE) printf("[GetCode(,%d,%d) returning %d]\n",code_size,flag,rv);
 return(rv);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int GetCode_ ( gdIOCtx fd,
int  code_size,
int  flag,
int ZeroDataBlockP 
) [static]

Definition at line 306 of file gd_gif_in.c.

{
       static unsigned char    buf[280];
       static int              curbit, lastbit, done, last_byte;
       int                     i, j, ret;
       unsigned char           count;

       if (flag) {
               curbit = 0;
               lastbit = 0;
               done = FALSE;
               return 0;
       }

       if ( (curbit+code_size) >= lastbit) {
               if (done) {
                       if (curbit >= lastbit) {
                                /* Oh well */
                       }                        
                       return -1;
               }
               buf[0] = buf[last_byte-2];
               buf[1] = buf[last_byte-1];

               if ((count = GetDataBlock(fd, &buf[2], ZeroDataBlockP)) == 0)
                       done = TRUE;

               last_byte = 2 + count;
               curbit = (curbit - lastbit) + 16;
               lastbit = (2+count)*8 ;
       }

       ret = 0;
       for (i = curbit, j = 0; j < code_size; ++i, ++j)
               ret |= ((buf[ i / 8 ] & (1 << (i % 8))) != 0) << j;

       curbit += code_size;
       return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int GetDataBlock ( gdIOCtx fd,
unsigned char *  buf,
int ZeroDataBlockP 
) [static]

Definition at line 288 of file gd_gif_in.c.

{
 int rv;
 int i;

 rv = GetDataBlock_(fd,buf, ZeroDataBlockP);
 if (VERBOSE)
  { printf("[GetDataBlock returning %d",rv);
    if (rv > 0)
     { printf(":");
       for (i=0;i<rv;i++) printf(" %02x",buf[i]);
     }
    printf("]\n");
  }
 return(rv);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int GetDataBlock_ ( gdIOCtx fd,
unsigned char *  buf,
int ZeroDataBlockP 
) [static]

Definition at line 270 of file gd_gif_in.c.

{
       unsigned char   count;

       if (! ReadOK(fd,&count,1)) {
               return -1;
       }

       *ZeroDataBlockP = count == 0;

       if ((count != 0) && (! ReadOK(fd, buf, count))) {
               return -1;
       }

       return count;
}

Here is the caller graph for this function:

static int LWZReadByte ( gdIOCtx fd,
int  flag,
int  input_code_size,
int ZeroDataBlockP 
) [static]

Definition at line 479 of file gd_gif_in.c.

{
 int rv;

 rv = LWZReadByte_(fd,flag,input_code_size, ZeroDataBlockP);
 if (VERBOSE) printf("[LWZReadByte(,%d,%d) returning %d]\n",flag,input_code_size,rv);
 return(rv);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int LWZReadByte_ ( gdIOCtx fd,
int  flag,
int  input_code_size,
int ZeroDataBlockP 
) [static]

Definition at line 358 of file gd_gif_in.c.

{
       static int      fresh = FALSE;
       int             code, incode;
       static int      code_size, set_code_size;
       static int      max_code, max_code_size;
       static int      firstcode, oldcode;
       static int      clear_code, end_code;
       static int      table[2][(1<< MAX_LWZ_BITS)];
       static int      stack[STACK_SIZE], *sp;
       register int    i;

       if (flag) {
               set_code_size = input_code_size;
               code_size = set_code_size+1;
               clear_code = 1 << set_code_size ;
               end_code = clear_code + 1;
               max_code_size = 2*clear_code;
               max_code = clear_code+2;

               GetCode(fd, 0, TRUE, ZeroDataBlockP);
               
               fresh = TRUE;

               for (i = 0; i < clear_code; ++i) {
                       table[0][i] = 0;
                       table[1][i] = i;
               }
               for (; i < (1<<MAX_LWZ_BITS); ++i)
                       table[0][i] = table[1][0] = 0;

               sp = stack;

               return 0;
       } else if (fresh) {
               fresh = FALSE;
               do {
                       firstcode = oldcode =
                               GetCode(fd, code_size, FALSE, ZeroDataBlockP);
               } while (firstcode == clear_code);
               return firstcode;
       }

       if (sp > stack)
               return *--sp;

       while ((code = GetCode(fd, code_size, FALSE, ZeroDataBlockP)) >= 0) {
               if (code == clear_code) {
                       for (i = 0; i < clear_code; ++i) {
                               table[0][i] = 0;
                               table[1][i] = i;
                       }
                       for (; i < (1<<MAX_LWZ_BITS); ++i)
                               table[0][i] = table[1][i] = 0;
                       code_size = set_code_size+1;
                       max_code_size = 2*clear_code;
                       max_code = clear_code+2;
                       sp = stack;
                       firstcode = oldcode =
                                       GetCode(fd, code_size, FALSE, ZeroDataBlockP);
                       return firstcode;
               } else if (code == end_code) {
                       int             count;
                       unsigned char   buf[260];

                       if (*ZeroDataBlockP)
                               return -2;

                       while ((count = GetDataBlock(fd, buf, ZeroDataBlockP)) > 0)
                               ;

                       if (count != 0)
                       return -2;
               }

               incode = code;

              if (sp == (stack + STACK_SIZE)) {
                     /* Bad compressed data stream */
                     return -1;
              }

               if (code >= max_code) {
                       *sp++ = firstcode;
                       code = oldcode;
               }

               while (code >= clear_code) {
                     if (sp == (stack + STACK_SIZE)) {
                            /* Bad compressed data stream */
                            return -1;
                     }
                       *sp++ = table[1][code];
                       if (code == table[0][code]) {
                               /* Oh well */
                       }
                       code = table[0][code];
               }

               *sp++ = firstcode = table[1][code];

               if ((code = max_code) <(1<<MAX_LWZ_BITS)) {
                       table[0][code] = oldcode;
                       table[1][code] = firstcode;
                       ++max_code;
                       if ((max_code >= max_code_size) &&
                               (max_code_size < (1<<MAX_LWZ_BITS))) {
                               max_code_size *= 2;
                               ++code_size;
                       }
               }

               oldcode = incode;

               if (sp > stack)
                       return *--sp;
       }
       return code;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ReadColorMap ( gdIOCtx fd,
int  number,
unsigned char(*)  buffer[256] 
) [static]

Definition at line 222 of file gd_gif_in.c.

{
       int             i;
       unsigned char   rgb[3];


       for (i = 0; i < number; ++i) {
               if (! ReadOK(fd, rgb, sizeof(rgb))) {
                       return TRUE;
               }
               buffer[CM_RED][i] = rgb[0] ;
               buffer[CM_GREEN][i] = rgb[1] ;
               buffer[CM_BLUE][i] = rgb[2] ;
       }


       return FALSE;
}
static void ReadImage ( gdImagePtr  im,
gdIOCtx fd,
int  len,
int  height,
unsigned char(*)  cmap[256],
int  interlace,
int ZeroDataBlockP 
) [static]

Definition at line 489 of file gd_gif_in.c.

{
       unsigned char   c;      
       int             v;
       int             xpos = 0, ypos = 0, pass = 0;
       int i;
       /* Stash the color map into the image */
       for (i=0; (i<gdMaxColors); i++) {
               im->red[i] = cmap[CM_RED][i];     
               im->green[i] = cmap[CM_GREEN][i]; 
               im->blue[i] = cmap[CM_BLUE][i];   
               im->open[i] = 1;
       }
       /* Many (perhaps most) of these colors will remain marked open. */
       im->colorsTotal = gdMaxColors;
       /*
       **  Initialize the Compression routines
       */
       if (! ReadOK(fd,&c,1)) {
               return; 
       }
       if (LWZReadByte(fd, TRUE, c, ZeroDataBlockP) < 0) {
               return;
       }

       /*
       **  If this is an "uninteresting picture" ignore it.
       **  REMOVED For 1.4
       */
       /*if (ignore) { */
       /*        while (LWZReadByte(fd, FALSE, c) >= 0) */
       /*                ; */
       /*        return; */
       /*} */

       while ((v = LWZReadByte(fd,FALSE,c, ZeroDataBlockP)) >= 0 ) {
               /* This how we recognize which colors are actually used. */
               if (im->open[v]) {
                       im->open[v] = 0;
               }
               gdImageSetPixel(im, xpos, ypos, v);
               ++xpos;
               if (xpos == len) {
                       xpos = 0;
                       if (interlace) {
                               switch (pass) {
                               case 0:
                               case 1:
                                       ypos += 8; break;
                               case 2:
                                       ypos += 4; break;
                               case 3:
                                       ypos += 2; break;
                               }

                               if (ypos >= height) {
                                       ++pass;
                                       switch (pass) {
                                       case 1:
                                               ypos = 4; break;
                                       case 2:
                                               ypos = 2; break;
                                       case 3:
                                               ypos = 1; break;
                                       default:
                                               goto fini;
                                       }
                               }
                       } else {
                               ++ypos;
                       }
               }
               if (ypos >= height)
                       break;
       }

fini:
       if (LWZReadByte(fd,FALSE,c, ZeroDataBlockP)>=0) {
               /* Ignore extra */
       }
}

Here is the call graph for this function: