third_party/libtiff/tif_packbits.c - pdfium - Git at Google

 /*
  * Copyright (c) 1988-1997 Sam Leffler
  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  *
  * Permission to use, copy, modify, distribute, and sell this software and
  * its documentation for any purpose is hereby granted without fee, provided
  * that (i) the above copyright notices and this permission notice appear in
  * all copies of the software and related documentation, and (ii) the names of
  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  * publicity relating to the software without the specific, prior written
  * permission of Sam Leffler and Silicon Graphics.
  *
  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  *
  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  * OF THIS SOFTWARE.
  */

 #include "tiffiop.h"
 #ifdef PACKBITS_SUPPORT
 /*
  * TIFF Library.
  *
  * PackBits Compression Algorithm Support
  */
 #include <stdio.h>

 static int
 PackBitsPreEncode(TIFF* tif, uint16 s)
 {
 	(void) s;

         tif->tif_data = (uint8*)_TIFFmalloc(sizeof(tmsize_t));
 	if (tif->tif_data == NULL)
 		return (0);
 	/*
 	 * Calculate the scanline/tile-width size in bytes.
 	 */
 	if (isTiled(tif))
 		*(tmsize_t*)tif->tif_data = TIFFTileRowSize(tif);
 	else
 		*(tmsize_t*)tif->tif_data = TIFFScanlineSize(tif);
 	return (1);
 }

 static int
 PackBitsPostEncode(TIFF* tif)
 {
         if (tif->tif_data)
             _TIFFfree(tif->tif_data);
 	return (1);
 }

 /*
  * Encode a run of pixels.
  */
 static int
 PackBitsEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
 {
 	unsigned char* bp = (unsigned char*) buf;
 	uint8* op;
 	uint8* ep;
 	uint8* lastliteral;
 	long n, slop;
 	int b;
 	enum { BASE, LITERAL, RUN, LITERAL_RUN } state;

 	(void) s;
 	op = tif->tif_rawcp;
 	ep = tif->tif_rawdata + tif->tif_rawdatasize;
 	state = BASE;
 	lastliteral = 0;
 	while (cc > 0) {
 		/*
 		 * Find the longest string of identical bytes.
 		 */
 		b = *bp++;
 		cc--;
 		n = 1;
 		for (; cc > 0 && b == *bp; cc--, bp++)
 			n++;
 	again:
 		if (op + 2 >= ep) {		/* insure space for new data */
 			/*
 			 * Be careful about writing the last
 			 * literal.  Must write up to that point
 			 * and then copy the remainder to the
 			 * front of the buffer.
 			 */
 			if (state == LITERAL || state == LITERAL_RUN) {
 				slop = (long)(op - lastliteral);
 				tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp);
 				if (!TIFFFlushData1(tif))
 					return (0);
 				op = tif->tif_rawcp;
 				while (slop-- > 0)
 					*op++ = *lastliteral++;
 				lastliteral = tif->tif_rawcp;
 			} else {
 				tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
 				if (!TIFFFlushData1(tif))
 					return (0);
 				op = tif->tif_rawcp;
 			}
 		}
 		switch (state) {
 		case BASE:		/* initial state, set run/literal */
 			if (n > 1) {
 				state = RUN;
 				if (n > 128) {
 					*op++ = (uint8) -127;
 					*op++ = (uint8) b;
 					n -= 128;
 					goto again;
 				}
 				*op++ = (uint8)(-(n-1));
 				*op++ = (uint8) b;
 			} else {
 				lastliteral = op;
 				*op++ = 0;
 				*op++ = (uint8) b;
 				state = LITERAL;
 			}
 			break;
 		case LITERAL:		/* last object was literal string */
 			if (n > 1) {
 				state = LITERAL_RUN;
 				if (n > 128) {
 					*op++ = (uint8) -127;
 					*op++ = (uint8) b;
 					n -= 128;
 					goto again;
 				}
 				*op++ = (uint8)(-(n-1));	/* encode run */
 				*op++ = (uint8) b;
 			} else {			/* extend literal */
 				if (++(*lastliteral) == 127)
 					state = BASE;
 				*op++ = (uint8) b;
 			}
 			break;
 		case RUN:		/* last object was run */
 			if (n > 1) {
 				if (n > 128) {
 					*op++ = (uint8) -127;
 					*op++ = (uint8) b;
 					n -= 128;
 					goto again;
 				}
 				*op++ = (uint8)(-(n-1));
 				*op++ = (uint8) b;
 			} else {
 				lastliteral = op;
 				*op++ = 0;
 				*op++ = (uint8) b;
 				state = LITERAL;
 			}
 			break;
 		case LITERAL_RUN:	/* literal followed by a run */
 			/*
 			 * Check to see if previous run should
 			 * be converted to a literal, in which
 			 * case we convert literal-run-literal
 			 * to a single literal.
 			 */
 			if (n == 1 && op[-2] == (uint8) -1 &&
 			    *lastliteral < 126) {
 				state = (((*lastliteral) += 2) == 127 ?
 				    BASE : LITERAL);
 				op[-2] = op[-1];	/* replicate */
 			} else
 				state = RUN;
 			goto again;
 		}
 	}
 	tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
 	tif->tif_rawcp = op;
 	return (1);
 }

 /*
  * Encode a rectangular chunk of pixels.  We break it up
  * into row-sized pieces to insure that encoded runs do
  * not span rows.  Otherwise, there can be problems with
  * the decoder if data is read, for example, by scanlines
  * when it was encoded by strips.
  */
 static int
 PackBitsEncodeChunk(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
 {
 	tmsize_t rowsize = *(tmsize_t*)tif->tif_data;

 	while (cc > 0) {
 		tmsize_t chunk = rowsize;

 		if( cc < chunk )
 		    chunk = cc;

 		if (PackBitsEncode(tif, bp, chunk, s) < 0)
 		    return (-1);
 		bp += chunk;
 		cc -= chunk;
 	}
 	return (1);
 }

 static int
 PackBitsDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
 {
 	static const char module[] = "PackBitsDecode";
 	char *bp;
 	tmsize_t cc;
 	long n;
 	int b;

 	(void) s;
 	bp = (char*) tif->tif_rawcp;
 	cc = tif->tif_rawcc;
 	while (cc > 0 && occ > 0) {
 		n = (long) *bp++;
 		cc--;
 		/*
 		 * Watch out for compilers that
 		 * don't sign extend chars...
 		 */
 		if (n >= 128)
 			n -= 256;
 		if (n < 0) {		/* replicate next byte -n+1 times */
 			if (n == -128)	/* nop */
 				continue;
 			n = -n + 1;
 			if( occ < (tmsize_t)n )
 			{
 				TIFFWarningExt(tif->tif_clientdata, module,
 				    "Discarding %lu bytes to avoid buffer overrun",
 				    (unsigned long) ((tmsize_t)n - occ));
 				n = (long)occ;
 			}
 			if( cc == 0 )
 			{
 				TIFFWarningExt(tif->tif_clientdata, module,
 					       "Terminating PackBitsDecode due to lack of data.");
 				break;
 			}
 			occ -= n;
 			b = *bp++;
 			cc--;
 			while (n-- > 0)
 				*op++ = (uint8) b;
 		} else {		/* copy next n+1 bytes literally */
 			if (occ < (tmsize_t)(n + 1))
 			{
 				TIFFWarningExt(tif->tif_clientdata, module,
 				    "Discarding %lu bytes to avoid buffer overrun",
 				    (unsigned long) ((tmsize_t)n - occ + 1));
 				n = (long)occ - 1;
 			}
 			if (cc < (tmsize_t) (n+1))
 			{
 				TIFFWarningExt(tif->tif_clientdata, module,
 					       "Terminating PackBitsDecode due to lack of data.");
 				break;
 			}
 			_TIFFmemcpy(op, bp, ++n);
 			op += n; occ -= n;
 			bp += n; cc -= n;
 		}
 	}
 	tif->tif_rawcp = (uint8*) bp;
 	tif->tif_rawcc = cc;
 	if (occ > 0) {
 		TIFFErrorExt(tif->tif_clientdata, module,
 		    "Not enough data for scanline %lu",
 		    (unsigned long) tif->tif_row);
 		return (0);
 	}
 	return (1);
 }

 int
 TIFFInitPackBits(TIFF* tif, int scheme)
 {
 	(void) scheme;
 	tif->tif_decoderow = PackBitsDecode;
 	tif->tif_decodestrip = PackBitsDecode;
 	tif->tif_decodetile = PackBitsDecode;
 	tif->tif_preencode = PackBitsPreEncode;
 	tif->tif_postencode = PackBitsPostEncode;
 	tif->tif_encoderow = PackBitsEncode;
 	tif->tif_encodestrip = PackBitsEncodeChunk;
 	tif->tif_encodetile = PackBitsEncodeChunk;
 	return (1);
 }
 #endif /* PACKBITS_SUPPORT */

 /* vim: set ts=8 sts=8 sw=8 noet: */
 /*
  * Local Variables:
  * mode: c
  * c-basic-offset: 8
  * fill-column: 78
  * End:
  */
	/*
	* Copyright (c) 1988-1997 Sam Leffler
	* Copyright (c) 1991-1997 Silicon Graphics, Inc.
	*
	* Permission to use, copy, modify, distribute, and sell this software and
	* its documentation for any purpose is hereby granted without fee, provided
	* that (i) the above copyright notices and this permission notice appear in
	* all copies of the software and related documentation, and (ii) the names of
	* Sam Leffler and Silicon Graphics may not be used in any advertising or
	* publicity relating to the software without the specific, prior written
	* permission of Sam Leffler and Silicon Graphics.
	*
	* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
	* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
	* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
	*
	* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
	* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
	* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
	* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
	* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
	* OF THIS SOFTWARE.
	*/

	#include "tiffiop.h"
	#ifdef PACKBITS_SUPPORT
	/*
	* TIFF Library.
	*
	* PackBits Compression Algorithm Support
	*/
	#include <stdio.h>

	static int
	PackBitsPreEncode(TIFF* tif, uint16 s)
	{
	(void) s;

	tif->tif_data = (uint8*)_TIFFmalloc(sizeof(tmsize_t));
	if (tif->tif_data == NULL)
	return (0);
	/*
	* Calculate the scanline/tile-width size in bytes.
	*/
	if (isTiled(tif))
	(tmsize_t)tif->tif_data = TIFFTileRowSize(tif);
	else
	(tmsize_t)tif->tif_data = TIFFScanlineSize(tif);
	return (1);
	}

	static int
	PackBitsPostEncode(TIFF* tif)
	{
	if (tif->tif_data)
	_TIFFfree(tif->tif_data);
	return (1);
	}

	/*
	* Encode a run of pixels.
	*/
	static int
	PackBitsEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
	{
	unsigned char* bp = (unsigned char*) buf;
	uint8* op;
	uint8* ep;
	uint8* lastliteral;
	long n, slop;
	int b;
	enum { BASE, LITERAL, RUN, LITERAL_RUN } state;

	(void) s;
	op = tif->tif_rawcp;
	ep = tif->tif_rawdata + tif->tif_rawdatasize;
	state = BASE;
	lastliteral = 0;
	while (cc > 0) {
	/*
	* Find the longest string of identical bytes.
	*/
	b = *bp++;
	cc--;
	n = 1;
	for (; cc > 0 && b == *bp; cc--, bp++)
	n++;
	again:
	if (op + 2 >= ep) { /* insure space for new data */
	/*
	* Be careful about writing the last
	* literal. Must write up to that point
	* and then copy the remainder to the
	* front of the buffer.
	*/
	if (state == LITERAL \|\| state == LITERAL_RUN) {
	slop = (long)(op - lastliteral);
	tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp);
	if (!TIFFFlushData1(tif))
	return (0);
	op = tif->tif_rawcp;
	while (slop-- > 0)
	op++ = lastliteral++;
	lastliteral = tif->tif_rawcp;
	} else {
	tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
	if (!TIFFFlushData1(tif))
	return (0);
	op = tif->tif_rawcp;
	}
	}
	switch (state) {
	case BASE: /* initial state, set run/literal */
	if (n > 1) {
	state = RUN;
	if (n > 128) {
	*op++ = (uint8) -127;
	*op++ = (uint8) b;
	n -= 128;
	goto again;
	}
	*op++ = (uint8)(-(n-1));
	*op++ = (uint8) b;
	} else {
	lastliteral = op;
	*op++ = 0;
	*op++ = (uint8) b;
	state = LITERAL;
	}
	break;
	case LITERAL: /* last object was literal string */
	if (n > 1) {
	state = LITERAL_RUN;
	if (n > 128) {
	*op++ = (uint8) -127;
	*op++ = (uint8) b;
	n -= 128;
	goto again;
	}
	op++ = (uint8)(-(n-1)); / encode run */
	*op++ = (uint8) b;
	} else { /* extend literal */
	if (++(*lastliteral) == 127)
	state = BASE;
	*op++ = (uint8) b;
	}
	break;
	case RUN: /* last object was run */
	if (n > 1) {
	if (n > 128) {
	*op++ = (uint8) -127;
	*op++ = (uint8) b;
	n -= 128;
	goto again;
	}
	*op++ = (uint8)(-(n-1));
	*op++ = (uint8) b;
	} else {
	lastliteral = op;
	*op++ = 0;
	*op++ = (uint8) b;
	state = LITERAL;
	}
	break;
	case LITERAL_RUN: /* literal followed by a run */
	/*
	* Check to see if previous run should
	* be converted to a literal, in which
	* case we convert literal-run-literal
	* to a single literal.
	*/
	if (n == 1 && op[-2] == (uint8) -1 &&
	*lastliteral < 126) {
	state = (((*lastliteral) += 2) == 127 ?
	BASE : LITERAL);
	op[-2] = op[-1]; /* replicate */
	} else
	state = RUN;
	goto again;
	}
	}
	tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
	tif->tif_rawcp = op;
	return (1);
	}

	/*
	* Encode a rectangular chunk of pixels. We break it up
	* into row-sized pieces to insure that encoded runs do
	* not span rows. Otherwise, there can be problems with
	* the decoder if data is read, for example, by scanlines
	* when it was encoded by strips.
	*/
	static int
	PackBitsEncodeChunk(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
	{
	tmsize_t rowsize = (tmsize_t)tif->tif_data;

	while (cc > 0) {
	tmsize_t chunk = rowsize;

	if( cc < chunk )
	chunk = cc;

	if (PackBitsEncode(tif, bp, chunk, s) < 0)
	return (-1);
	bp += chunk;
	cc -= chunk;
	}
	return (1);
	}

	static int
	PackBitsDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
	{
	static const char module[] = "PackBitsDecode";
	char *bp;
	tmsize_t cc;
	long n;
	int b;

	(void) s;
	bp = (char*) tif->tif_rawcp;
	cc = tif->tif_rawcc;
	while (cc > 0 && occ > 0) {
	n = (long) *bp++;
	cc--;
	/*
	* Watch out for compilers that
	* don't sign extend chars...
	*/
	if (n >= 128)
	n -= 256;
	if (n < 0) { /* replicate next byte -n+1 times */
	if (n == -128) /* nop */
	continue;
	n = -n + 1;
	if( occ < (tmsize_t)n )
	{
	TIFFWarningExt(tif->tif_clientdata, module,
	"Discarding %lu bytes to avoid buffer overrun",
	(unsigned long) ((tmsize_t)n - occ));
	n = (long)occ;
	}
	if( cc == 0 )
	{
	TIFFWarningExt(tif->tif_clientdata, module,
	"Terminating PackBitsDecode due to lack of data.");
	break;
	}
	occ -= n;
	b = *bp++;
	cc--;
	while (n-- > 0)
	*op++ = (uint8) b;
	} else { /* copy next n+1 bytes literally */
	if (occ < (tmsize_t)(n + 1))
	{
	TIFFWarningExt(tif->tif_clientdata, module,
	"Discarding %lu bytes to avoid buffer overrun",
	(unsigned long) ((tmsize_t)n - occ + 1));
	n = (long)occ - 1;
	}
	if (cc < (tmsize_t) (n+1))
	{
	TIFFWarningExt(tif->tif_clientdata, module,
	"Terminating PackBitsDecode due to lack of data.");
	break;
	}
	_TIFFmemcpy(op, bp, ++n);
	op += n; occ -= n;
	bp += n; cc -= n;
	}
	}
	tif->tif_rawcp = (uint8*) bp;
	tif->tif_rawcc = cc;
	if (occ > 0) {
	TIFFErrorExt(tif->tif_clientdata, module,
	"Not enough data for scanline %lu",
	(unsigned long) tif->tif_row);
	return (0);
	}
	return (1);
	}

	int
	TIFFInitPackBits(TIFF* tif, int scheme)
	{
	(void) scheme;
	tif->tif_decoderow = PackBitsDecode;
	tif->tif_decodestrip = PackBitsDecode;
	tif->tif_decodetile = PackBitsDecode;
	tif->tif_preencode = PackBitsPreEncode;
	tif->tif_postencode = PackBitsPostEncode;
	tif->tif_encoderow = PackBitsEncode;
	tif->tif_encodestrip = PackBitsEncodeChunk;
	tif->tif_encodetile = PackBitsEncodeChunk;
	return (1);
	}
	#endif /* PACKBITS_SUPPORT */

	/* vim: set ts=8 sts=8 sw=8 noet: */
	/*
	* Local Variables:
	* mode: c
	* c-basic-offset: 8
	* fill-column: 78
	* End:
	*/