Path: utzoo!utgpu!jarvis.csri.toronto.edu!mailrus!ncar!ames!decwrl!sgi!paul@manray.sgi.com
From: paul@manray.sgi.com (Paul Haeberli)
Newsgroups: comp.sys.sgi
Subject: A filter to convert IRIS images to Compuserve GIF format
Message-ID: <42452@sgi.sgi.com>
Date: 3 Oct 89 07:59:52 GMT
Sender: paul@manray.sgi.com
Organization: Silicon Graphics, Inc., Mountain View, CA
Lines: 693

/*
 *	togif - 
 *		Convert an IRIS image to GIF format.  Converts b/w and 
 *	color images to 8 bit per pixel GIF format.  Color images
 *	are dithered with a 4 by 4 dither matrix.  GIF image files 
 *	may be uuencoded, and sent over the network.
 *
 *			Paul Haeberli @ Silicon Graphics - 1989
 *
 *	To compile use:
 *
 *		cc -I/usr/include/gl togif.c -o togif -limage 
 *
 */
#include "image.h"

#define MAXXSIZE 4096
#define MAXCOLORS 256

short rbuf[MAXXSIZE];
short gbuf[MAXXSIZE];
short bbuf[MAXXSIZE];
short obuf[MAXXSIZE];
int rmap[MAXCOLORS];
int gmap[MAXCOLORS];
int bmap[MAXCOLORS];
int iscolor, currow;
IMAGE *iimage;

int getgifpix(x,y)
int x, y;
{
    if(iscolor) {
	if(currow!= y) {
	    getrow(iimage,rbuf,iimage->ysize-1-y,0);
	    getrow(iimage,gbuf,iimage->ysize-1-y,1);
	    getrow(iimage,bbuf,iimage->ysize-1-y,2);
	    ditherrow(rbuf,gbuf,bbuf,obuf,iimage->xsize,y);
	    currow = y;
	}
	return obuf[x];
    } else {
	if(currow!= y) {
	    getrow(iimage,rbuf,iimage->ysize-1-y,0);
	    currow = y;
	}
	return rbuf[x];
    }
}

main( argc, argv )
int argc;
char *argv[];
{
    FILE *of;
    int xsize, ysize;
    int i, bpp;
    int r, g, b;

    if(argc<2) {
	fprintf(stderr,"usage: togif image.rgb image.gif\n");
	exit(1);
    }
    iimage = iopen(argv[1],"r");
    if(!iimage) {
	fprintf(stderr,"togif: can't open input image [%s]\n",argv[1]);
	exit(1);
    }
    xsize = iimage->xsize;
    ysize = iimage->ysize;
    if(iimage->zsize>=3) 
       iscolor = 1;
    else
       iscolor = 0;
    of = fopen(argv[2],"w");
    if(!of) {
	fprintf(stderr,"togif: can't open out image [%s]\n",argv[2]);
	exit(1);
    }
    if(iscolor) {
	for(i=0; i>0)&0x7;
	   g = (i>>3)&0x7;
	   b = (i>>6)&0x3;
	   rmap[i] = (255*r)/7;
	   gmap[i] = (255*g)/7;
	   bmap[i] = (255*b)/3;
	}
    } else {
	for(i=0; imatval) 
		    tabval =  (val/TOTAL)+1;
		else 
		    tabval = (val/TOTAL);
		tabval *= mult;
		tabval += add;
		tab[j][256*i+k] = tabval;
	    }
	}
    }
    return tab;
}

ditherrow(r,g,b,wp,n,y)
unsigned short *r, *g, *b;
short *wp;
int n, y;
{
    short *rbase;
    short *gbase;
    short *bbase;

    if(!rtab) {
	rtab = makedittab(8,1,0);
	gtab = makedittab(8,8,0);
	btab = makedittab(4,64,0);
    }
    rbase = rtab[WRAPY(y)];
    gbase = gtab[WRAPY(y)];
    bbase = btab[WRAPY(y)];
    while(n) {
	if(n>=XSIZE) {
	    *wp++ = rbase[*r++ +   0] + gbase[*g++ +   0] + bbase[*b++ +   0];
	    *wp++ = rbase[*r++ + 256] + gbase[*g++ + 256] + bbase[*b++ + 256];
	    *wp++ = rbase[*r++ + 512] + gbase[*g++ + 512] + bbase[*b++ + 512];
	    *wp++ = rbase[*r++ + 768] + gbase[*g++ + 768] + bbase[*b++ + 768];
	    n -= XSIZE;
	} else {
	    *wp++ = rbase[*r++] + gbase[*g++] + bbase[*b++];
	    rbase += 256;
	    gbase += 256;
	    bbase += 256;
	    n--;
	}
    }
}

/*
 * SCARY GIF code follows . . . . sorry.
 *
 * Based on GIFENCOD by David Rowley .A
 * Lempel-Zim compression based on "compress".
 *
 */

/*****************************************************************************
 *
 * GIFENCODE.C    - GIF Image compression interface
 *
 * GIFEncode( FName, GHeight, GWidth, GInterlace, Background,
 *            BitsPerPixel, Red, Green, Blue, GetPixel )
 *
 *****************************************************************************/
