Index: third_party/tiff_v403/tif_packbits.c |
diff --git a/third_party/tiff_v403/tif_packbits.c b/third_party/tiff_v403/tif_packbits.c |
deleted file mode 100644 |
index b599934f1ff5b9565c568bc52a7cb11c25fdfaf4..0000000000000000000000000000000000000000 |
--- a/third_party/tiff_v403/tif_packbits.c |
+++ /dev/null |
@@ -1,300 +0,0 @@ |
-/* $Id: tif_packbits.c,v 1.22 2012-06-20 05:25:33 fwarmerdam Exp $ */ |
- |
-/* |
- * 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; |
- |
- if (!(tif->tif_data = (uint8*)_TIFFmalloc(sizeof(tmsize_t)))) |
- 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 (-1); |
- 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 (-1); |
- 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; |
- } |
- 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: |
- */ |
- |