mgd.cxx File Reference

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <midas.h>
#include "mgd.h"
#include <ctype.h>

Include dependency graph for mgd.cxx:

Go to the source code of this file.

Macros
#define	dashedSet
#define	TRUE   1
#define	FALSE   0
#define	GIFBITS   12
#define	HSIZE   5003 /* 80% occupancy */
#define	ARGVAL()   (*++(*argv) || (--argc && *++argv))
#define	MAXCODE(n_bits)   (((code_int) 1 << (n_bits)) - 1)
#define	HashTabOf(i)   htab[i]
#define	CodeTabOf(i)   codetab[i]
#define	tab_prefixof(i)   CodeTabOf(i)
#define	tab_suffixof(i)   ((char_type*)(htab))[i]
#define	de_stack   ((char_type*)&tab_suffixof((code_int)1<<GIFBITS))
#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)   (fread(buffer, len, 1, file) != 0)
#define	LM_to_uint(a, b)   (((b)<<8)|(a))

Typedefs
typedef int	code_int
typedef long int	count_int
typedef unsigned char	char_type

Functions
static void	gdImageBrushApply (gdImagePtr im, int x, int y)
static void	gdImageTileApply (gdImagePtr im, int x, int y)
gdImagePtr	gdImageCreate (int sx, int sy)
void	gdImageDestroy (gdImagePtr im)
int	gdImageColorClosest (gdImagePtr im, int r, int g, int b)
int	gdImageColorExact (gdImagePtr im, int r, int g, int b)
int	gdImageColorAllocate (gdImagePtr im, int r, int g, int b)
void	gdImageColorDeallocate (gdImagePtr im, int color)
void	gdImageColorTransparent (gdImagePtr im, int color)
void	gdImageSetPixel (gdImagePtr im, int x, int y, int color)
int	gdImageGetPixel (gdImagePtr im, int x, int y)
void	gdImageLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
void	gdImageDashedLine (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
int	gdImageBoundsSafe (gdImagePtr im, int x, int y)
void	gdImageChar (gdImagePtr im, gdFontPtr f, int x, int y, int c, int color)
void	gdImageCharUp (gdImagePtr im, gdFontPtr f, int x, int y, char c, int color)
void	gdImageString (gdImagePtr im, gdFontPtr f, int x, int y, const char *s, int color)
void	gdImageStringUp (gdImagePtr im, gdFontPtr f, int x, int y, const char *s, int color)
void	gdImageFillToBorder (gdImagePtr im, int x, int y, int border, int color)
void	gdImageFill (gdImagePtr im, int x, int y, int color)
static int	colorstobpp (int colors)
static void	BumpPixel (void)
static int	GIFNextPixel (gdImagePtr im)
static void	GIFEncode (gdGifBuffer *buffer, int GWidth, int GHeight, int GInterlace, int Background, int Transparent, int BitsPerPixel, int *Red, int *Green, int *Blue, gdImagePtr im)
static void	Putword (int w, gdGifBuffer *buffer)
static void	compress (int init_bits, gdGifBuffer *buffer, gdImagePtr im)
static void	output (code_int code)
static void	cl_block (void)
static void	cl_hash (count_int hsize)
static void	char_init (void)
static void	char_out (int c)
static void	flush_char (void)
static void	init_statics (void)
void	gdImageGif (gdImagePtr im, gdGifBuffer *buffer)
void	bputc (int c, gdGifBuffer *buffer)
static int	ReadColorMap (FILE *fd, int number, unsigned char(*buffer)[256])
static int	DoExtension (FILE *fd, int label, int *Transparent)
static int	GetDataBlock (FILE *fd, unsigned char *buf)
static int	GetCode (FILE *fd, int code_size, int flag)
static int	LWZReadByte (FILE *fd, int flag, int input_code_size)
static void	ReadImage (gdImagePtr im, FILE *fd, int len, int height, unsigned char(*cmap)[256], int interlace, int ignore)
gdImagePtr	gdImageCreateFromGif (FILE *fd)
void	gdImageRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
void	gdImageFilledRectangle (gdImagePtr im, int x1, int y1, int x2, int y2, int color)
void	gdImageCopy (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int w, int h)
void	gdImageCopyResized (gdImagePtr dst, gdImagePtr src, int dstX, int dstY, int srcX, int srcY, int dstW, int dstH, int srcW, int srcH)
void	gdImagePolygon (gdImagePtr im, gdPointPtr p, int n, int c)
int	gdCompareInt (const void *a, const void *b)
void	gdImageFilledPolygon (gdImagePtr im, gdPointPtr p, int n, int c)
void	gdImageSetStyle (gdImagePtr im, int *style, int noOfPixels)
void	gdImageSetBrush (gdImagePtr im, gdImagePtr brush)
void	gdImageInterlace (gdImagePtr im, int interlaceArg)

Variables
int	gdFontGiantData []
int	gdFontMediumBoldData []
int	gdFontSmallData []
gdFont	gdFontGiantRep
gdFont	gdFontMediumBoldRep
gdFont	gdFontSmallRep
gdFontPtr	gdFontMediumBold = &gdFontMediumBoldRep
gdFontPtr	gdFontGiant = &gdFontGiantRep
gdFontPtr	gdFontSmall = &gdFontSmallRep
static char	gif_buffer [500000]
static int	Width
static int	Height
static int	curx
static int	cury
static long	CountDown
static int	Pass = 0
static int	Interlace
static int	n_bits
static int	maxbits = GIFBITS
static code_int	maxcode
static code_int	maxmaxcode = (code_int) 1 << GIFBITS
static count_int	htab [HSIZE]
static unsigned short	codetab [HSIZE]
static code_int	hsize = HSIZE
static code_int	free_ent = 0
static int	clear_flg = 0
static int	offset
static long int	in_count = 1
static long int	out_count = 0
static int	g_init_bits
static gdGifBuffer *	g_outbuffer
static int	ClearCode
static int	EOFCode
static unsigned long	cur_accum = 0
static int	cur_bits = 0
static unsigned long	masks []
static int	a_count
static char	accum [256]
struct {
int   transparent
int   delayTime
int   inputFlag
int   disposal
}	Gif89
int	ZeroDataBlock

Macro Definition Documentation

ARGVAL

#define ARGVAL

(

)

(*++(*argv) || (--argc && *++argv))

Definition at line 1461 of file mgd.cxx.

BitSet

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

Definition at line 1851 of file mgd.cxx.

CM_BLUE

#define CM_BLUE   2

Definition at line 1845 of file mgd.cxx.

CM_GREEN

#define CM_GREEN   1

Definition at line 1844 of file mgd.cxx.

CM_RED

#define CM_RED   0

Definition at line 1843 of file mgd.cxx.

CodeTabOf

#define CodeTabOf

(

i

)

codetab[i]

Definition at line 1475 of file mgd.cxx.

dashedSet

#define dashedSet

Value:

   { \
      dashStep++; \
		if (dashStep == gdDashSize) { \
         dashStep = 0; \
         on = !on; \
      } \
		if (on) { \
			gdImageSetPixel(im, x, y, color); \
      } \
   }

Definition at line 726 of file mgd.cxx.

   { \
      dashStep++; \
		if (dashStep == gdDashSize) { \
         dashStep = 0; \
         on = !on; \
      } \
		if (on) { \
			gdImageSetPixel(im, x, y, color); \
      } \
   }

de_stack

#define de_stack   ((char_type*)&tab_suffixof((code_int)1<<GIFBITS))

Definition at line 1490 of file mgd.cxx.

FALSE [1/2]

#define FALSE   0

Definition at line 1169 of file mgd.cxx.

FALSE [2/2]

#define FALSE   0

Definition at line 1169 of file mgd.cxx.

GIFBITS

#define GIFBITS   12

Definition at line 1435 of file mgd.cxx.

HashTabOf

#define HashTabOf

(

i

)

htab[i]

Definition at line 1474 of file mgd.cxx.

HSIZE

#define HSIZE   5003 /* 80% occupancy */

Definition at line 1437 of file mgd.cxx.

INTERLACE

#define INTERLACE   0x40

Definition at line 1849 of file mgd.cxx.

LM_to_uint

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

Definition at line 1855 of file mgd.cxx.

LOCALCOLORMAP

#define LOCALCOLORMAP   0x80

Definition at line 1850 of file mgd.cxx.

MAX_LWZ_BITS

#define MAX_LWZ_BITS   12

Definition at line 1847 of file mgd.cxx.

MAXCODE

#define MAXCODE

(

n_bits

)

(((code_int) 1 << (n_bits)) - 1)

Definition at line 1470 of file mgd.cxx.

MAXCOLORMAPSIZE

#define MAXCOLORMAPSIZE   256

Definition at line 1838 of file mgd.cxx.

ReadOK

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

Definition at line 1853 of file mgd.cxx.

tab_prefixof

#define tab_prefixof

(

i

)

CodeTabOf(i)

Definition at line 1488 of file mgd.cxx.

tab_suffixof

#define tab_suffixof

(

i

)

((char_type*)(htab))[i]

Definition at line 1489 of file mgd.cxx.

TRUE [1/2]

#define TRUE   1

Definition at line 1168 of file mgd.cxx.

TRUE [2/2]

#define TRUE   1

Definition at line 1168 of file mgd.cxx.

Typedef Documentation

char_type

typedef unsigned char char_type

Definition at line 1442 of file mgd.cxx.

code_int

typedef int code_int

Definition at line 1090 of file mgd.cxx.

count_int

typedef long int count_int

Definition at line 1096 of file mgd.cxx.

Function Documentation

bputc()

void bputc	(	int	c,
		gdGifBuffer *	buffer
	)

Definition at line 1253 of file mgd.cxx.

{
   buffer->data[buffer->size++] = (unsigned char) c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BumpPixel()

static void BumpPixel ( void  )

static

Definition at line 1180 of file mgd.cxx.

{
   /*
    * Bump the current X position
    */
   ++curx;
 
   /*
    * If we are at the end of a scan line, set curx back to the beginning
    * If we are interlaced, bump the cury to the appropriate spot,
    * otherwise, just increment it.
    */
   if (curx == Width) {
      curx = 0;
 
      if (!Interlace)
         ++cury;
      else {
         switch (Pass) {
 
         case 0:
            cury += 8;
            if (cury >= Height) {
               ++Pass;
               cury = 4;
            }
            break;
 
         case 1:
            cury += 8;
            if (cury >= Height) {
               ++Pass;
               cury = 2;
            }
            break;
 
         case 2:
            cury += 4;
            if (cury >= Height) {
               ++Pass;
               cury = 1;
            }
            break;
 
         case 3:
            cury += 2;
            break;
         }
      }
   }
}

Here is the caller graph for this function:

char_init()

static void char_init ( void  )

static

Definition at line 1760 of file mgd.cxx.

{
   a_count = 0;
}

Here is the caller graph for this function:

char_out()

static void char_out ( int  c )

static

Definition at line 1774 of file mgd.cxx.

{
   accum[a_count++] = c;
   if (a_count >= 254)
      flush_char();
}

Here is the call graph for this function:

Here is the caller graph for this function:

cl_block()

static void cl_block ( void  )

static

Definition at line 1703 of file mgd.cxx.

{                               /* table clear for block compress */
 
   cl_hash((count_int) hsize);
   free_ent = ClearCode + 2;
   clear_flg = 1;
 
   output((code_int) ClearCode);
}

Here is the call graph for this function:

Here is the caller graph for this function:

cl_hash()

static void cl_hash ( count_int  hsize )

static

Definition at line 1713 of file mgd.cxx.

{                               /* reset code table */
  
   count_int *htab_p = htab + hsize;
 
   long i;
   long m1 = -1;
 
   i = hsize - 16;
   do {                         /* might use Sys V memset(3) here */
      *(htab_p - 16) = m1;
      *(htab_p - 15) = m1;
      *(htab_p - 14) = m1;
      *(htab_p - 13) = m1;
      *(htab_p - 12) = m1;
      *(htab_p - 11) = m1;
      *(htab_p - 10) = m1;
      *(htab_p - 9) = m1;
      *(htab_p - 8) = m1;
      *(htab_p - 7) = m1;
      *(htab_p - 6) = m1;
      *(htab_p - 5) = m1;
      *(htab_p - 4) = m1;
      *(htab_p - 3) = m1;
      *(htab_p - 2) = m1;
      *(htab_p - 1) = m1;
      htab_p -= 16;
   } while ((i -= 16) >= 0);
 
   for (i += 16; i > 0; --i)
      *--htab_p = m1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

colorstobpp()

static int colorstobpp ( int  colors )

static

Definition at line 1136 of file mgd.cxx.

{
   int bpp = 0;
 
   if (colors <= 2)
      bpp = 1;
   else if (colors <= 4)
      bpp = 2;
   else if (colors <= 8)
      bpp = 3;
   else if (colors <= 16)
      bpp = 4;
   else if (colors <= 32)
      bpp = 5;
   else if (colors <= 64)
      bpp = 6;
   else if (colors <= 128)
      bpp = 7;
   else if (colors <= 256)
      bpp = 8;
   return bpp;
}

Here is the call graph for this function:

Here is the caller graph for this function:

compress()

static void compress ( int  init_bits, gdGifBuffer *  buffer, gdImagePtr  im  )

static

Definition at line 1526 of file mgd.cxx.

{
   long fcode;
   code_int i /* = 0 */ ;
   int c;
   code_int ent;
   code_int disp;
   code_int hsize_reg;
   int hshift;
 
   /*
    * Set up the globals:  g_init_bits - initial number of bits
    *                      g_outbuffer   - pointer to output file
    */
   g_init_bits = init_bits;
   g_outbuffer = buffer;
 
   /*
    * Set up the necessary values
    */
   offset = 0;
   out_count = 0;
   clear_flg = 0;
   in_count = 1;
   maxcode = MAXCODE(n_bits = g_init_bits);
 
   ClearCode = (1 << (init_bits - 1));
   EOFCode = ClearCode + 1;
   free_ent = ClearCode + 2;
 
   char_init();
 
   ent = GIFNextPixel(im);
 
   hshift = 0;
   for (fcode = (long) hsize; fcode < 65536L; fcode *= 2L)
      ++hshift;
   hshift = 8 - hshift;         /* set hash code range bound */
 
   hsize_reg = hsize;
   cl_hash((count_int) hsize_reg);      /* clear hash table */
 
   output((code_int) ClearCode);
 
#ifdef SIGNED_COMPARE_SLOW
   while ((c = GIFNextPixel(im)) != (unsigned) EOF) {
#else                           /*SIGNED_COMPARE_SLOW */
   while ((c = GIFNextPixel(im)) != EOF) {      /* } */
#endif                          /*SIGNED_COMPARE_SLOW */
 
      ++in_count;
 
      fcode = (long) (((long) c << maxbits) + ent);
      i = (((code_int) c << hshift) ^ ent);     /* xor hashing */
 
      if (HashTabOf(i) == fcode) {
         ent = CodeTabOf(i);
         continue;
      } else if ((long) HashTabOf(i) < 0)       /* empty slot */
         goto nomatch;
      disp = hsize_reg - i;     /* secondary hash (after G. Knott) */
      if (i == 0)
         disp = 1;
    probe:
      if ((i -= disp) < 0)
         i += hsize_reg;
 
      if (HashTabOf(i) == fcode) {
         ent = CodeTabOf(i);
         continue;
      }
      if ((long) HashTabOf(i) > 0)
         goto probe;
    nomatch:
      output((code_int) ent);
      ++out_count;
      ent = c;
#ifdef SIGNED_COMPARE_SLOW
      if ((unsigned) free_ent < (unsigned) maxmaxcode) {
#else                           /*SIGNED_COMPARE_SLOW */
      if (free_ent < maxmaxcode) {      /* } */
#endif                          /*SIGNED_COMPARE_SLOW */
         CodeTabOf(i) = free_ent++;     /* code -> hashtable */
         HashTabOf(i) = fcode;
      } else
         cl_block();
   }
   /*
    * Put out the final code.
    */
   output((code_int) ent);
   ++out_count;
   output((code_int) EOFCode);
}

Here is the call graph for this function:

Here is the caller graph for this function:

DoExtension()

static int DoExtension ( FILE *  fd, int  label, int *  Transparent  )

static

Definition at line 2023 of file mgd.cxx.

{
   static unsigned char buf[256];
 
   switch (label) {
   case 0xf9:                  /* Graphic Control Extension */
      (void) GetDataBlock(fd, (unsigned char *) buf);
      Gif89.disposal = (buf[0] >> 2) & 0x7;
      Gif89.inputFlag = (buf[0] >> 1) & 0x1;
      Gif89.delayTime = LM_to_uint(buf[1], buf[2]);
      if ((buf[0] & 0x1) != 0)
         *Transparent = buf[3];
 
      while (GetDataBlock(fd, (unsigned char *) buf) != 0);
      return FALSE;
   default:
      break;
   }
   while (GetDataBlock(fd, (unsigned char *) buf) != 0);
 
   return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

flush_char()

static void flush_char ( void  )

static

Definition at line 1784 of file mgd.cxx.

{
   if (a_count > 0) {
      bputc(a_count, g_outbuffer);
      memcpy(g_outbuffer->data + g_outbuffer->size, accum, a_count);
      g_outbuffer->size += a_count;
      a_count = 0;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

gdCompareInt()

int gdCompareInt	(	const void *	a,
		const void *	b
	)

Definition at line 2579 of file mgd.cxx.

{
   return (*(const int *) a) - (*(const int *) b);
}

Here is the caller graph for this function:

gdImageBrushApply()

static void gdImageBrushApply ( gdImagePtr  im, int  x, int  y  )

static

Definition at line 579 of file mgd.cxx.

{
   int lx, ly;
   int hy;
   int hx;
   int x1, y1, x2, y2;
   int srcx, srcy;
   if (!im->brush) {
      return;
   }
   hy = gdImageSY(im->brush) / 2;
   y1 = y - hy;
   y2 = y1 + gdImageSY(im->brush);
   hx = gdImageSX(im->brush) / 2;
   x1 = x - hx;
   x2 = x1 + gdImageSX(im->brush);
   srcy = 0;
   for (ly = y1; (ly < y2); ly++) {
      srcx = 0;
      for (lx = x1; (lx < x2); lx++) {
         int p;
         p = gdImageGetPixel(im->brush, srcx, srcy);
         /* Allow for non-square brushes! */
         if (p != gdImageGetTransparent(im->brush)) {
            gdImageSetPixel(im, lx, ly, im->brushColorMap[p]);
         }
         srcx++;
      }
      srcy++;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

gdImageTileApply()

static void gdImageTileApply ( gdImagePtr  im, int  x, int  y  )

static

Definition at line 611 of file mgd.cxx.

{
   int srcx, srcy;
   int p;
   if (!im->tile) {
      return;
   }
   srcx = x % gdImageSX(im->tile);
   srcy = y % gdImageSY(im->tile);
   p = gdImageGetPixel(im->tile, srcx, srcy);
   /* Allow for transparency */
   if (p != gdImageGetTransparent(im->tile)) {
      gdImageSetPixel(im, x, y, im->tileColorMap[p]);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCode()

static int GetCode ( FILE *  fd, int  code_size, int  flag  )

static

Definition at line 2063 of file mgd.cxx.

{
   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])) == 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:

GetDataBlock()

static int GetDataBlock ( FILE *  fd, unsigned char *  buf  )

static

Definition at line 2046 of file mgd.cxx.

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

Here is the caller graph for this function:

GIFEncode()

static void GIFEncode ( gdGifBuffer *  buffer, int  GWidth, int  GHeight, int  GInterlace, int  Background, int  Transparent, int  BitsPerPixel, int *  Red, int *  Green, int *  Blue, gdImagePtr  im  )

static

Definition at line 1259 of file mgd.cxx.

{
   int B;
   int RWidth, RHeight;
   int LeftOfs, TopOfs;
   int Resolution;
   int ColorMapSize;
   int InitCodeSize;
   int i;
 
   Interlace = GInterlace;
 
   ColorMapSize = 1 << BitsPerPixel;
 
   RWidth = Width = GWidth;
   RHeight = Height = GHeight;
   LeftOfs = TopOfs = 0;
 
   Resolution = BitsPerPixel;
 
   /*
    * Calculate number of bits we are expecting
    */
   CountDown = (long) Width *(long) Height;
 
   /*
    * Indicate which pass we are on (if interlace)
    */
   Pass = 0;
 
   /*
    * The initial code size
    */
   if (BitsPerPixel <= 1)
      InitCodeSize = 2;
   else
      InitCodeSize = BitsPerPixel;
 
   /*
    * Set up the current x and y position
    */
   curx = cury = 0;
 
   /*
    * Write the Magic header
    */
   memcpy(buffer->data + buffer->size, Transparent < 0 ? "GIF87a" : "GIF89a", 6);
   buffer->size += 6;
 
   /*
    * Write out the screen width and height
    */
   Putword(RWidth, buffer);
   Putword(RHeight, buffer);
 
   /*
    * Indicate that there is a global color map
    */
   B = 0x80;                    /* Yes, there is a color map */
 
   /*
    * OR in the resolution
    */
   B |= (Resolution - 1) << 5;
 
   /*
    * OR in the Bits per Pixel
    */
   B |= (BitsPerPixel - 1);
 
   /*
    * Write it out
    */
   bputc(B, buffer);
 
   /*
    * Write out the Background color
    */
   bputc(Background, buffer);
 
   /*
    * Byte of 0's (future expansion)
    */
   bputc(0, buffer);
 
   /*
    * Write out the Global Color Map
    */
   for (i = 0; i < ColorMapSize; ++i) {
      bputc(Red[i], buffer);
      bputc(Green[i], buffer);
      bputc(Blue[i], buffer);
   }
 
   /*
    * Write out extension for transparent color index, if necessary.
    */
   if (Transparent >= 0) {
      bputc('!', buffer);
      bputc(0xf9, buffer);
      bputc(4, buffer);
      bputc(1, buffer);
      bputc(0, buffer);
      bputc(0, buffer);
      bputc((unsigned char) Transparent, buffer);
      bputc(0, buffer);
   }
 
   /*
    * Write an Image separator
    */
   bputc(',', buffer);
 
   /*
    * Write the Image header
    */
 
   Putword(LeftOfs, buffer);
   Putword(TopOfs, buffer);
   Putword(Width, buffer);
   Putword(Height, buffer);
 
   /*
    * Write out whether or not the image is interlaced
    */
   if (Interlace)
      bputc(0x40, buffer);
   else
      bputc(0x00, buffer);
 
   /*
    * Write out the initial code size
    */
   bputc(InitCodeSize, buffer);
 
   /*
    * Go and actually compress the data
    */
   compress(InitCodeSize + 1, buffer, im);
 
   /*
    * Write out a Zero-length packet (to end the series)
    */
   bputc(0, buffer);
 
   /*
    * Write the GIF file terminator
    */
   bputc(';', buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GIFNextPixel()

static int GIFNextPixel ( gdImagePtr  im )

static

Definition at line 1235 of file mgd.cxx.

{
   int r;
 
   if (CountDown == 0)
      return EOF;
 
   --CountDown;
 
   r = gdImageGetPixel(im, curx, cury);
 
   BumpPixel();
 
   return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_statics()

static void init_statics ( void  )

static

Definition at line 1794 of file mgd.cxx.

{
   /* Some of these are properly initialized later. What I'm doing
      here is making sure code that depends on C's initialization
      of statics doesn't break when the code gets called more
      than once. */
   Width = 0;
   Height = 0;
   curx = 0;
   cury = 0;
   CountDown = 0;
   Pass = 0;
   Interlace = 0;
   a_count = 0;
   cur_accum = 0;
   cur_bits = 0;
   g_init_bits = 0;
   g_outbuffer = 0;
   ClearCode = 0;
   EOFCode = 0;
   free_ent = 0;
   clear_flg = 0;
   offset = 0;
   in_count = 1;
   out_count = 0;
   hsize = HSIZE;
   n_bits = 0;
   maxbits = GIFBITS;
   maxcode = 0;
   maxmaxcode = (code_int) 1 << GIFBITS;
}

Here is the caller graph for this function:

LWZReadByte()

static int LWZReadByte ( FILE *  fd, int  flag, int  input_code_size  )

static

Definition at line 2104 of file mgd.cxx.

{
   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[(1 << (MAX_LWZ_BITS)) * 2], *sp;
   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);
 
      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);
      } while (firstcode == clear_code);
      return firstcode;
   }
 
   if (sp > stack)
      return *--sp;
 
   while ((code = GetCode(fd, code_size, FALSE)) >= 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);
         return firstcode;
      } else if (code == end_code) {
         int count;
         unsigned char buf[260];
 
         if (ZeroDataBlock)
            return -2;
 
         while ((count = GetDataBlock(fd, buf)) > 0);
 
         if (count != 0)
            return -2;
      }
 
      incode = code;
 
      if (code >= max_code) {
         *sp++ = firstcode;
         code = oldcode;
      }
 
      while (code >= clear_code) {
         *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:

output()

static void output ( code_int  code )

static

Definition at line 1647 of file mgd.cxx.

{
   cur_accum &= masks[cur_bits];
 
   if (cur_bits > 0)
      cur_accum |= ((long) code << cur_bits);
   else
      cur_accum = code;
 
   cur_bits += n_bits;
 
   while (cur_bits >= 8) {
      char_out((unsigned int) (cur_accum & 0xff));
      cur_accum >>= 8;
      cur_bits -= 8;
   }
 
   /*
    * If the next entry is going to be too big for the code size,
    * then increase it, if possible.
    */
   if (free_ent > maxcode || clear_flg) {
 
      if (clear_flg) {
 
         maxcode = MAXCODE(n_bits = g_init_bits);
         clear_flg = 0;
 
      } else {
 
         ++n_bits;
         if (n_bits == maxbits)
            maxcode = maxmaxcode;
         else
            maxcode = MAXCODE(n_bits);
      }
   }
 
   if (code == EOFCode) {
      /*
       * At EOF, write the rest of the buffer.
       */
      while (cur_bits > 0) {
         char_out((unsigned int) (cur_accum & 0xff));
         cur_accum >>= 8;
         cur_bits -= 8;
      }
 
      flush_char();
 
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Putword()

static void Putword ( int  w, gdGifBuffer *  buffer  )

static

Definition at line 1415 of file mgd.cxx.

{
   buffer->data[buffer->size++] = (unsigned char) (w & 0xff);
   buffer->data[buffer->size++] = (unsigned char) ((w / 256) & 0xff);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadColorMap()

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

static

Definition at line 2004 of file mgd.cxx.

{
   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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ReadImage()

static void ReadImage ( gdImagePtr  im, FILE *  fd, int  len, int  height, unsigned char(*)  cmap[256], int  interlace, int  ignore  )

static

Definition at line 2212 of file mgd.cxx.

{
   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) < 0) {
      return;
   }
 
   /*
    **  If this is an "uninteresting picture" ignore it.
    */
   if (ignore) {
      while (LWZReadByte(fd, FALSE, c) >= 0);
      return;
   }
 
   while ((v = LWZReadByte(fd, FALSE, c)) >= 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) >= 0) {
      /* Ignore extra */
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

a_count

int a_count

static

Definition at line 1755 of file mgd.cxx.

accum

char accum[256]

static

Definition at line 1768 of file mgd.cxx.

clear_flg

int clear_flg = 0

static

Definition at line 1498 of file mgd.cxx.

ClearCode

int ClearCode

static

Definition at line 1523 of file mgd.cxx.

codetab

unsigned short codetab[HSIZE]

static

Definition at line 1473 of file mgd.cxx.

CountDown

long CountDown

static

Definition at line 1173 of file mgd.cxx.

cur_accum

unsigned long cur_accum = 0

static

Definition at line 1638 of file mgd.cxx.

cur_bits

int cur_bits = 0

static

Definition at line 1639 of file mgd.cxx.

curx

int curx

static

Definition at line 1172 of file mgd.cxx.

cury

int cury

static

Definition at line 1172 of file mgd.cxx.

delayTime

int delayTime

Definition at line 1872 of file mgd.cxx.

disposal

int disposal

Definition at line 1874 of file mgd.cxx.

EOFCode

int EOFCode

static

Definition at line 1524 of file mgd.cxx.

free_ent

code_int free_ent = 0

static

Definition at line 1492 of file mgd.cxx.

g_init_bits

int g_init_bits

static

Definition at line 1520 of file mgd.cxx.

g_outbuffer

gdGifBuffer* g_outbuffer

static

Definition at line 1521 of file mgd.cxx.

gdFontGiantData

int gdFontGiantData[]

Definition at line 32 of file mgd.cxx.

                        {
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 48, 120, 252, 510, 252, 120, 48, 0, 0, 0,
   0, 0, 0, 0, 0, 438, 204, 438, 204, 438, 204, 438, 0, 0, 0,
   0, 0, 0, 102, 102, 126, 102, 102, 0, 504, 96, 96, 96, 96, 0,
   0, 0, 0, 62, 6, 30, 6, 6, 0, 496, 48, 240, 48, 48, 0,
   0, 0, 0, 124, 70, 6, 70, 124, 0, 248, 408, 248, 408, 408, 0,
   0, 0, 0, 6, 6, 6, 6, 62, 0, 496, 48, 240, 48, 48, 0,
   0, 0, 0, 0, 0, 120, 204, 204, 120, 0, 0, 0, 0, 0, 0,
   0, 0, 48, 48, 48, 510, 510, 48, 48, 48, 0, 510, 510, 0, 0,
   0, 0, 0, 102, 110, 126, 118, 102, 0, 48, 48, 48, 48, 496, 0,
   0, 0, 0, 102, 102, 102, 60, 24, 0, 504, 96, 96, 96, 96, 0,
   48, 48, 48, 48, 48, 48, 48, 63, 63, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 63, 63, 48, 48, 48, 48, 48, 48,
   0, 0, 0, 0, 0, 0, 0, 496, 496, 48, 48, 48, 48, 48, 48,
   48, 48, 48, 48, 48, 48, 48, 496, 496, 0, 0, 0, 0, 0, 0,
   48, 48, 48, 48, 48, 48, 48, 511, 511, 48, 48, 48, 48, 48, 48,
   0, 0, 0, 511, 511, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 511, 511, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 511, 511, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 511, 511, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 511, 511, 0, 0,
   48, 48, 48, 48, 48, 48, 48, 496, 496, 48, 48, 48, 48, 48, 48,
   48, 48, 48, 48, 48, 48, 48, 63, 63, 48, 48, 48, 48, 48, 48,
   48, 48, 48, 48, 48, 48, 48, 511, 511, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 511, 511, 48, 48, 48, 48, 48, 48,
   48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
   0, 0, 0, 448, 112, 28, 6, 28, 112, 448, 0, 510, 510, 0, 0,
   0, 0, 0, 14, 56, 224, 384, 224, 56, 14, 0, 510, 510, 0, 0,
   0, 0, 0, 0, 0, 510, 510, 200, 200, 200, 206, 206, 0, 0, 0,
   0, 0, 0, 384, 192, 510, 510, 48, 510, 510, 12, 6, 0, 0, 0,
   0, 0, 0, 240, 408, 24, 24, 252, 24, 24, 62, 506, 14, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 48, 48, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 48, 48, 48, 48, 48, 48, 48, 48, 0, 48, 0, 0, 0,
   0, 0, 216, 216, 216, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 108, 108, 254, 108, 108, 254, 108, 108, 0, 0, 0, 0,
   0, 0, 32, 248, 428, 44, 60, 248, 480, 416, 428, 248, 32, 0, 0,
   0, 0, 396, 222, 222, 108, 48, 48, 216, 492, 492, 198, 0, 0, 0,
   0, 0, 60, 102, 102, 102, 60, 102, 486, 198, 230, 444, 0, 0, 0,
   0, 0, 240, 112, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 96, 48, 24, 24, 12, 12, 12, 12, 24, 24, 48, 96, 0, 0,
   0, 12, 24, 48, 48, 96, 96, 96, 96, 48, 48, 24, 12, 0, 0,
   0, 0, 0, 16, 214, 124, 56, 238, 56, 124, 214, 16, 0, 0, 0,
   0, 0, 0, 0, 48, 48, 48, 510, 48, 48, 48, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 120, 56, 12, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 510, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 120, 48, 0, 0,
   0, 0, 384, 192, 192, 96, 48, 48, 24, 12, 12, 6, 0, 0, 0,
   0, 0, 120, 204, 390, 390, 390, 390, 390, 390, 204, 120, 0, 0, 0,
   0, 0, 48, 56, 60, 48, 48, 48, 48, 48, 48, 252, 0, 0, 0,
   0, 0, 252, 390, 390, 384, 192, 96, 56, 12, 6, 510, 0, 0, 0,
   0, 0, 510, 384, 192, 96, 240, 384, 384, 384, 390, 252, 0, 0, 0,
   0, 0, 192, 224, 240, 216, 204, 198, 510, 192, 192, 192, 0, 0, 0,
   0, 0, 510, 6, 6, 254, 398, 384, 384, 384, 390, 252, 0, 0, 0,
   0, 0, 248, 12, 6, 6, 254, 398, 390, 390, 390, 252, 0, 0, 0,
   0, 0, 510, 384, 384, 192, 96, 48, 24, 24, 12, 12, 0, 0, 0,
   0, 0, 252, 390, 390, 390, 252, 390, 390, 390, 390, 252, 0, 0, 0,
   0, 0, 252, 390, 390, 390, 454, 508, 384, 384, 192, 124, 0, 0, 0,
   0, 0, 0, 0, 0, 48, 120, 48, 0, 0, 48, 120, 48, 0, 0,
   0, 0, 0, 0, 0, 48, 120, 48, 0, 0, 120, 56, 12, 0, 0,
   0, 0, 192, 96, 48, 24, 12, 12, 24, 48, 96, 192, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 510, 0, 0, 510, 0, 0, 0, 0, 0,
   0, 0, 12, 24, 48, 96, 192, 192, 96, 48, 24, 12, 0, 0, 0,
   0, 0, 252, 390, 390, 384, 192, 96, 48, 48, 0, 48, 0, 0, 0,
   0, 0, 252, 390, 390, 502, 414, 478, 502, 6, 6, 252, 0, 0, 0,
   0, 0, 48, 120, 204, 390, 390, 390, 510, 390, 390, 390, 0, 0, 0,
   0, 0, 254, 396, 396, 396, 252, 396, 396, 396, 396, 254, 0, 0, 0,
   0, 0, 252, 390, 6, 6, 6, 6, 6, 6, 390, 252, 0, 0, 0,
   0, 0, 254, 396, 396, 396, 396, 396, 396, 396, 396, 254, 0, 0, 0,
   0, 0, 510, 12, 12, 12, 124, 12, 12, 12, 12, 510, 0, 0, 0,
   0, 0, 510, 12, 12, 12, 124, 12, 12, 12, 12, 12, 0, 0, 0,
   0, 0, 252, 390, 6, 6, 6, 486, 390, 390, 390, 252, 0, 0, 0,
   0, 0, 390, 390, 390, 390, 510, 390, 390, 390, 390, 390, 0, 0, 0,
   0, 0, 252, 48, 48, 48, 48, 48, 48, 48, 48, 252, 0, 0, 0,
   0, 0, 496, 192, 192, 192, 192, 192, 192, 192, 198, 124, 0, 0, 0,
   0, 0, 390, 198, 102, 54, 30, 30, 54, 102, 198, 390, 0, 0, 0,
   0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 510, 0, 0, 0,
   0, 0, 390, 390, 462, 510, 510, 438, 438, 390, 390, 390, 0, 0, 0,
   0, 0, 390, 390, 398, 414, 438, 486, 454, 390, 390, 390, 0, 0, 0,
   0, 0, 252, 390, 390, 390, 390, 390, 390, 390, 390, 252, 0, 0, 0,
   0, 0, 254, 390, 390, 390, 254, 6, 6, 6, 6, 6, 0, 0, 0,
   0, 0, 252, 390, 390, 390, 390, 390, 390, 438, 486, 252, 384, 0, 0,
   0, 0, 254, 390, 390, 390, 254, 54, 102, 198, 390, 390, 0, 0, 0,
   0, 0, 252, 390, 6, 6, 252, 384, 384, 384, 390, 252, 0, 0, 0,
   0, 0, 510, 48, 48, 48, 48, 48, 48, 48, 48, 48, 0, 0, 0,
   0, 0, 390, 390, 390, 390, 390, 390, 390, 390, 390, 252, 0, 0, 0,
   0, 0, 390, 390, 390, 204, 204, 204, 120, 120, 120, 48, 0, 0, 0,
   0, 0, 390, 390, 390, 390, 438, 438, 438, 438, 510, 204, 0, 0, 0,
   0, 0, 390, 390, 204, 120, 48, 48, 120, 204, 390, 390, 0, 0, 0,
   0, 0, 390, 390, 204, 120, 48, 48, 48, 48, 48, 48, 0, 0, 0,
   0, 0, 510, 384, 192, 96, 48, 24, 12, 6, 6, 510, 0, 0, 0,
   0, 0, 248, 24, 24, 24, 24, 24, 24, 24, 24, 248, 0, 0, 0,
   0, 0, 6, 12, 12, 24, 48, 48, 96, 192, 192, 384, 0, 0, 0,
   0, 0, 124, 96, 96, 96, 96, 96, 96, 96, 96, 124, 0, 0, 0,
   0, 0, 48, 120, 204, 390, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 511, 0, 0,
   0, 0, 60, 56, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 252, 384, 384, 508, 390, 454, 508, 0, 0, 0,
   0, 0, 6, 6, 6, 254, 398, 390, 390, 390, 398, 254, 0, 0, 0,
   0, 0, 0, 0, 0, 252, 390, 6, 6, 6, 390, 252, 0, 0, 0,
   0, 0, 384, 384, 384, 508, 454, 390, 390, 390, 454, 508, 0, 0, 0,
   0, 0, 0, 0, 0, 252, 390, 390, 510, 6, 6, 252, 0, 0, 0,
   0, 0, 240, 408, 408, 24, 24, 126, 24, 24, 24, 24, 0, 0, 0,
   0, 0, 0, 0, 0, 508, 198, 198, 198, 124, 6, 252, 390, 390, 252,
   0, 0, 6, 6, 6, 254, 398, 390, 390, 390, 390, 390, 0, 0, 0,
   0, 0, 0, 48, 0, 56, 48, 48, 48, 48, 48, 252, 0, 0, 0,
   0, 0, 0, 192, 0, 240, 192, 192, 192, 192, 192, 198, 198, 198, 124,
   0, 0, 6, 6, 6, 390, 230, 62, 14, 62, 230, 390, 0, 0, 0,
   0, 0, 56, 48, 48, 48, 48, 48, 48, 48, 48, 252, 0, 0, 0,
   0, 0, 0, 0, 0, 254, 438, 438, 438, 438, 438, 390, 0, 0, 0,
   0, 0, 0, 0, 0, 254, 398, 390, 390, 390, 390, 390, 0, 0, 0,
   0, 0, 0, 0, 0, 252, 390, 390, 390, 390, 390, 252, 0, 0, 0,
   0, 0, 0, 0, 0, 254, 398, 390, 390, 390, 398, 254, 6, 6, 6,
   0, 0, 0, 0, 0, 508, 454, 390, 390, 390, 454, 508, 384, 384, 384,
   0, 0, 0, 0, 0, 246, 412, 396, 12, 12, 12, 12, 0, 0, 0,
   0, 0, 0, 0, 0, 252, 390, 6, 252, 384, 390, 252, 0, 0, 0,
   0, 0, 0, 24, 24, 254, 24, 24, 24, 24, 408, 240, 0, 0, 0,
   0, 0, 0, 0, 0, 198, 198, 198, 198, 198, 198, 508, 0, 0, 0,
   0, 0, 0, 0, 0, 390, 390, 204, 204, 120, 120, 48, 0, 0, 0,
   0, 0, 0, 0, 0, 390, 390, 438, 438, 438, 510, 204, 0, 0, 0,
   0, 0, 0, 0, 0, 390, 204, 120, 48, 120, 204, 390, 0, 0, 0,
   0, 0, 0, 0, 0, 198, 198, 198, 198, 198, 230, 252, 192, 198, 124,
   0, 0, 0, 0, 0, 510, 192, 96, 48, 24, 12, 510, 0, 0, 0,
   0, 0, 480, 48, 48, 96, 56, 56, 96, 48, 48, 480, 0, 0, 0,
   0, 0, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 0, 0, 0,
   0, 0, 30, 48, 48, 24, 112, 112, 24, 48, 48, 30, 0, 0, 0,
   0, 0, 412, 438, 230, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};

gdFontGiantRep

gdFont gdFontGiantRep

Initial value:

= {
   128, 0, 9, 15,
   gdFontGiantData
}

Definition at line 393 of file mgd.cxx.

                        {
   128, 0, 9, 15,
   gdFontGiantData
};

gdFontMediumBoldData

int gdFontMediumBoldData[]

Definition at line 163 of file mgd.cxx.

                             {
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 12, 30, 63, 30, 12, 0, 0, 0,
   0, 0, 0, 51, 51, 12, 51, 51, 12, 51, 51, 0, 0,
   0, 27, 27, 31, 27, 27, 0, 60, 24, 24, 24, 24, 0,
   0, 15, 3, 7, 3, 3, 0, 60, 12, 28, 12, 12, 0,
   0, 14, 3, 3, 3, 14, 0, 28, 44, 28, 44, 44, 0,
   0, 3, 3, 3, 3, 15, 0, 60, 12, 28, 12, 12, 0,
   0, 0, 30, 51, 51, 30, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 12, 12, 63, 63, 12, 12, 0, 63, 63, 0, 0,
   0, 51, 55, 63, 59, 51, 0, 12, 12, 12, 12, 60, 0,
   0, 51, 51, 18, 30, 12, 0, 60, 24, 24, 24, 24, 0,
   12, 12, 12, 12, 12, 12, 15, 15, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 15, 15, 12, 12, 12, 12, 12,
   0, 0, 0, 0, 0, 0, 124, 124, 12, 12, 12, 12, 12,
   12, 12, 12, 12, 12, 12, 124, 124, 0, 0, 0, 0, 0,
   12, 12, 12, 12, 12, 12, 127, 127, 12, 12, 12, 12, 12,
   0, 0, 127, 127, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 127, 127, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 127, 127, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 127, 127, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 127, 127, 0,
   12, 12, 12, 12, 12, 12, 124, 124, 12, 12, 12, 12, 12,
   12, 12, 12, 12, 12, 12, 15, 15, 12, 12, 12, 12, 12,
   12, 12, 12, 12, 12, 12, 127, 127, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 127, 127, 12, 12, 12, 12, 12,
   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
   0, 0, 48, 24, 6, 3, 6, 24, 48, 63, 63, 0, 0,
   0, 0, 3, 6, 24, 48, 24, 6, 3, 63, 63, 0, 0,
   0, 0, 0, 0, 0, 63, 54, 54, 54, 55, 51, 0, 0,
   0, 0, 32, 48, 63, 63, 12, 63, 63, 3, 1, 0, 0,
   0, 0, 28, 54, 6, 6, 15, 6, 6, 54, 29, 0, 0,
   0, 0, 0, 0, 0, 0, 12, 12, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 12, 12, 12, 12, 12, 12, 0, 12, 12, 0, 0,
   0, 0, 54, 54, 54, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 20, 20, 62, 62, 20, 62, 62, 20, 20, 0, 0,
   0, 0, 12, 30, 45, 13, 30, 44, 45, 30, 12, 0, 0,
   0, 0, 39, 53, 23, 24, 12, 6, 58, 43, 57, 0, 0,
   0, 0, 14, 27, 27, 27, 14, 43, 59, 27, 46, 0, 0,
   0, 0, 28, 28, 12, 6, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 24, 12, 12, 6, 6, 6, 12, 12, 24, 0, 0,
   0, 0, 6, 12, 12, 24, 24, 24, 12, 12, 6, 0, 0,
   0, 0, 0, 0, 18, 12, 63, 63, 12, 18, 0, 0, 0,
   0, 0, 0, 0, 12, 12, 63, 63, 12, 12, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 28, 28, 12, 6, 0,
   0, 0, 0, 0, 0, 0, 63, 63, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 30, 12, 0,
   0, 0, 48, 48, 24, 24, 12, 6, 6, 3, 3, 0, 0,
   0, 0, 12, 18, 51, 51, 51, 51, 51, 18, 12, 0, 0,
   0, 0, 12, 14, 13, 12, 12, 12, 12, 12, 63, 0, 0,
   0, 0, 30, 51, 51, 48, 28, 6, 3, 3, 63, 0, 0,
   0, 0, 30, 51, 48, 48, 28, 48, 48, 51, 30, 0, 0,
   0, 0, 48, 56, 60, 54, 51, 51, 63, 48, 48, 0, 0,
   0, 0, 63, 3, 3, 31, 51, 48, 48, 51, 30, 0, 0,
   0, 0, 30, 51, 3, 3, 31, 51, 51, 51, 30, 0, 0,
   0, 0, 63, 48, 48, 24, 24, 12, 12, 6, 6, 0, 0,
   0, 0, 30, 51, 51, 51, 30, 51, 51, 51, 30, 0, 0,
   0, 0, 30, 51, 51, 51, 62, 48, 48, 51, 30, 0, 0,
   0, 0, 0, 0, 12, 30, 12, 0, 0, 12, 30, 12, 0,
   0, 0, 0, 0, 12, 30, 12, 0, 28, 28, 12, 6, 0,
   0, 0, 48, 24, 12, 6, 3, 6, 12, 24, 48, 0, 0,
   0, 0, 0, 0, 63, 63, 0, 63, 63, 0, 0, 0, 0,
   0, 0, 3, 6, 12, 24, 48, 24, 12, 6, 3, 0, 0,
   0, 0, 30, 51, 51, 48, 28, 12, 0, 12, 12, 0, 0,
   0, 0, 30, 49, 49, 61, 53, 61, 1, 49, 30, 0, 0,
   0, 0, 30, 51, 51, 51, 63, 51, 51, 51, 51, 0, 0,
   0, 0, 31, 51, 51, 51, 31, 51, 51, 51, 31, 0, 0,
   0, 0, 30, 51, 3, 3, 3, 3, 3, 51, 30, 0, 0,
   0, 0, 31, 51, 51, 51, 51, 51, 51, 51, 31, 0, 0,
   0, 0, 63, 3, 3, 3, 31, 3, 3, 3, 63, 0, 0,
   0, 0, 63, 3, 3, 3, 31, 3, 3, 3, 3, 0, 0,
   0, 0, 30, 51, 3, 3, 59, 51, 51, 51, 62, 0, 0,
   0, 0, 51, 51, 51, 51, 63, 51, 51, 51, 51, 0, 0,
   0, 0, 63, 12, 12, 12, 12, 12, 12, 12, 63, 0, 0,
   0, 0, 48, 48, 48, 48, 48, 48, 48, 51, 30, 0, 0,
   0, 0, 35, 51, 27, 15, 7, 15, 27, 51, 35, 0, 0,
   0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 63, 0, 0,
   0, 0, 33, 51, 63, 63, 51, 51, 51, 51, 51, 0, 0,
   0, 0, 51, 51, 55, 55, 63, 59, 59, 51, 51, 0, 0,
   0, 0, 30, 51, 51, 51, 51, 51, 51, 51, 30, 0, 0,
   0, 0, 31, 51, 51, 51, 31, 3, 3, 3, 3, 0, 0,
   0, 0, 30, 51, 51, 51, 51, 51, 55, 59, 30, 48, 0,
   0, 0, 31, 51, 51, 51, 31, 15, 27, 51, 35, 0, 0,
   0, 0, 30, 51, 3, 3, 30, 48, 48, 51, 30, 0, 0,
   0, 0, 63, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0,
   0, 0, 51, 51, 51, 51, 51, 51, 51, 51, 30, 0, 0,
   0, 0, 51, 51, 51, 18, 18, 30, 12, 12, 12, 0, 0,
   0, 0, 51, 51, 51, 51, 51, 63, 63, 51, 33, 0, 0,
   0, 0, 33, 51, 18, 30, 12, 30, 18, 51, 33, 0, 0,
   0, 0, 51, 51, 30, 30, 12, 12, 12, 12, 12, 0, 0,
   0, 0, 63, 48, 48, 24, 12, 6, 3, 3, 63, 0, 0,
   0, 0, 30, 6, 6, 6, 6, 6, 6, 6, 30, 0, 0,
   0, 0, 3, 3, 6, 6, 12, 24, 24, 48, 48, 0, 0,
   0, 0, 30, 24, 24, 24, 24, 24, 24, 24, 30, 0, 0,
   0, 0, 12, 30, 51, 33, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 63, 63, 0,
   0, 0, 14, 14, 12, 24, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 30, 48, 62, 51, 51, 62, 0, 0,
   0, 0, 3, 3, 3, 31, 51, 51, 51, 51, 31, 0, 0,
   0, 0, 0, 0, 0, 30, 51, 3, 3, 51, 30, 0, 0,
   0, 0, 48, 48, 48, 62, 51, 51, 51, 51, 62, 0, 0,
   0, 0, 0, 0, 0, 30, 51, 63, 3, 51, 30, 0, 0,
   0, 0, 28, 54, 6, 6, 15, 6, 6, 6, 6, 0, 0,
   0, 0, 0, 0, 0, 46, 51, 51, 30, 3, 30, 51, 30,
   0, 0, 3, 3, 3, 31, 51, 51, 51, 51, 51, 0, 0,
   0, 0, 12, 12, 0, 14, 12, 12, 12, 12, 63, 0, 0,
   0, 0, 48, 48, 0, 48, 48, 48, 48, 48, 48, 51, 30,
   0, 0, 3, 3, 3, 51, 27, 15, 15, 27, 51, 0, 0,
   0, 0, 14, 12, 12, 12, 12, 12, 12, 12, 63, 0, 0,
   0, 0, 0, 0, 0, 27, 63, 63, 51, 51, 51, 0, 0,
   0, 0, 0, 0, 0, 31, 51, 51, 51, 51, 51, 0, 0,
   0, 0, 0, 0, 0, 30, 51, 51, 51, 51, 30, 0, 0,
   0, 0, 0, 0, 0, 31, 51, 51, 51, 31, 3, 3, 3,
   0, 0, 0, 0, 0, 62, 51, 51, 51, 62, 48, 48, 48,
   0, 0, 0, 0, 0, 31, 51, 3, 3, 3, 3, 0, 0,
   0, 0, 0, 0, 0, 30, 51, 6, 24, 51, 30, 0, 0,
   0, 0, 0, 3, 3, 15, 3, 3, 3, 51, 30, 0, 0,
   0, 0, 0, 0, 0, 51, 51, 51, 51, 51, 62, 0, 0,
   0, 0, 0, 0, 0, 51, 51, 51, 30, 30, 12, 0, 0,
   0, 0, 0, 0, 0, 51, 51, 51, 63, 63, 18, 0, 0,
   0, 0, 0, 0, 0, 51, 51, 30, 30, 51, 51, 0, 0,
   0, 0, 0, 0, 0, 51, 51, 51, 51, 62, 48, 51, 30,
   0, 0, 0, 0, 0, 63, 48, 24, 6, 3, 63, 0, 0,
   0, 0, 28, 6, 6, 12, 6, 12, 6, 6, 28, 0, 0,
   0, 0, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 0,
   0, 0, 14, 24, 24, 12, 24, 12, 24, 24, 14, 0, 0,
   0, 0, 38, 63, 25, 0, 0, 0, 0, 0, 0, 0, 0,
   42, 20, 42, 20, 42, 20, 42, 20, 42, 20, 42, 20, 42,
};

gdFontMediumBoldRep

gdFont gdFontMediumBoldRep

Initial value:

= {
   128, 0, 7, 13,
   gdFontMediumBoldData
}

Definition at line 398 of file mgd.cxx.

                             {
   128, 0, 7, 13,
   gdFontMediumBoldData
};

gdFontSmallData

int gdFontSmallData[]

Definition at line 294 of file mgd.cxx.

                        {
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 4, 4, 4, 4, 4, 0, 4, 0, 0, 0,
   0, 10, 10, 10, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 10, 31, 10, 10, 31, 10, 0, 0, 0,
   0, 4, 14, 21, 5, 14, 20, 21, 14, 4, 0, 0,
   0, 0, 31, 19, 8, 4, 2, 25, 25, 0, 0, 0,
   0, 0, 2, 5, 5, 2, 21, 9, 22, 0, 0, 0,
   0, 6, 6, 3, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 16, 8, 4, 4, 4, 8, 16, 0, 0, 0,
   0, 0, 1, 2, 4, 4, 4, 2, 1, 0, 0, 0,
   0, 0, 4, 21, 14, 4, 14, 21, 4, 0, 0, 0,
   0, 0, 0, 4, 4, 31, 4, 4, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 6, 6, 3, 0, 0,
   0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 6, 6, 0, 0, 0,
   0, 0, 0, 16, 8, 4, 2, 1, 0, 0, 0, 0,
   0, 0, 14, 17, 25, 21, 19, 17, 14, 0, 0, 0,
   0, 0, 4, 6, 4, 4, 4, 4, 14, 0, 0, 0,
   0, 0, 14, 17, 16, 8, 4, 2, 31, 0, 0, 0,
   0, 0, 14, 17, 16, 12, 16, 17, 14, 0, 0, 0,
   0, 0, 8, 12, 10, 9, 31, 8, 8, 0, 0, 0,
   0, 0, 31, 1, 15, 16, 16, 17, 14, 0, 0, 0,
   0, 0, 12, 2, 1, 15, 17, 17, 14, 0, 0, 0,
   0, 0, 31, 16, 8, 8, 4, 4, 4, 0, 0, 0,
   0, 0, 14, 17, 17, 14, 17, 17, 14, 0, 0, 0,
   0, 0, 14, 17, 17, 30, 16, 8, 6, 0, 0, 0,
   0, 0, 0, 0, 6, 6, 0, 6, 6, 0, 0, 0,
   0, 0, 0, 0, 6, 6, 0, 6, 6, 3, 0, 0,
   0, 0, 0, 8, 4, 2, 4, 8, 0, 0, 0, 0,
   0, 0, 0, 0, 31, 0, 31, 0, 0, 0, 0, 0,
   0, 0, 0, 2, 4, 8, 4, 2, 0, 0, 0, 0,
   0, 0, 14, 17, 8, 4, 4, 0, 4, 0, 0, 0,
   0, 0, 14, 17, 29, 21, 29, 1, 14, 0, 0, 0,
   0, 0, 14, 17, 17, 31, 17, 17, 17, 0, 0, 0,
   0, 0, 15, 17, 17, 15, 17, 17, 15, 0, 0, 0,
   0, 0, 14, 17, 1, 1, 1, 17, 14, 0, 0, 0,
   0, 0, 15, 18, 18, 18, 18, 18, 15, 0, 0, 0,
   0, 0, 31, 1, 1, 15, 1, 1, 31, 0, 0, 0,
   0, 0, 31, 1, 1, 15, 1, 1, 1, 0, 0, 0,
   0, 0, 14, 17, 1, 1, 25, 17, 14, 0, 0, 0,
   0, 0, 17, 17, 17, 31, 17, 17, 17, 0, 0, 0,
   0, 0, 14, 4, 4, 4, 4, 4, 14, 0, 0, 0,
   0, 0, 16, 16, 16, 16, 16, 17, 14, 0, 0, 0,
   0, 0, 17, 9, 5, 3, 5, 9, 17, 0, 0, 0,
   0, 0, 1, 1, 1, 1, 1, 1, 31, 0, 0, 0,
   0, 0, 17, 27, 21, 17, 17, 17, 17, 0, 0, 0,
   0, 0, 17, 17, 19, 21, 25, 17, 17, 0, 0, 0,
   0, 0, 14, 17, 17, 17, 17, 17, 14, 0, 0, 0,
   0, 0, 15, 17, 17, 15, 1, 1, 1, 0, 0, 0,
   0, 0, 14, 17, 17, 17, 21, 9, 22, 0, 0, 0,
   0, 0, 15, 17, 17, 15, 5, 9, 17, 0, 0, 0,
   0, 0, 14, 17, 1, 14, 16, 17, 14, 0, 0, 0,
   0, 0, 31, 4, 4, 4, 4, 4, 4, 0, 0, 0,
   0, 0, 17, 17, 17, 17, 17, 17, 14, 0, 0, 0,
   0, 0, 17, 17, 17, 17, 10, 10, 4, 0, 0, 0,
   0, 0, 17, 17, 17, 17, 21, 27, 17, 0, 0, 0,
   0, 0, 17, 17, 10, 4, 10, 17, 17, 0, 0, 0,
   0, 0, 17, 17, 10, 4, 4, 4, 4, 0, 0, 0,
   0, 0, 31, 16, 8, 31, 2, 1, 31, 0, 0, 0,
   0, 28, 4, 4, 4, 4, 4, 4, 4, 28, 0, 0,
   0, 0, 0, 1, 2, 4, 8, 16, 0, 0, 0, 0,
   0, 7, 4, 4, 4, 4, 4, 4, 4, 7, 0, 0,
   0, 4, 10, 17, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 0,
   0, 12, 12, 24, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 14, 16, 30, 17, 30, 0, 0, 0,
   0, 0, 1, 1, 15, 17, 17, 17, 15, 0, 0, 0,
   0, 0, 0, 0, 14, 17, 1, 1, 30, 0, 0, 0,
   0, 0, 16, 16, 30, 17, 17, 17, 30, 0, 0, 0,
   0, 0, 0, 0, 14, 17, 15, 1, 14, 0, 0, 0,
   0, 0, 12, 18, 2, 7, 2, 2, 2, 0, 0, 0,
   0, 0, 0, 0, 14, 17, 17, 17, 30, 16, 14, 0,
   0, 0, 1, 1, 15, 17, 17, 17, 17, 0, 0, 0,
   0, 0, 0, 4, 0, 4, 4, 4, 4, 0, 0, 0,
   0, 0, 0, 16, 0, 16, 16, 16, 16, 17, 14, 0,
   0, 0, 1, 1, 17, 9, 7, 9, 17, 0, 0, 0,
   0, 0, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0,
   0, 0, 0, 0, 11, 21, 21, 21, 21, 0, 0, 0,
   0, 0, 0, 0, 13, 19, 17, 17, 17, 0, 0, 0,
   0, 0, 0, 0, 14, 17, 17, 17, 14, 0, 0, 0,
   0, 0, 0, 0, 15, 17, 17, 17, 15, 1, 1, 0,
   0, 0, 0, 0, 14, 17, 17, 17, 30, 16, 16, 0,
   0, 0, 0, 0, 13, 19, 1, 1, 1, 0, 0, 0,
   0, 0, 0, 0, 30, 1, 14, 16, 15, 0, 0, 0,
   0, 0, 4, 4, 31, 4, 4, 4, 24, 0, 0, 0,
   0, 0, 0, 0, 17, 17, 17, 17, 14, 0, 0, 0,
   0, 0, 0, 0, 17, 17, 17, 10, 4, 0, 0, 0,
   0, 0, 0, 0, 17, 17, 21, 21, 10, 0, 0, 0,
   0, 0, 0, 0, 17, 10, 4, 10, 17, 0, 0, 0,
   0, 0, 0, 0, 17, 17, 17, 10, 4, 2, 1, 0,
   0, 0, 0, 0, 31, 8, 14, 2, 31, 0, 0, 0,
   0, 16, 8, 8, 8, 4, 8, 8, 8, 16, 0, 0,
   0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0,
   0, 1, 2, 2, 2, 4, 2, 2, 2, 1, 0, 0,
   0, 22, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 1, 1, 15, 17, 17, 17, 15, 0, 0, 0,
};

gdFontSmallRep

gdFont gdFontSmallRep

Initial value:

= {
   96, 32, 6, 12,
   gdFontSmallData
}

Definition at line 403 of file mgd.cxx.

                        {
   96, 32, 6, 12,
   gdFontSmallData
};

[struct]

struct { ... } Gif89

Initial value:

= {
-1, -1, -1, 0}

gif_buffer

char gif_buffer[500000]

static

Definition at line 1116 of file mgd.cxx.

Height

int Height

static

Definition at line 1171 of file mgd.cxx.

hsize

code_int hsize = HSIZE

static

Definition at line 1477 of file mgd.cxx.

htab

count_int htab[HSIZE]

static

Definition at line 1472 of file mgd.cxx.

in_count

long int in_count = 1

static

Definition at line 1501 of file mgd.cxx.

inputFlag

int inputFlag

Definition at line 1873 of file mgd.cxx.

Interlace

int Interlace

static

Definition at line 1175 of file mgd.cxx.

masks

unsigned long masks[]

static

Initial value:

= { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
   0x001F, 0x003F, 0x007F, 0x00FF,
   0x01FF, 0x03FF, 0x07FF, 0x0FFF,
   0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF
}

Definition at line 1641 of file mgd.cxx.

                               { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
   0x001F, 0x003F, 0x007F, 0x00FF,
   0x01FF, 0x03FF, 0x07FF, 0x0FFF,
   0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF
};

maxbits

int maxbits = GIFBITS

static

Definition at line 1464 of file mgd.cxx.

maxcode

code_int maxcode

static

Definition at line 1465 of file mgd.cxx.

maxmaxcode

code_int maxmaxcode = (code_int) 1 << GIFBITS

static

Definition at line 1466 of file mgd.cxx.

n_bits

int n_bits

static

Definition at line 1463 of file mgd.cxx.

offset

int offset

static

Definition at line 1500 of file mgd.cxx.

out_count

long int out_count = 0

static

Definition at line 1502 of file mgd.cxx.

Pass

int Pass = 0

static

Definition at line 1174 of file mgd.cxx.

transparent

int transparent

Definition at line 1871 of file mgd.cxx.

Width

int Width

static

Definition at line 1171 of file mgd.cxx.

ZeroDataBlock

int ZeroDataBlock

Definition at line 1886 of file mgd.cxx.