| /* | |
| * 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> | |
| #ifndef PACKBITS_READ_ONLY | |
| static int PackBitsPreEncode(TIFF *tif, uint16_t s) | |
| { | |
| (void)s; | |
| tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, 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) | |
| _TIFFfreeExt(tif, tif->tif_data); | |
| return (1); | |
| } | |
| /* | |
| * Encode a run of pixels. | |
| */ | |
| static int PackBitsEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s) | |
| { | |
| unsigned char *bp = (unsigned char *)buf; | |
| uint8_t *op; | |
| uint8_t *ep; | |
| uint8_t *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 = NULL; | |
| 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_t)-127; | |
| *op++ = (uint8_t)b; | |
| n -= 128; | |
| goto again; | |
| } | |
| *op++ = (uint8_t)(-(n - 1)); | |
| *op++ = (uint8_t)b; | |
| } | |
| else | |
| { | |
| lastliteral = op; | |
| *op++ = 0; | |
| *op++ = (uint8_t)b; | |
| state = LITERAL; | |
| } | |
| break; | |
| case LITERAL: /* last object was literal string */ | |
| if (n > 1) | |
| { | |
| state = LITERAL_RUN; | |
| if (n > 128) | |
| { | |
| *op++ = (uint8_t)-127; | |
| *op++ = (uint8_t)b; | |
| n -= 128; | |
| goto again; | |
| } | |
| *op++ = (uint8_t)(-(n - 1)); /* encode run */ | |
| *op++ = (uint8_t)b; | |
| } | |
| else | |
| { /* extend literal */ | |
| if (++(*lastliteral) == 127) | |
| state = BASE; | |
| *op++ = (uint8_t)b; | |
| } | |
| break; | |
| case RUN: /* last object was run */ | |
| if (n > 1) | |
| { | |
| if (n > 128) | |
| { | |
| *op++ = (uint8_t)-127; | |
| *op++ = (uint8_t)b; | |
| n -= 128; | |
| goto again; | |
| } | |
| *op++ = (uint8_t)(-(n - 1)); | |
| *op++ = (uint8_t)b; | |
| } | |
| else | |
| { | |
| lastliteral = op; | |
| *op++ = 0; | |
| *op++ = (uint8_t)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_t)-1 && *lastliteral < 126) | |
| { | |
| state = | |
| (((*lastliteral) = (uint8_t)(*lastliteral + 2)) == 127 | |
| ? BASE | |
| : LITERAL); | |
| op[-2] = op[-1]; /* replicate */ | |
| } | |
| else | |
| state = RUN; | |
| goto again; | |
| default: | |
| break; | |
| } | |
| } | |
| 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_t *bp, tmsize_t cc, uint16_t 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); | |
| } | |
| #endif | |
| static int PackBitsDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s) | |
| { | |
| static const char module[] = "PackBitsDecode"; | |
| int8_t *bp; | |
| tmsize_t cc; | |
| long n; | |
| int b; | |
| (void)s; | |
| bp = (int8_t *)tif->tif_rawcp; | |
| cc = tif->tif_rawcc; | |
| while (cc > 0 && occ > 0) | |
| { | |
| n = (long)*bp++; | |
| cc--; | |
| if (n < 0) | |
| { /* replicate next byte -n+1 times */ | |
| if (n == -128) /* nop */ | |
| continue; | |
| n = -n + 1; | |
| if (occ < (tmsize_t)n) | |
| { | |
| TIFFWarningExtR(tif, module, | |
| "Discarding %" TIFF_SSIZE_FORMAT | |
| " bytes to avoid buffer overrun", | |
| (tmsize_t)n - occ); | |
| n = (long)occ; | |
| } | |
| if (cc == 0) | |
| { | |
| TIFFWarningExtR( | |
| tif, module, | |
| "Terminating PackBitsDecode due to lack of data."); | |
| break; | |
| } | |
| occ -= n; | |
| b = *bp++; | |
| cc--; | |
| while (n-- > 0) | |
| *op++ = (uint8_t)b; | |
| } | |
| else | |
| { /* copy next n+1 bytes literally */ | |
| if (occ < (tmsize_t)(n + 1)) | |
| { | |
| TIFFWarningExtR(tif, module, | |
| "Discarding %" TIFF_SSIZE_FORMAT | |
| " bytes to avoid buffer overrun", | |
| (tmsize_t)n - occ + 1); | |
| n = (long)occ - 1; | |
| } | |
| if (cc < (tmsize_t)(n + 1)) | |
| { | |
| TIFFWarningExtR( | |
| tif, 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_t *)bp; | |
| tif->tif_rawcc = cc; | |
| if (occ > 0) | |
| { | |
| memset(op, 0, (size_t)occ); | |
| TIFFErrorExtR(tif, module, "Not enough data for scanline %" PRIu32, | |
| tif->tif_dir.td_row); | |
| return (0); | |
| } | |
| return (1); | |
| } | |
| static uint64_t PackBitsGetMaxCompressionRatio(TIFF *tif) | |
| { | |
| (void)tif; | |
| /* See README_for_libtiff_developpers.md for raw data used to estimate | |
| * the maximum compression rate. */ | |
| return 64; | |
| } | |
| int TIFFInitPackBits(TIFF *tif, int scheme) | |
| { | |
| (void)scheme; | |
| tif->tif_decoderow = PackBitsDecode; | |
| tif->tif_decodestrip = PackBitsDecode; | |
| tif->tif_decodetile = PackBitsDecode; | |
| #ifndef PACKBITS_READ_ONLY | |
| tif->tif_preencode = PackBitsPreEncode; | |
| tif->tif_postencode = PackBitsPostEncode; | |
| tif->tif_encoderow = PackBitsEncode; | |
| tif->tif_encodestrip = PackBitsEncodeChunk; | |
| tif->tif_encodetile = PackBitsEncodeChunk; | |
| #endif | |
| tif->tif_getmaxcompressionratio = PackBitsGetMaxCompressionRatio; | |
| return (1); | |
| } | |
| #endif /* PACKBITS_SUPPORT */ |