typedef int (* ifunptr)();

#define TRUE 1
#define FALSE 0

int Width, Height;
int curx, cury;
long CountDown;
int Pass = 0;
int Interlace;

/*
 * Bump the 'curx' and 'cury' to point to the next pixel
 */
BumpPixel()
{
    curx++;
    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;
	    }
	}
    }
}

/*
 * Return the next pixel from the image
 */
GIFNextPixel( getpixel )
ifunptr getpixel;
{
    int r;

    if( CountDown == 0 )
	return EOF;
    CountDown--;
    r = (*getpixel)( curx, cury );
    BumpPixel();
    return r;
}

/*
 * public GIFEncode
 */
GIFEncode( fp, GWidth, GHeight, GInterlace, Background,
           BitsPerPixel, Red, Green, Blue, GetPixel )
FILE *fp;
int GWidth, GHeight;
int GInterlace;
int Background;
int BitsPerPixel;
int Red[], Green[], Blue[];
ifunptr GetPixel;
{
    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;

    CountDown = (long)Width * (long)Height;
    Pass = 0;
    if( BitsPerPixel <= 1 )
	InitCodeSize = 2;
    else
	InitCodeSize = BitsPerPixel;
    curx = cury = 0;
    fwrite( "GIF87a", 1, 6, fp );
    Putword( RWidth, fp );
    Putword( RHeight, fp );
    B = 0x80;       /* Yes, there is a color map */
    B |= (Resolution - 1) << 5;
    B |= (BitsPerPixel - 1);
    fputc( B, fp );
    fputc( Background, fp );
    fputc( 0, fp );
    for( i=0; i

#define ARGVAL() (*++(*argv) || (--argc && *++argv))

int n_bits;                        /* number of bits/code */
int maxbits = BITS;                /* user settable max # bits/code */
code_int maxcode;                  /* maximum code, given n_bits */
code_int maxmaxcode = (code_int)1 << BITS; /* should NEVER generate this code */
# define MAXCODE(n_bits)        (((code_int) 1 << (n_bits)) - 1)

count_int htab [HSIZE];
unsigned short codetab [HSIZE];
#define HashTabOf(i)       htab[i]
#define CodeTabOf(i)    codetab[i]

code_int hsize = HSIZE;                 /* for dynamic table sizing */
count_int fsize;

/*
 * To save much memory, we overlay the table used by compress() with those
 * used by decompress().  The tab_prefix table is the same size and type
 * as the codetab.  The tab_suffix table needs 2**BITS characters.  We
 * get this from the beginning of htab.  The output stack uses the rest
 * of htab, and contains characters.  There is plenty of room for any
 * possible stack (stack used to be 8000 characters).
 */
#define tab_prefixof(i) CodeTabOf(i)
#define tab_suffixof(i)        ((char_type *)(htab))[i]
#define de_stack               ((char_type *)&tab_suffixof((code_int)1< 0 )
            goto probe;
nomatch:
        output ( (code_int) ent );
        out_count++;
        ent = c;
        if ( free_ent < maxmaxcode ) {
            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 );
    return;
}

/*****************************************************************
 * TAG( output )
 *
 * Output the given code.
 * Inputs:
 *      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
 *              that n_bits =< (long)wordsize - 1.
 * Outputs:
 *      Outputs code to the file.
 * Assumptions:
 *      Chars are 8 bits long.
 * Algorithm:
 *      Maintain a BITS character long buffer (so that 8 codes will
 * fit in it exactly).  Use the VAX insv instruction to insert each
 * code in turn.  When the buffer fills up empty it and start over.
 */

unsigned long cur_accum = 0;
int cur_bits = 0;

unsigned long masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
                                  0x001F, 0x003F, 0x007F, 0x00FF,
                                  0x01FF, 0x03FF, 0x07FF, 0x0FFF,
                                  0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };

output( code )
code_int  code;
{
    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();
        fflush( g_outfile );
        if( ferror( g_outfile ) )
                writeerr();
    }
}

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

cl_hash(hsize)          /* reset code table */
register count_int hsize;
{
        register count_int *htab_p = htab+hsize;
        register long i;
        register 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;
}

writeerr()
{
        printf( "error writing output file\n" );
        exit(1);
}

/******************************************************************************
 *
 * GIF Specific routines
 *
 ******************************************************************************/

/*
 * Number of characters so far in this 'packet'
 */
int a_count;

/*
 * Set up the 'byte output' routine
 */
char_init()
{
        a_count = 0;
}

/*
 * Define the storage for the packet accumulator
 */
char accum[ 256 ];

/*
 * Add a character to the end of the current packet, and if it is 254
 * characters, flush the packet to disk.
 */
char_out( c )
int c;
{
        accum[ a_count++ ] = c;
        if( a_count >= 254 )
                flush_char();
}

/*
 * Flush the packet to disk, and reset the accumulator
 */
flush_char()
{
        if( a_count > 0 ) {
                fputc( a_count, g_outfile );
                fwrite( accum, 1, a_count, g_outfile );
                a_count = 0;
        }
}