File difference report generated by CSDiff by ComponentSoftware on 10/10/2004 10:19 PM

Base file: D:\Dev\cximage\libs\tiff-v3.5.7\libtiff\tif_lzw.c
Compared file: D:\Dev\cximage\cximage599b\tiff\tif_lzw.c

1c1
< /* $Header: /cvsroot/osrs/libtiff/libtiff/tif_lzw.c,v 1.9 2001/09/25 01:59:13 warmerda Exp $ */
---
> /* $Header: /cvsroot/libtiff-lzw-compression-kit/tif_lzw.c,v 1.2 2001/09/25 02:14:31 warmerda Exp $ */
99a100,101
> 
>         int             rw_mode;        /* preserve rw_mode from init */
639a642,918
> /*
>  * LZW Encoding.
>  */
> 
> static int
> LZWSetupEncode(TIFF* tif)
> {
> 	LZWEncodeState* sp = EncoderState(tif);
> 	static const char module[] = "LZWSetupEncode";
> 
> 	assert(sp != NULL);
> 	sp->enc_hashtab = (hash_t*) _TIFFmalloc(HSIZE*sizeof (hash_t));
> 	if (sp->enc_hashtab == NULL) {
> 		TIFFError(module, "No space for LZW hash table");
> 		return (0);
> 	}
> 	return (1);
> }
> 
> /*
>  * Reset encoding state at the start of a strip.
>  */
> static int
> LZWPreEncode(TIFF* tif, tsample_t s)
> {
> 	LZWEncodeState *sp = EncoderState(tif);
> 
> 	(void) s;
> 	assert(sp != NULL);
> 	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);
> }
> 
> #define	CALCRATIO(sp, rat) {					\
> 	if (incount > 0x007fffff) { /* NB: shift will overflow */\
> 		rat = outcount >> 8;				\
> 		rat = (rat == 0 ? 0x7fffffff : incount/rat);	\
> 	} else							\
> 		rat = (incount<<8) / outcount;			\
> }
> #define	PutNextCode(op, c) {					\
> 	nextdata = (nextdata << nbits) | c;			\
> 	nextbits += nbits;					\
> 	*op++ = (u_char)(nextdata >> (nextbits-8));		\
> 	nextbits -= 8;						\
> 	if (nextbits >= 8) {					\
> 		*op++ = (u_char)(nextdata >> (nextbits-8));	\
> 		nextbits -= 8;					\
> 	}							\
> 	outcount += nbits;					\
> }
> 
> /*
>  * 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, tidata_t bp, tsize_t cc, tsample_t s)
> {
> 	register LZWEncodeState *sp = EncoderState(tif);
> 	register long fcode;
> 	register hash_t *hp;
> 	register int h, c;
> 	hcode_t ent;
> 	long disp;
> 	long incount, outcount, checkpoint;
> 	long nextdata, nextbits;
> 	int free_ent, maxcode, nbits;
> 	tidata_t op, limit;
> 
> 	(void) s;
> 	if (sp == NULL)
> 		return (0);
> 	/*
> 	 * 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 = 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 'cuz 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 = (tsize_t)(op - tif->tif_rawdata);
> 			TIFFFlushData1(tif);
> 			op = tif->tif_rawdata;
> 		}
> 		PutNextCode(op, ent);
> 		ent = c;
> 		hp->code = 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 = free_ent;
> 	sp->lzw_maxcode = maxcode;
> 	sp->lzw_nbits = nbits;
> 	tif->tif_rawcp = op;
> 	return (1);
> }
> 
> /*
>  * Finish off an encoded strip by flushing the last
>  * string and tacking on an End Of Information code.
>  */
> static int
> LZWPostEncode(TIFF* tif)
> {
> 	register LZWEncodeState *sp = EncoderState(tif);
> 	tidata_t op = tif->tif_rawcp;
> 	long nextbits = sp->lzw_nextbits;
> 	long nextdata = sp->lzw_nextdata;
> 	long outcount = sp->enc_outcount;
> 	int nbits = sp->lzw_nbits;
> 
> 	if (op > sp->enc_rawlimit) {
> 		tif->tif_rawcc = (tsize_t)(op - tif->tif_rawdata);
> 		TIFFFlushData1(tif);
> 		op = tif->tif_rawdata;
> 	}
> 	if (sp->enc_oldcode != (hcode_t) -1) {
> 		PutNextCode(op, sp->enc_oldcode);
> 		sp->enc_oldcode = (hcode_t) -1;
> 	}
> 	PutNextCode(op, CODE_EOI);
> 	if (nextbits > 0) 
> 		*op++ = (u_char)(nextdata << (8-nextbits));
> 	tif->tif_rawcc = (tsize_t)(op - tif->tif_rawdata);
> 	return (1);
> }
> 
> /*
>  * Reset encoding hash table.
>  */
> static void
> cl_hash(LZWEncodeState* sp)
> {
> 	register hash_t *hp = &sp->enc_hashtab[HSIZE-1];
> 	register long i = HSIZE-8;
640a920,934
>  	do {
> 		i -= 8;
> 		hp[-7].hash = -1;
> 		hp[-6].hash = -1;
> 		hp[-5].hash = -1;
> 		hp[-4].hash = -1;
> 		hp[-3].hash = -1;
> 		hp[-2].hash = -1;
> 		hp[-1].hash = -1;
> 		hp[ 0].hash = -1;
> 		hp -= 8;
> 	} while (i >= 0);
>     	for (i += 8; i > 0; i--, hp--)
> 		hp->hash = -1;
> }
646c940
< 		if (tif->tif_mode == O_RDONLY) {
---
> 		if (LZWState(tif)->rw_mode == O_RDONLY) {
648a943,945
> 		} else {
> 			if (EncoderState(tif)->enc_hashtab)
> 				_TIFFfree(EncoderState(tif)->enc_hashtab);
655,662d951
< static int
< LZWSetupEncode(TIFF* tif)
< {
<     TIFFError(tif->tif_name,
<               "LZW compression is not available to due to Unisys patent enforcement");
<     return (0);
< }
< 
670,671c959
< 	if (tif->tif_mode == O_RDONLY) 
<         {
---
> 	if (tif->tif_mode == O_RDONLY) {
676a965,969
> 	} else {
> 		tif->tif_data = (tidata_t) _TIFFmalloc(sizeof (LZWEncodeState));
> 		if (tif->tif_data == NULL)
> 			goto bad;
> 		EncoderState(tif)->enc_hashtab = NULL;
678a972,973
>         LZWState(tif)->rw_mode = tif->tif_mode;
> 
682d976
< 	tif->tif_setupencode = LZWSetupEncode;
687a982,987
> 	tif->tif_setupencode = LZWSetupEncode;
> 	tif->tif_preencode = LZWPreEncode;
> 	tif->tif_postencode = LZWPostEncode;
> 	tif->tif_encoderow = LZWEncode;
> 	tif->tif_encodestrip = LZWEncode;
> 	tif->tif_encodetile = LZWEncode;
689d988
< 
693d991
<         if( tif->tif_mode == O_RDONLY )
695d992
< 
697d993
< 


<---------------------  End of report  --------------------->

