mirror of
https://github.com/zint/zint
synced 2024-11-16 20:57:25 +13:00
eb6e5daa2d
also improve non-half-int interpolation performance raster/vector.c: use new stripf() func in "common.c" to workaround gcc 32-bit float calculation variations gs1.c: allow dummy AI "[]" if GS1NOCHECK_MODE and has data (#204); also add note re TPX AI 235 and terminating FNC1 Remove trailing whitespace in various files
374 lines
12 KiB
C
374 lines
12 KiB
C
/* tif_lzw.h - LZW compression for TIFF
|
|
|
|
libzint - the open source barcode library
|
|
Copyright (C) 2021 Robin Stuart <rstuart114@gmail.com>
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
3. Neither the name of the project nor the names of its contributors
|
|
may be used to endorse or promote products derived from this software
|
|
without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
|
|
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
SUCH DAMAGE.
|
|
*/
|
|
/* vim: set ts=4 sw=4 et : */
|
|
|
|
#ifndef TIF_LZW_H
|
|
#define TIF_LZW_H
|
|
|
|
/*
|
|
* Adapted from TIFF Library 4.2.0 libtiff/tif_lzw.c */
|
|
/*
|
|
* 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.
|
|
*/
|
|
/*
|
|
* TIFF Library.
|
|
* Rev 5.0 Lempel-Ziv & Welch Compression Support
|
|
*
|
|
* This code is derived from the compress program whose code is
|
|
* derived from software contributed to Berkeley by James A. Woods,
|
|
* derived from original work by Spencer Thomas and Joseph Orost.
|
|
*
|
|
* The original Berkeley copyright notice appears below in its entirety.
|
|
*/
|
|
/*
|
|
* Copyright (c) 1985, 1986 The Regents of the University of California.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* James A. Woods, derived from original work by Spencer Thomas
|
|
* and Joseph Orost.
|
|
*
|
|
* Redistribution and use in source and binary forms are permitted
|
|
* provided that the above copyright notice and this paragraph are
|
|
* duplicated in all such forms and that any documentation,
|
|
* advertising materials, and other materials related to such
|
|
* distribution and use acknowledge that the software was developed
|
|
* by the University of California, Berkeley. The name of the
|
|
* University may not be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
*/
|
|
|
|
#define MAXCODE(n) ((1L << (n)) - 1)
|
|
|
|
/*
|
|
* The TIFF spec specifies that encoded bit
|
|
* strings range from 9 to 12 bits.
|
|
*/
|
|
#define BITS_MIN 9 /* start with 9 bits */
|
|
#define BITS_MAX 12 /* max of 12 bit strings */
|
|
/* predefined codes */
|
|
#define CODE_CLEAR 256 /* code to clear string table */
|
|
#define CODE_EOI 257 /* end-of-information code */
|
|
#define CODE_FIRST 258 /* first free code entry */
|
|
#define CODE_MAX MAXCODE(BITS_MAX)
|
|
#define HSIZE 9001L /* 91% occupancy */
|
|
#define HSHIFT (13 - 8)
|
|
|
|
/*
|
|
* Encoding-specific state.
|
|
*/
|
|
typedef uint16_t tif_lzw_hcode; /* codes fit in 16 bits */
|
|
typedef struct {
|
|
long hash;
|
|
tif_lzw_hcode code;
|
|
} tif_lzw_hash;
|
|
|
|
#define CHECK_GAP 10000 /* ratio check interval */
|
|
|
|
/*
|
|
* State block.
|
|
*/
|
|
typedef struct {
|
|
tif_lzw_hash *enc_hashtab; /* kept separate for small machines */
|
|
} tif_lzw_state;
|
|
|
|
/*
|
|
* LZW Encoding.
|
|
*/
|
|
|
|
/*
|
|
* Reset encoding hash table.
|
|
*/
|
|
static void tif_lzw_cl_hash(tif_lzw_state *sp) {
|
|
register tif_lzw_hash *hp = &sp->enc_hashtab[HSIZE - 1];
|
|
register long i = HSIZE - 8;
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
#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; \
|
|
}
|
|
|
|
/* Explicit 0xff masking to make icc -check=conversions happy */
|
|
#define PutNextCode(op_file, c) { \
|
|
nextdata = (nextdata << nbits) | c; \
|
|
nextbits += nbits; \
|
|
putc((nextdata >> (nextbits - 8)) & 0xff, op_file); \
|
|
nextbits -= 8; \
|
|
if (nextbits >= 8) { \
|
|
putc((nextdata >> (nextbits - 8)) & 0xff, op_file); \
|
|
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 tif_lzw_encode(tif_lzw_state *sp, FILE *op_file, const unsigned char *bp, int cc) {
|
|
register long fcode;
|
|
register tif_lzw_hash *hp;
|
|
register int h, c;
|
|
tif_lzw_hcode ent;
|
|
long disp;
|
|
|
|
int nbits; /* # of bits/code */
|
|
int maxcode; /* maximum code for nbits */
|
|
int free_ent; /* next free entry in hash table */
|
|
unsigned long nextdata; /* next bits of i/o */
|
|
long nextbits; /* # of valid bits in nextdata */
|
|
long checkpoint; /* point at which to clear table */
|
|
long ratio; /* current compression ratio */
|
|
long incount; /* (input) data bytes encoded */
|
|
long outcount; /* encoded (output) bytes */
|
|
|
|
/*
|
|
* Reset encoding state at the start of a strip.
|
|
*/
|
|
if (sp->enc_hashtab == NULL) {
|
|
sp->enc_hashtab = (tif_lzw_hash *) malloc(HSIZE * sizeof(tif_lzw_hash));
|
|
if (sp->enc_hashtab == NULL) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
tif_lzw_cl_hash(sp); /* clear hash table */
|
|
|
|
nbits = BITS_MIN;
|
|
maxcode = MAXCODE(BITS_MIN);
|
|
free_ent = CODE_FIRST;
|
|
nextdata = 0;
|
|
nextbits = 0;
|
|
checkpoint = CHECK_GAP;
|
|
ratio = 0;
|
|
incount = 0;
|
|
outcount = 0;
|
|
|
|
ent = (tif_lzw_hcode) -1;
|
|
|
|
if (cc > 0) {
|
|
PutNextCode(op_file, 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.
|
|
*/
|
|
PutNextCode(op_file, ent);
|
|
ent = (tif_lzw_hcode) c;
|
|
hp->code = (tif_lzw_hcode) (free_ent++);
|
|
hp->hash = fcode;
|
|
if (free_ent == CODE_MAX - 1) {
|
|
/* table is full, emit clear code and reset */
|
|
tif_lzw_cl_hash(sp);
|
|
ratio = 0;
|
|
incount = 0;
|
|
outcount = 0;
|
|
free_ent = CODE_FIRST;
|
|
PutNextCode(op_file, 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 <= ratio) {
|
|
tif_lzw_cl_hash(sp);
|
|
ratio = 0;
|
|
incount = 0;
|
|
outcount = 0;
|
|
free_ent = CODE_FIRST;
|
|
PutNextCode(op_file, CODE_CLEAR);
|
|
nbits = BITS_MIN;
|
|
maxcode = MAXCODE(BITS_MIN);
|
|
} else {
|
|
ratio = rat;
|
|
}
|
|
}
|
|
}
|
|
hit:
|
|
;
|
|
}
|
|
|
|
/*
|
|
* Finish off an encoded strip by flushing the last
|
|
* string and tacking on an End Of Information code.
|
|
*/
|
|
if (ent != (tif_lzw_hcode) -1) {
|
|
|
|
PutNextCode(op_file, ent);
|
|
free_ent++;
|
|
|
|
if (free_ent == CODE_MAX - 1) {
|
|
/* table is full, emit clear code and reset */
|
|
outcount = 0;
|
|
PutNextCode(op_file, CODE_CLEAR);
|
|
nbits = 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);
|
|
}
|
|
}
|
|
}
|
|
PutNextCode(op_file, CODE_EOI);
|
|
/* Explicit 0xff masking to make icc -check=conversions happy */
|
|
if (nextbits > 0) {
|
|
putc((nextdata << (8 - nextbits)) & 0xff, op_file);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void tif_lzw_cleanup(tif_lzw_state *sp) {
|
|
if (sp->enc_hashtab) {
|
|
free(sp->enc_hashtab);
|
|
}
|
|
}
|
|
|
|
static void tif_lzw_init(tif_lzw_state *sp) {
|
|
sp->enc_hashtab = NULL;
|
|
}
|
|
|
|
#endif /* TIF_LZW_H */
|