/* * Reset encoding state at the start of a strip. */ static int LZWPreEncode(TIFF* tif, uint16 s) { LZWCodecState *sp = EncoderState(tif); (void) s; assert(sp != NULL); if( sp->enc_hashtab == NULL ) { tif->tif_setupencode( tif ); } sp->lzw_nbits = BITS_MIN; sp->lzw_maxcode = MAXCODE(BITS_MIN); sp->lzw_free_ent = CODE_FIRST; sp->lzw_nextbits = 0; sp->lzw_nextdata = 0; sp->enc_checkpoint = CHECK_GAP; sp->enc_ratio = 0; sp->enc_incount = 0; sp->enc_outcount = 0; /* * The 4 here insures there is space for 2 max-sized * codes in LZWEncode and LZWPostDecode. */ sp->enc_rawlimit = tif->tif_rawdata + tif->tif_rawdatasize-1 - 4; cl_hash(sp); /* clear hash table */ sp->enc_oldcode = (hcode_t) -1; /* generates CODE_CLEAR in LZWEncode */ return (1); }
/* * Clear out the hash table */ static void cl_block (void) /* table clear for block compress */ { cl_hash ( (count_int) hsize ); free_ent = ClearCode + 2; clear_flg = 1; output( (code_int)ClearCode ); }
static void cl_block (count_int *htab, struct aap *a) /* table clear for block compress */ { /* Clear out the hash table */ cl_hash ( (count_int)HSIZE, htab ); a->free_ent = a->ClearCode + 2; a->clear_flg = 1; output(a->ClearCode, a); }
/* * Encode a chunk of pixels. * * Uses an 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 CODE_CLEAR is generated * for the decoder. */ static int LZWEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s) { register LZWCodecState *sp = EncoderState(tif); register long fcode; register hash_t *hp; register int h, c; hcode_t ent; long disp; long incount, outcount, checkpoint; unsigned long nextdata; long nextbits; int free_ent, maxcode, nbits; uint8* op; uint8* limit; (void) s; if (sp == NULL) return (0); assert(sp->enc_hashtab != NULL); /* * Load local state. */ incount = sp->enc_incount; outcount = sp->enc_outcount; checkpoint = sp->enc_checkpoint; nextdata = sp->lzw_nextdata; nextbits = sp->lzw_nextbits; free_ent = sp->lzw_free_ent; maxcode = sp->lzw_maxcode; nbits = sp->lzw_nbits; op = tif->tif_rawcp; limit = sp->enc_rawlimit; ent = (hcode_t)sp->enc_oldcode; if (ent == (hcode_t) -1 && cc > 0) { /* * NB: This is safe because it can only happen * at the start of a strip where we know there * is space in the data buffer. */ PutNextCode(op, CODE_CLEAR); ent = *bp++; cc--; incount++; } while (cc > 0) { c = *bp++; cc--; incount++; fcode = ((long)c << BITS_MAX) + ent; h = (c << HSHIFT) ^ ent; /* xor hashing */ #ifdef _WINDOWS /* * Check hash index for an overflow. */ if (h >= HSIZE) h -= HSIZE; #endif hp = &sp->enc_hashtab[h]; if (hp->hash == fcode) { ent = hp->code; continue; } if (hp->hash >= 0) { /* * Primary hash failed, check secondary hash. */ disp = HSIZE - h; if (h == 0) disp = 1; do { /* * Avoid pointer arithmetic because of * wraparound problems with segments. */ if ((h -= disp) < 0) h += HSIZE; hp = &sp->enc_hashtab[h]; if (hp->hash == fcode) { ent = hp->code; goto hit; } } while (hp->hash >= 0); } /* * New entry, emit code and add to table. */ /* * Verify there is space in the buffer for the code * and any potential Clear code that might be emitted * below. The value of limit is setup so that there * are at least 4 bytes free--room for 2 codes. */ if (op > limit) { tif->tif_rawcc = (tmsize_t)(op - tif->tif_rawdata); if( !TIFFFlushData1(tif) ) return 0; op = tif->tif_rawdata; } PutNextCode(op, ent); ent = (hcode_t)c; hp->code = (hcode_t)(free_ent++); hp->hash = fcode; if (free_ent == CODE_MAX-1) { /* table is full, emit clear code and reset */ cl_hash(sp); sp->enc_ratio = 0; incount = 0; outcount = 0; free_ent = CODE_FIRST; PutNextCode(op, CODE_CLEAR); nbits = BITS_MIN; maxcode = MAXCODE(BITS_MIN); } else { /* * If the next entry is going to be too big for * the code size, then increase it, if possible. */ if (free_ent > maxcode) { nbits++; assert(nbits <= BITS_MAX); maxcode = (int) MAXCODE(nbits); } else if (incount >= checkpoint) { long rat; /* * Check compression ratio and, if things seem * to be slipping, clear the hash table and * reset state. The compression ratio is a * 24+8-bit fractional number. */ checkpoint = incount+CHECK_GAP; CALCRATIO(sp, rat); if (rat <= sp->enc_ratio) { cl_hash(sp); sp->enc_ratio = 0; incount = 0; outcount = 0; free_ent = CODE_FIRST; PutNextCode(op, CODE_CLEAR); nbits = BITS_MIN; maxcode = MAXCODE(BITS_MIN); } else sp->enc_ratio = rat; } } hit: ; } /* * Restore global state. */ sp->enc_incount = incount; sp->enc_outcount = outcount; sp->enc_checkpoint = checkpoint; sp->enc_oldcode = ent; sp->lzw_nextdata = nextdata; sp->lzw_nextbits = nextbits; sp->lzw_free_ent = (unsigned short)free_ent; sp->lzw_maxcode = (unsigned short)maxcode; sp->lzw_nbits = (unsigned short)nbits; tif->tif_rawcp = op; return (1); }
void compress(void) { register long fcode; register code_int i = 0; register int c; register code_int ent; register int disp; register code_int hsize_reg; register int hshift; offset = 0; bytes_out = 3; out_count = 0; clear_flg = 0; ratio = 0; in_count = 1; checkpoint = 10000; maxcode = ((1 << (n_bits = 9)) - 1); free_ent = ((block_compress) ? (257) : (256)); ent = getbyte(); hshift = 0; for (fcode = (long) hsize; fcode < 65536L; fcode *= 2L) { hshift++; } hshift = 8 - hshift; hsize_reg = hsize; cl_hash((count_int) hsize_reg); while (InCnt > 0) { int apsim_bound111 = 0; c = getbyte(); in_count++; fcode = (long) (((long) c << maxbits) + ent); i = ((c << hshift) ^ ent); if (htab[i] == fcode) { ent = codetab[i]; continue; } else if ((long) htab[i] < 0) { goto nomatch; } disp = hsize_reg - i; if (i == 0) { disp = 1; } probe: if ((i -= disp) < 0) { i += hsize_reg; } if (htab[i] == fcode) { ent = codetab[i]; continue; } if ((long) htab[i] > 0 && (++apsim_bound111 < in_count)) goto probe; nomatch: out_count++; ent = c; if (free_ent < maxmaxcode) { codetab[i] = free_ent++; htab[i] = fcode; } else if (((count_int) in_count >= checkpoint) && (block_compress)) { cl_block(); } } if (bytes_out > in_count) { exit_stat = 2; } return; }
/*- * compress write * * 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 zwrite(void *cookie, const char *wbp, int num) { code_int i; int c, disp; struct s_zstate *zs; const u_char *bp; u_char tmp; int count; if (num == 0) return (0); zs = cookie; count = num; bp = wbp; if (state == S_MIDDLE) goto middle; state = S_MIDDLE; maxmaxcode = 1L << maxbits; if (fwrite(magic_header, sizeof(char), sizeof(magic_header), fp) != sizeof(magic_header)) return (-1); tmp = (u_char)((maxbits) | block_compress); if (fwrite(&tmp, sizeof(char), sizeof(tmp), fp) != sizeof(tmp)) return (-1); offset = 0; bytes_out = 3; /* Includes 3-byte header mojo. */ out_count = 0; clear_flg = 0; ratio = 0; in_count = 1; checkpoint = CHECK_GAP; maxcode = MAXCODE(n_bits = INIT_BITS); free_ent = ((block_compress) ? FIRST : 256); ent = *bp++; --count; hshift = 0; for (fcode = (long)hsize; fcode < 65536L; fcode *= 2L) hshift++; hshift = 8 - hshift; /* Set hash code range bound. */ hsize_reg = hsize; cl_hash(zs, (count_int)hsize_reg); /* Clear hash table. */ middle: for (i = 0; count--;) { c = *bp++; in_count++; fcode = (long)(((long)c << maxbits) + ent); i = ((c << hshift) ^ ent); /* Xor hashing. */ if (htabof(i) == fcode) { ent = codetabof(i); continue; } else if ((long)htabof(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 (htabof(i) == fcode) { ent = codetabof(i); continue; } if ((long)htabof(i) >= 0) goto probe; nomatch: if (output(zs, (code_int) ent) == -1) return (-1); out_count++; ent = c; if (free_ent < maxmaxcode) { codetabof(i) = free_ent++; /* code -> hashtable */ htabof(i) = fcode; } else if ((count_int)in_count >= checkpoint && block_compress) { if (cl_block(zs) == -1) return (-1); } } return (num); }
int main() { register long fcode; register code_int i = 0; register int c; register code_int ent; #ifdef XENIX_16 register code_int disp; #else /* Normal machine */ register int disp; #endif register code_int hsize_reg; register int hshift; #ifndef COMPATIBLE if (nomagic == 0) { /* putchar(magic_header[0]); putchar(magic_header[1]); putchar((char)(maxbits | block_compress)); */ } #endif /* COMPATIBLE */ offset = 0; bytes_out = 3; /* includes 3-byte header mojo */ out_count = 0; clear_flg = 0; ratio = 0; in_count = 1; printf("main: bytes_out %d... hsize %d\n", (int)bytes_out, (int)hsize); checkpoint = CHECK_GAP; maxcode = MAXCODE(n_bits = INIT_BITS); free_ent = ((block_compress) ? FIRST : 256 ); ent = '\0'; /* getchar (); */ hshift = 0; for ( fcode = (long) hsize; fcode < 65536L; fcode *= 2L ) hshift++; hshift = 8 - hshift; /* set hash code range bound */ printf("main: hshift %d...\n", hshift); hsize_reg = hsize; cl_hash( (count_int) hsize_reg); /* clear hash table */ /*#ifdef SIGNED_COMPARE_SLOW while ( (c = getchar()) != (unsigned) EOF ) { #else while ( (c = getchar()) != EOF ) { #endif*/ printf("main: bytes_out %d...\n", (int)bytes_out); printf("main: hsize_reg %d...\n", (int)hsize_reg); printf("main: before compress %d...\n", (int)in_count); while (in_count < BYTES_TO_COMPRESS) { c = in_count % 255; printf("main: compressing %d...\n", (int)in_count); in_count++; fcode = (long) (((long) c << maxbits) + ent); i = (((long)c << hshift) ^ ent); /* xor hashing */ if ( htabof (i) == fcode ) { ent = codetabof (i); continue; } else if ( (long)htabof (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 ( htabof (i) == fcode ) { ent = codetabof (i); continue; } if ( (long)htabof (i) > 0 ) goto probe; nomatch: output ( (code_int) ent ); out_count++; ent = c; #ifdef SIGNED_COMPARE_SLOW if ( (unsigned) free_ent < (unsigned) maxmaxcode) { #else if ( free_ent < maxmaxcode ) { #endif codetabof (i) = free_ent++; /* code -> hashtable */ htabof (i) = fcode; } else if ( (count_int)in_count >= checkpoint && block_compress ) cl_block (); } /* * Put out the final code. */ printf("main: output...\n"); output( (code_int)ent ); out_count++; output( (code_int)-1 ); if(bytes_out > in_count) /* exit(2) if no savings */ exit_stat = 2; printf("main: end...\n"); report (0xdeaddead); return 0; } /***************************************************************** * 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. */ static char buf[BITS]; #ifndef vax char_type lmask[9] = {0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00}; char_type rmask[9] = {0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff}; #endif /* vax */ void output( code ) code_int code; { /* * On the VAX, it is important to have the register declarations * in exactly the order given, or the asm will break. */ register int r_off = offset, bits= n_bits; register char * bp = buf; if ( code >= 0 ) { #ifdef vax /* VAX DEPENDENT!! Implementation on other machines is below. * * Translation: Insert BITS bits from the argument starting at * offset bits from the beginning of buf. */ 0; /* Work around for pcc -O bug with asm and if stmt */ asm( "insv 4(ap),r11,r10,(r9)" ); #else /* not a vax */ /* * byte/bit numbering on the VAX is simulated by the following code */ /* * Get to the first byte. */ bp += (r_off >> 3); r_off &= 7; /* * Since code is always >= 8 bits, only need to mask the first * hunk on the left. */ *bp = (*bp & rmask[r_off]) | ((code << r_off) & lmask[r_off]); bp++; bits -= (8 - r_off); code >>= 8 - r_off; /* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */ if ( bits >= 8 ) { *bp++ = code; code >>= 8; bits -= 8; } /* Last bits. */ if(bits) *bp = code; #endif /* vax */ offset += n_bits; if ( offset == (n_bits << 3) ) { bp = buf; bits = n_bits; bytes_out += bits; /* do putchar(*bp++); */ while(--bits); offset = 0; } /* * 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 > 0)) { /* * Write the whole buffer, because the input side won't * discover the size increase until after it has read it. */ if ( offset > 0 ) { /* if( fwrite( buf, 1, n_bits, stdout ) != n_bits) writeerr(); */ bytes_out += n_bits; } offset = 0; if ( clear_flg ) { maxcode = MAXCODE (n_bits = INIT_BITS); clear_flg = 0; } else { n_bits++; if ( n_bits == maxbits ) maxcode = maxmaxcode; else maxcode = MAXCODE(n_bits); } } } else {
void compress(void) { register long fcode; register code_int i = 0; register int c; register code_int ent; register int disp; register code_int hsize_reg; register int hshift; offset = 0; bytes_out = 3; /* includes 3-byte header mojo */ out_count = 0; clear_flg = 0; ratio = 0; in_count = 1; checkpoint = CHECK_GAP; maxcode = MAXCODE(n_bits = INIT_BITS); free_ent = ((block_compress) ? (FIRST) : (256)); ent = getbyte(); 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 */ while (InCnt > 0) { /* apsim_loop 11 0 */ int apsim_bound111 = 0; c = getbyte(); /* decrements InCnt */ in_count++; fcode = (long) (((long) c << maxbits) + ent); i = ((c << hshift) ^ ent); /* xor hashing */ if (htabof(i) == fcode) { ent = codetabof(i); continue; } else if ((long) htabof(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) { /* apsim_loop 111 11 */ i += hsize_reg; } if (htabof(i) == fcode) { ent = codetabof(i); continue; } if ((long) htabof(i) > 0 && (++apsim_bound111 < in_count)) goto probe; nomatch: out_count++; ent = c; if (free_ent < maxmaxcode) { codetabof(i) = free_ent++; /* apsim_unknown codetab */ htabof(i) = fcode; /* apsim_unknown htab */ } else if (((count_int) in_count >= checkpoint) && (block_compress)) { cl_block(); } } if (bytes_out > in_count) { /* exit(2) if no savings */ exit_stat = 2; } return; }
static void compress(int init_bits, FILE *outfile, byte *data, int len, struct aap *a) { register long fcode; register int i = 0; register int c; register int ent; register int disp; register int hsize_reg; register int hshift; unsigned short codetab [HSIZE]; count_int htab [HSIZE]; /* * Set up the globals: g_init_bits - initial number of bits * g_outfile - pointer to output file */ a->g_init_bits = init_bits; a->g_outfile = outfile; /* initialize 'compress' globals */ memset((char *) htab, 0, sizeof(htab)); memset((char *) codetab, 0, sizeof(codetab)); a->free_ent = 0; a->clear_flg = 0; a->cur_accum = 0; a->cur_bits = 0; /* * Set up the necessary values */ a->clear_flg = 0; a->maxcode = MAXCODE(a->n_bits = a->g_init_bits); a->ClearCode = (1 << (init_bits - 1)); a->EOFCode = a->ClearCode + 1; a->free_ent = a->ClearCode + 2; a->a_count = 0; ent = a->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, htab); /* clear hash table */ output(a->ClearCode, a); while (len) { c = a->pc2nc[*data++]; len--; fcode = (long) ( ( (long) c << XV_BITS) + ent); i = (((int) c << hshift) ^ ent); /* xor hashing */ if ( htab[i] == fcode ) { ent = codetab[i]; continue; } else if ( (long)htab[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 ( htab[i] == fcode ) { ent = codetab[i]; continue; } if ( (long)htab[i] >= 0 ) goto probe; nomatch: output(ent, a); ent = c; if ( a->free_ent < (1<<XV_BITS) ) { codetab[i] = a->free_ent++; /* code -> hashtable */ htab[i] = fcode; } else cl_block(htab, a); } /* Put out the final code */ output(ent, a); output(a->EOFCode, a); }
static void compress( int init_bits, FILE *outfile, ifun_t* ReadValue ) { register long fcode; register code_int i = 0; register int c; register code_int ent; register code_int disp; register code_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; /* * 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( ReadValue ); 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 ); while ( (c = GIFNextPixel( ReadValue )) != EOF ) { in_count++; fcode = (long) (((long) c << maxbits) + ent); /* i = (((code_int)c << hshift) ~ ent); */ /* xor hashing */ 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; 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; }
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; 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(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(ent); out_count++; output(EOFCode); }
static void compress(int init_bits, gdIOCtxPtr outfile, gdImagePtr im, GifCtx *ctx) { register long fcode; register code_int i /* = 0 */; register int c; register code_int ent; register code_int disp; register code_int hsize_reg; register int hshift; /* * Set up the globals: g_init_bits - initial number of bits * g_outfile - pointer to output file */ ctx->g_init_bits = init_bits; ctx->g_outfile = outfile; /* * Set up the necessary values */ ctx->offset = 0; ctx->out_count = 0; ctx->clear_flg = 0; ctx->in_count = 1; ctx->maxcode = MAXCODE(ctx->n_bits = ctx->g_init_bits); ctx->ClearCode = (1 << (init_bits - 1)); ctx->EOFCode = ctx->ClearCode + 1; ctx->free_ent = ctx->ClearCode + 2; char_init(ctx); ent = GIFNextPixel( im, ctx ); 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, ctx ); /* clear hash table */ output( (code_int)ctx->ClearCode, ctx ); #ifdef SIGNED_COMPARE_SLOW while ( (c = GIFNextPixel( im )) != (unsigned) EOF ) { #else /*SIGNED_COMPARE_SLOW*/ while ( (c = GIFNextPixel( im, ctx )) != EOF ) { /* } */ #endif /*SIGNED_COMPARE_SLOW*/ ++(ctx->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, ctx ); ++(ctx->out_count); ent = c; #ifdef SIGNED_COMPARE_SLOW if ( (unsigned) ctx->free_ent < (unsigned) maxmaxcode) { #else /*SIGNED_COMPARE_SLOW*/ if ( ctx->free_ent < maxmaxcode ) { /* } */ #endif /*SIGNED_COMPARE_SLOW*/ CodeTabOf (i) = ctx->free_ent++; /* code -> hashtable */ HashTabOf (i) = fcode; } else cl_block(ctx); } /* * Put out the final code. */ output( (code_int)ent, ctx ); ++(ctx->out_count); output( (code_int) ctx->EOFCode, ctx ); } /***************************************************************** * 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 GIFBITS 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. */ static const unsigned long masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF }; /* Arbitrary value to mark output is done. When we see EOFCode, then we don't * expect to see any more data. If we do (e.g. corrupt image inputs), cur_bits * might be negative, so flag it to return early. */ #define CUR_BITS_FINISHED -1000 static void output(code_int code, GifCtx *ctx) { if (ctx->cur_bits == CUR_BITS_FINISHED) { return; } ctx->cur_accum &= masks[ ctx->cur_bits ]; if( ctx->cur_bits > 0 ) ctx->cur_accum |= ((long)code << ctx->cur_bits); else ctx->cur_accum = code; ctx->cur_bits += ctx->n_bits; while( ctx->cur_bits >= 8 ) { char_out( (unsigned int)(ctx->cur_accum & 0xff), ctx ); ctx->cur_accum >>= 8; ctx->cur_bits -= 8; } /* * If the next entry is going to be too big for the code size, * then increase it, if possible. */ if ( ctx->free_ent > ctx->maxcode || ctx->clear_flg ) { if( ctx->clear_flg ) { ctx->maxcode = MAXCODE (ctx->n_bits = ctx->g_init_bits); ctx->clear_flg = 0; } else { ++(ctx->n_bits); if ( ctx->n_bits == maxbits ) ctx->maxcode = maxmaxcode; else ctx->maxcode = MAXCODE(ctx->n_bits); } } if( code == ctx->EOFCode ) { /* * At EOF, write the rest of the buffer. */ while( ctx->cur_bits > 0 ) { char_out( (unsigned int)(ctx->cur_accum & 0xff), ctx); ctx->cur_accum >>= 8; ctx->cur_bits -= 8; } /* Flag that it's done to prevent re-entry. */ ctx->cur_bits = CUR_BITS_FINISHED; flush_char(ctx); } } /* * Clear out the hash table */ static void cl_block (GifCtx *ctx) /* table clear for block compress */ { cl_hash ( (count_int) hsize, ctx ); ctx->free_ent = ctx->ClearCode + 2; ctx->clear_flg = 1; output( (code_int)ctx->ClearCode, ctx); } static void cl_hash(register count_int chsize, GifCtx *ctx) /* reset code table */ { register count_int *htab_p = ctx->htab+chsize; register long i; register long m1 = -1; i = chsize - 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 * ******************************************************************************/ /* * Set up the 'byte output' routine */ static void char_init(GifCtx *ctx) { ctx->a_count = 0; } /* * 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, GifCtx *ctx) { ctx->accum[ ctx->a_count++ ] = c; if( ctx->a_count >= 254 ) flush_char(ctx); }
compress() { register long fcode; register code_int i = 0; register int c; register code_int ent; #ifdef XENIX_16 register code_int disp; #else /* Normal machine */ register int disp; #endif register code_int hsize_reg; register int hshift; #ifndef COMPATIBLE if (nomagic == 0) { putbyte(magic_header[0]); putbyte(magic_header[1]); putbyte((char)(maxbits | block_compress)); } #endif /* COMPATIBLE */ offset = 0; bytes_out = 3; /* includes 3-byte header mojo */ out_count = 0; clear_flg = 0; ratio = 0; in_count = 1; checkpoint = CHECK_GAP; maxcode = MAXCODE(n_bits = INIT_BITS); free_ent = ((block_compress) ? FIRST : 256 ); ent = getbyte (); 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 */ #ifdef SIGNED_COMPARE_SLOW while ( (c = getbyte()) != (unsigned) EOF ) { #else while ( (c = getbyte()) != EOF ) { #endif in_count++; fcode = (long) (((long) c << maxbits) + ent); i = ((c << hshift) ^ ent); /* xor hashing */ if ( htabof (i) == fcode ) { ent = codetabof (i); continue; } else if ( (long)htabof (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 ( htabof (i) == fcode ) { ent = codetabof (i); continue; } if ( (long)htabof (i) > 0 ) goto probe; nomatch: output ( (code_int) ent ); out_count++; ent = c; #ifdef SIGNED_COMPARE_SLOW if ( (unsigned) free_ent < (unsigned) maxmaxcode) { #else if ( free_ent < maxmaxcode ) { #endif codetabof (i) = free_ent++; /* code -> hashtable */ htabof (i) = fcode; } else if ( (count_int)in_count >= checkpoint && block_compress ) cl_block (); } /* * Put out the final code. */ output( (code_int)ent ); out_count++; output( (code_int)-1 ); /* * Print out stats on stderr */ if(zcat_flg == 0 && !quiet) { #ifdef DEBUG fprintf( stderr, "%ld chars in, %ld codes (%ld bytes) out, compression factor: ", in_count, out_count, bytes_out ); prratio( stderr, in_count, bytes_out ); fprintf( stderr, "\n"); fprintf( stderr, "\tCompression as in compact: " ); prratio( stderr, in_count-bytes_out, in_count ); fprintf( stderr, "\n"); fprintf( stderr, "\tLargest code (of last block) was %d (%d bits)\n", free_ent - 1, n_bits ); #else /* !DEBUG */ fprintf( stderr, "Compression: " ); prratio( stderr, in_count-bytes_out, in_count ); #endif /* DEBUG */ } if(bytes_out > in_count) /* exit(2) if no savings */ exit_stat = 2; 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. */ static char buf[BITS]; char_type lmask[9] = {0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80, 0x00}; char_type rmask[9] = {0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff}; output( code ) code_int code; { #ifdef DEBUG static int col = 0; #endif /* DEBUG */ /* * On the VAX, it is important to have the register declarations * in exactly the order given, or the asm will break. */ register int r_off = offset, bits= n_bits; register char * bp = buf; #ifdef DEBUG if ( verbose ) fprintf( stderr, "%5d%c", code, (col+=6) >= 74 ? (col = 0, '\n') : ' ' ); #endif /* DEBUG */ if ( code >= 0 ) { /* * byte/bit numbering on the VAX is simulated by the following code */ /* * Get to the first byte. */ bp += (r_off >> 3); r_off &= 7; /* * Since code is always >= 8 bits, only need to mask the first * hunk on the left. */ *bp = (*bp & rmask[r_off]) | (code << r_off) & lmask[r_off]; bp++; bits -= (8 - r_off); code >>= 8 - r_off; /* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */ if ( bits >= 8 ) { *bp++ = code; code >>= 8; bits -= 8; } /* Last bits. */ if(bits) *bp = code; offset += n_bits; if ( offset == (n_bits << 3) ) { bp = buf; bits = n_bits; bytes_out += bits; do putbyte(*bp++); while(--bits); offset = 0; } /* * 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 > 0)) { /* * Write the whole buffer, because the input side won't * discover the size increase until after it has read it. */ if ( offset > 0 ) { writebytes( buf, n_bits ); bytes_out += n_bits; } offset = 0; if ( clear_flg ) { maxcode = MAXCODE (n_bits = INIT_BITS); clear_flg = 0; } else { n_bits++; if ( n_bits == maxbits ) maxcode = maxmaxcode; else maxcode = MAXCODE(n_bits); } #ifdef DEBUG if ( debug ) { fprintf( stderr, "\nChange to %d bits\n", n_bits ); col = 0; } #endif /* DEBUG */ } } else { /* * At EOF, write the rest of the buffer. */ if ( offset > 0 )