summaryrefslogtreecommitdiffstats
path: root/hl/tools/gif2h5/hdfgifwr.c
diff options
context:
space:
mode:
Diffstat (limited to 'hl/tools/gif2h5/hdfgifwr.c')
-rw-r--r--hl/tools/gif2h5/hdfgifwr.c528
1 files changed, 262 insertions, 266 deletions
diff --git a/hl/tools/gif2h5/hdfgifwr.c b/hl/tools/gif2h5/hdfgifwr.c
index 62b3eae..e5f79e2 100644
--- a/hl/tools/gif2h5/hdfgifwr.c
+++ b/hl/tools/gif2h5/hdfgifwr.c
@@ -1,17 +1,17 @@
/*
+ * Copyright (C) 2001 National Center for Supercomputing Applications
+ * All rights reserved.
+ *
* hdfgifwr.c - handles writing of GIF files.
*
* Contains:
* hdfWriteGIF(fp, pic, ptype, w, h, rmap, gmap, bmap, numcols, colorstyle,
- * comment)
+ * comment)
*
* Note: slightly brain-damaged, in that it'll only write non-interlaced
* GIF files (in the interests of speed, or something)
- *
*/
-
-
/*****************************************************************
* Portions of this code Copyright (C) 1989 by Michael Mauldin.
* Permission is granted to use this file in whole or in
@@ -36,10 +36,11 @@
#include <stdio.h>
-#include "gif.h"
#include <stdlib.h>
#include <string.h>
+#include "gif.h"
+
typedef BYTE byte;
typedef long int count_int;
@@ -77,59 +78,58 @@ static void flush_char(void);
#else
static void compress(), output(), cl_block(), cl_hash();
static void char_init(), char_out(), flush_char();
-#endif
+#endif /* __STDC__ */
static byte pc2nc[256],r1[256],g1[256],b1[256];
/*************************************************************/
int hdfWriteGIF(FILE *fp, byte *pic, int ptype, int w, int h, byte *rmap,
- byte *gmap, byte *bmap, byte *pc2ncmap, int numcols, int colorstyle,
- int BitsPerPixel)
+ byte *gmap, byte *bmap, byte *pc2ncmap, int numcols,
+ int colorstyle, int BitsPerPixel)
{
- int RWidth, RHeight;
- int LeftOfs, TopOfs;
- int ColorMapSize, InitCodeSize, Background;
- int i;
- byte *pic8;
- pic8 = pic;
-
- Interlace = 0;
- Background = 0;
-
- for (i=0; i<256; i++) {
- pc2nc[i] = pc2ncmap[i];
- r1[i] = rmap[i];
- g1[i] = gmap[i];
- b1[i] = bmap[i];
- }
-
- ColorMapSize = 1 << BitsPerPixel;
-
- RWidth = Width = w;
- RHeight = Height = h;
- LeftOfs = TopOfs = 0;
-
- CountDown = w * h; /* # of pixels we'll be doing */
-
- if (BitsPerPixel <= 1) InitCodeSize = 2;
- else InitCodeSize = BitsPerPixel;
-
- curx = cury = 0;
-
- if (!fp) {
- fprintf(stderr, "WriteGIF: file not open for writing\n" );
- return (1);
- }
-
- compress(InitCodeSize+1, fp, pic8, w*h);
-
-
- if (ferror(fp)) return -1;
- return (0);
-}
+ int RWidth, RHeight;
+ int LeftOfs, TopOfs;
+ int ColorMapSize, InitCodeSize, Background;
+ int i;
+ byte *pic8 = pic;
+
+ Interlace = 0;
+ Background = 0;
+
+ for (i = 0; i < 256; i++) {
+ pc2nc[i] = pc2ncmap[i];
+ r1[i] = rmap[i];
+ g1[i] = gmap[i];
+ b1[i] = bmap[i];
+ }
+
+ ColorMapSize = 1 << BitsPerPixel;
+
+ RWidth = Width = w;
+ RHeight = Height = h;
+ LeftOfs = TopOfs = 0;
+ CountDown = w * h; /* # of pixels we'll be doing */
+ if (BitsPerPixel <= 1)
+ InitCodeSize = 2;
+ else
+ InitCodeSize = BitsPerPixel;
+
+ curx = cury = 0;
+
+ if (!fp) {
+ fprintf(stderr, "WriteGIF: file not open for writing\n" );
+ return (1);
+ }
+
+ compress(InitCodeSize+1, fp, pic8, w*h);
+
+ if (ferror(fp))
+ return -1;
+ return 0 ;
+}
/***********************************************************************/
static unsigned long cur_accum = 0;
@@ -142,6 +142,7 @@ static int cur_bits = 0;
#define HSIZE 5003 /* 80% occupancy */
typedef unsigned char char_type;
+
static int n_bits; /* number of bits/code */
static int maxbits = XV_BITS; /* user settable max # bits/code */
static int maxcode; /* maximum code, given n_bits */
@@ -149,6 +150,7 @@ static int maxmaxcode = 1 << XV_BITS; /* NEVER generate this */
static count_int htab [HSIZE];
static unsigned short codetab [HSIZE];
+
#define HashTabOf(i) htab[i]
#define CodeTabOf(i) codetab[i]
@@ -156,11 +158,11 @@ static int hsize = HSIZE; /* for dynamic table sizing */
/*
* 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).
+ * 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)
@@ -181,17 +183,17 @@ static long int out_count = 0; /* # of codes output (for debugging) */
/*
* compress stdin to stdout
*
- * Algorithm: use open addressing double hashing (no chaining) on the
- * prefix code / next character combination. We do a variant of Knuth's
- * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
- * secondary probe. Here, the modular division first probe is gives way
- * to a faster exclusive-or manipulation. Also do block compression with
- * an adaptive reset, whereby the code table is cleared when the compression
- * ratio decreases, but after the table fills. The variable-length output
- * codes are re-sized at this point, and a special CLEAR code is generated
- * for the decompressor. Late addition: construct the table according to
- * file size for noticeable speed improvement on small files. Please direct
- * questions about this implementation to ames!jaw.
+ * Algorithm: use open addressing double hashing (no chaining) on the prefix
+ * code / next character combination. We do a variant of Knuth's algorithm D
+ * (vol. 3, sec. 6.4) along with G. Knott's relatively-prime secondary probe.
+ * Here, the modular division first probe is gives way to a faster
+ * exclusive-or manipulation. Also do block compression with an adaptive
+ * reset, whereby the code table is cleared when the compression ratio
+ * decreases, but after the table fills. The variable-length output codes are
+ * re-sized at this point, and a special CLEAR code is generated for the
+ * decompressor. Late addition: construct the table according to file size
+ * for noticeable speed improvement on small files. Please direct questions
+ * about this implementation to ames!jaw.
*/
static int g_init_bits;
@@ -201,114 +203,111 @@ static int ClearCode;
static int EOFCode;
/********************************************************/
-static void compress(init_bits, outfile, data, len)
-int init_bits;
-FILE *outfile;
-byte *data;
-int len;
+static void compress(int init_bits, FILE *outfile, byte *data, int len)
{
- register long fcode;
- register int i = 0;
- register int c;
- register int ent;
- register int disp;
- register int hsize_reg;
- register int hshift;
-
- /*
- * Set up the globals: g_init_bits - initial number of bits
- * g_outfile - pointer to output file
- */
- g_init_bits = init_bits;
- g_outfile = outfile;
-
- /* initialize 'compress' globals */
- maxbits = XV_BITS;
- maxmaxcode = 1<<XV_BITS;
- memset(htab, 0, sizeof(htab));
- memset(codetab, 0, sizeof(codetab));
- hsize = HSIZE;
- free_ent = 0;
- clear_flg = 0;
- in_count = 1;
- out_count = 0;
- cur_accum = 0;
- cur_bits = 0;
-
-
- /*
- * Set up the necessary values
- */
- 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 = pc2nc[*data++]; len--;
-
- 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(ClearCode);
-
- while (len) {
- c = pc2nc[*data++]; len--;
- in_count++;
-
- fcode = (long) ( ( (long) c << maxbits) + ent);
- i = (((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;
+ register long fcode;
+ register int i = 0;
+ register int c;
+ register int ent;
+ register int disp;
+ register int hsize_reg;
+ register int hshift;
+
+ /*
+ * Set up the globals: g_init_bits - initial number of bits g_outfile -
+ * pointer to output file
+ */
+ g_init_bits = init_bits;
+ g_outfile = outfile;
+
+ /* initialize 'compress' globals */
+ maxbits = XV_BITS;
+ maxmaxcode = 1<<XV_BITS;
+ memset(htab, 0, sizeof(htab));
+ memset(codetab, 0, sizeof(codetab));
+ hsize = HSIZE;
+ free_ent = 0;
+ clear_flg = 0;
+ in_count = 1;
+ out_count = 0;
+ cur_accum = 0;
+ cur_bits = 0;
+
+ /* Set up the necessary values */
+ 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 = pc2nc[*data++];
+ len--;
+
+ 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(ClearCode);
+
+ while (len) {
+ c = pc2nc[*data++];
+ len--;
+ in_count++;
+
+ fcode = (long)(((long) c << maxbits) + ent);
+ i = (((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 ((i -= disp) < 0)
+ i += hsize_reg;
- if ( HashTabOf (i) == fcode ) {
- ent = CodeTabOf (i);
- continue;
- }
+ if (HashTabOf (i) == fcode) {
+ ent = CodeTabOf (i);
+ continue;
+ }
- if ( (long)HashTabOf (i) >= 0 )
- goto probe;
+ if ((long)HashTabOf (i) >= 0)
+ goto probe;
nomatch:
- output(ent);
- out_count++;
- ent = c;
-
- if ( free_ent < maxmaxcode ) {
- CodeTabOf (i) = free_ent++; /* code -> hashtable */
- HashTabOf (i) = fcode;
+ output(ent);
+ out_count++;
+ ent = c;
+
+ if (free_ent < maxmaxcode) {
+ CodeTabOf (i) = free_ent++; /* code -> hashtable */
+ HashTabOf (i) = fcode;
+ } else {
+ cl_block();
+ }
}
- else
- cl_block();
- }
- /* Put out the final code */
- output(ent);
- out_count++;
- output(EOFCode);
+ /* Put out the final code */
+ output(ent);
+ out_count++;
+ output(EOFCode);
}
@@ -335,111 +334,104 @@ unsigned long masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
0x01FF, 0x03FF, 0x07FF, 0x0FFF,
0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
-static void output(code)
-int code;
+static void
+output(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( (int)((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( (int)((unsigned int)cur_accum & 0xff) );
- cur_accum >>= 8;
- cur_bits -= 8;
+ 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( (int)((unsigned int) cur_accum & 0xff) );
+ cur_accum >>= 8;
+ cur_bits -= 8;
}
- flush_char();
-
- fflush( g_outfile );
+ /*
+ * 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( (int)((unsigned int)cur_accum & 0xff) );
+ cur_accum >>= 8;
+ cur_bits -= 8;
+ }
+
+ flush_char();
+ fflush( g_outfile );
#ifdef FOO
- if( ferror( g_outfile ) )
- FatalError("unable to write GIF file");
+ if(ferror( g_outfile))
+ FatalError("unable to write GIF file");
#endif
- }
+ }
}
-
/********************************/
-static void cl_block () /* table clear for block compress */
+static void
+cl_block(void) /* table clear for block compress */
{
- /* Clear out the hash table */
-
- cl_hash ( (count_int) hsize );
- free_ent = ClearCode + 2;
- clear_flg = 1;
-
- output(ClearCode);
+ /* Clear out the hash table */
+ cl_hash((count_int) hsize);
+ free_ent = ClearCode + 2;
+ clear_flg = 1;
+ output(ClearCode);
}
-
/********************************/
-static void cl_hash(hashsize) /* reset code table */
-count_int hashsize;
+static void
+cl_hash(count_int hashsize) /* reset code table */
{
- count_int *htab_p = htab+hashsize;
- long i;
- long m1 = -1;
-
- i = hashsize - 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;
+ count_int *htab_p = htab+hashsize;
+ long i, m1 = -1;
+
+ i = hashsize - 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;
}
-
/******************************************************************************
*
* GIF Specific routines
@@ -454,9 +446,10 @@ static int a_count;
/*
* Set up the 'byte output' routine
*/
-static void char_init()
+static void
+char_init(void)
{
- a_count = 0;
+ a_count = 0;
}
/*
@@ -468,21 +461,24 @@ static char accum[ 256 ];
* Add a character to the end of the current packet, and if it is 254
* characters, flush the packet to disk.
*/
-static void char_out(int c)
+static void
+char_out(int c)
{
- accum[ a_count++ ] = c;
- if( a_count >= 254 )
- flush_char();
+ accum[ a_count++ ] = c;
+
+ if (a_count >= 254)
+ flush_char();
}
/*
* Flush the packet to disk, and reset the accumulator
*/
-static void flush_char()
+static void
+flush_char(void)
{
- if( a_count > 0 ) {
- fputc( a_count, g_outfile );
- fwrite( accum, 1, (size_t)a_count, g_outfile );
- a_count = 0;
- }
-}
+ if (a_count > 0) {
+ fputc( a_count, g_outfile );
+ fwrite( accum, 1, (size_t)a_count, g_outfile);
+ a_count = 0;
+ }
+}
generated by cgit v0.12 at 2024-11-09 09:30:34 (GMT)