niansa-misc/wine
1
0
Fork 0
mirror of synced 2025-03-07 03:53:26 +01:00
Code Issues Projects Releases Packages Wiki Activity

tiff: Import upstream release 4.5.0.

Browse source
This commit is contained in:
Alexandre Julliard 2023-03-11 18:37:42 +01:00
parent f93e53c94b
commit 4c255f5a63
43 changed files with 30408 additions and 27148 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
libs/tiff/Makefile.in
View file

@ -15,6 +15,7 @@ C_SRCS = \
libtiff/tif_fax3.c \ libtiff/tif_fax3.c \
libtiff/tif_fax3sm.c \ libtiff/tif_fax3sm.c \
libtiff/tif_flush.c \ libtiff/tif_flush.c \
libtiff/tif_hash_set.c \
libtiff/tif_jpeg.c \ libtiff/tif_jpeg.c \
libtiff/tif_luv.c \ libtiff/tif_luv.c \
libtiff/tif_lzw.c \ libtiff/tif_lzw.c \

464
libs/tiff/libtiff/t4.h
View file

@ -23,26 +23,27 @@
*/ */
#ifndef _T4_ #ifndef _T4_
#define _T4_ #define _T4_
/* /*
* CCITT T.4 1D Huffman runlength codes and * CCITT T.4 1D Huffman runlength codes and
* related definitions. Given the small sizes * related definitions. Given the small sizes
* of these tables it does not seem * of these tables it does not seem
* worthwhile to make code & length 8 bits. * worthwhile to make code & length 8 bits.
*/ */
typedef struct tableentry { typedef struct tableentry
unsigned short length; /* bit length of g3 code */ {
unsigned short code; /* g3 code */ unsigned short length; /* bit length of g3 code */
short runlen; /* run length in bits */ unsigned short code; /* g3 code */
short runlen; /* run length in bits */
} tableentry; } tableentry;
#define EOL 0x001 /* EOL code value - 0000 0000 0000 1 */ #define EOL 0x001 /* EOL code value - 0000 0000 0000 1 */
/* status values returned instead of a run length */ /* status values returned instead of a run length */
#define G3CODE_EOL -1 /* NB: ACT_EOL - ACT_WRUNT */ #define G3CODE_EOL -1 /* NB: ACT_EOL - ACT_WRUNT */
#define G3CODE_INVALID -2 /* NB: ACT_INVALID - ACT_WRUNT */ #define G3CODE_INVALID -2 /* NB: ACT_INVALID - ACT_WRUNT */
#define G3CODE_EOF -3 /* end of input data */ #define G3CODE_EOF -3 /* end of input data */
#define G3CODE_INCOMP -4 /* incomplete run code */ #define G3CODE_INCOMP -4 /* incomplete run code */
/* /*
* Note that these tables are ordered such that the * Note that these tables are ordered such that the
@ -54,237 +55,230 @@ typedef struct tableentry {
*/ */
#ifdef G3CODES #ifdef G3CODES
const tableentry TIFFFaxWhiteCodes[] = { const tableentry TIFFFaxWhiteCodes[] = {
{ 8, 0x35, 0 }, /* 0011 0101 */ {8, 0x35, 0}, /* 0011 0101 */
{ 6, 0x7, 1 }, /* 0001 11 */ {6, 0x7, 1}, /* 0001 11 */
{ 4, 0x7, 2 }, /* 0111 */ {4, 0x7, 2}, /* 0111 */
{ 4, 0x8, 3 }, /* 1000 */ {4, 0x8, 3}, /* 1000 */
{ 4, 0xB, 4 }, /* 1011 */ {4, 0xB, 4}, /* 1011 */
{ 4, 0xC, 5 }, /* 1100 */ {4, 0xC, 5}, /* 1100 */
{ 4, 0xE, 6 }, /* 1110 */ {4, 0xE, 6}, /* 1110 */
{ 4, 0xF, 7 }, /* 1111 */ {4, 0xF, 7}, /* 1111 */
{ 5, 0x13, 8 }, /* 1001 1 */ {5, 0x13, 8}, /* 1001 1 */
{ 5, 0x14, 9 }, /* 1010 0 */ {5, 0x14, 9}, /* 1010 0 */
{ 5, 0x7, 10 }, /* 0011 1 */ {5, 0x7, 10}, /* 0011 1 */
{ 5, 0x8, 11 }, /* 0100 0 */ {5, 0x8, 11}, /* 0100 0 */
{ 6, 0x8, 12 }, /* 0010 00 */ {6, 0x8, 12}, /* 0010 00 */
{ 6, 0x3, 13 }, /* 0000 11 */ {6, 0x3, 13}, /* 0000 11 */
{ 6, 0x34, 14 }, /* 1101 00 */ {6, 0x34, 14}, /* 1101 00 */
{ 6, 0x35, 15 }, /* 1101 01 */ {6, 0x35, 15}, /* 1101 01 */
{ 6, 0x2A, 16 }, /* 1010 10 */ {6, 0x2A, 16}, /* 1010 10 */
{ 6, 0x2B, 17 }, /* 1010 11 */ {6, 0x2B, 17}, /* 1010 11 */
{ 7, 0x27, 18 }, /* 0100 111 */ {7, 0x27, 18}, /* 0100 111 */
{ 7, 0xC, 19 }, /* 0001 100 */ {7, 0xC, 19}, /* 0001 100 */
{ 7, 0x8, 20 }, /* 0001 000 */ {7, 0x8, 20}, /* 0001 000 */
{ 7, 0x17, 21 }, /* 0010 111 */ {7, 0x17, 21}, /* 0010 111 */
{ 7, 0x3, 22 }, /* 0000 011 */ {7, 0x3, 22}, /* 0000 011 */
{ 7, 0x4, 23 }, /* 0000 100 */ {7, 0x4, 23}, /* 0000 100 */
{ 7, 0x28, 24 }, /* 0101 000 */ {7, 0x28, 24}, /* 0101 000 */
{ 7, 0x2B, 25 }, /* 0101 011 */ {7, 0x2B, 25}, /* 0101 011 */
{ 7, 0x13, 26 }, /* 0010 011 */ {7, 0x13, 26}, /* 0010 011 */
{ 7, 0x24, 27 }, /* 0100 100 */ {7, 0x24, 27}, /* 0100 100 */
{ 7, 0x18, 28 }, /* 0011 000 */ {7, 0x18, 28}, /* 0011 000 */
{ 8, 0x2, 29 }, /* 0000 0010 */ {8, 0x2, 29}, /* 0000 0010 */
{ 8, 0x3, 30 }, /* 0000 0011 */ {8, 0x3, 30}, /* 0000 0011 */
{ 8, 0x1A, 31 }, /* 0001 1010 */ {8, 0x1A, 31}, /* 0001 1010 */
{ 8, 0x1B, 32 }, /* 0001 1011 */ {8, 0x1B, 32}, /* 0001 1011 */
{ 8, 0x12, 33 }, /* 0001 0010 */ {8, 0x12, 33}, /* 0001 0010 */
{ 8, 0x13, 34 }, /* 0001 0011 */ {8, 0x13, 34}, /* 0001 0011 */
{ 8, 0x14, 35 }, /* 0001 0100 */ {8, 0x14, 35}, /* 0001 0100 */
{ 8, 0x15, 36 }, /* 0001 0101 */ {8, 0x15, 36}, /* 0001 0101 */
{ 8, 0x16, 37 }, /* 0001 0110 */ {8, 0x16, 37}, /* 0001 0110 */
{ 8, 0x17, 38 }, /* 0001 0111 */ {8, 0x17, 38}, /* 0001 0111 */
{ 8, 0x28, 39 }, /* 0010 1000 */ {8, 0x28, 39}, /* 0010 1000 */
{ 8, 0x29, 40 }, /* 0010 1001 */ {8, 0x29, 40}, /* 0010 1001 */
{ 8, 0x2A, 41 }, /* 0010 1010 */ {8, 0x2A, 41}, /* 0010 1010 */
{ 8, 0x2B, 42 }, /* 0010 1011 */ {8, 0x2B, 42}, /* 0010 1011 */
{ 8, 0x2C, 43 }, /* 0010 1100 */ {8, 0x2C, 43}, /* 0010 1100 */
{ 8, 0x2D, 44 }, /* 0010 1101 */ {8, 0x2D, 44}, /* 0010 1101 */
{ 8, 0x4, 45 }, /* 0000 0100 */ {8, 0x4, 45}, /* 0000 0100 */
{ 8, 0x5, 46 }, /* 0000 0101 */ {8, 0x5, 46}, /* 0000 0101 */
{ 8, 0xA, 47 }, /* 0000 1010 */ {8, 0xA, 47}, /* 0000 1010 */
{ 8, 0xB, 48 }, /* 0000 1011 */ {8, 0xB, 48}, /* 0000 1011 */
{ 8, 0x52, 49 }, /* 0101 0010 */ {8, 0x52, 49}, /* 0101 0010 */
{ 8, 0x53, 50 }, /* 0101 0011 */ {8, 0x53, 50}, /* 0101 0011 */
{ 8, 0x54, 51 }, /* 0101 0100 */ {8, 0x54, 51}, /* 0101 0100 */
{ 8, 0x55, 52 }, /* 0101 0101 */ {8, 0x55, 52}, /* 0101 0101 */
{ 8, 0x24, 53 }, /* 0010 0100 */ {8, 0x24, 53}, /* 0010 0100 */
{ 8, 0x25, 54 }, /* 0010 0101 */ {8, 0x25, 54}, /* 0010 0101 */
{ 8, 0x58, 55 }, /* 0101 1000 */ {8, 0x58, 55}, /* 0101 1000 */
{ 8, 0x59, 56 }, /* 0101 1001 */ {8, 0x59, 56}, /* 0101 1001 */
{ 8, 0x5A, 57 }, /* 0101 1010 */ {8, 0x5A, 57}, /* 0101 1010 */
{ 8, 0x5B, 58 }, /* 0101 1011 */ {8, 0x5B, 58}, /* 0101 1011 */
{ 8, 0x4A, 59 }, /* 0100 1010 */ {8, 0x4A, 59}, /* 0100 1010 */
{ 8, 0x4B, 60 }, /* 0100 1011 */ {8, 0x4B, 60}, /* 0100 1011 */
{ 8, 0x32, 61 }, /* 0011 0010 */ {8, 0x32, 61}, /* 0011 0010 */
{ 8, 0x33, 62 }, /* 0011 0011 */ {8, 0x33, 62}, /* 0011 0011 */
{ 8, 0x34, 63 }, /* 0011 0100 */ {8, 0x34, 63}, /* 0011 0100 */
{ 5, 0x1B, 64 }, /* 1101 1 */ {5, 0x1B, 64}, /* 1101 1 */
{ 5, 0x12, 128 }, /* 1001 0 */ {5, 0x12, 128}, /* 1001 0 */
{ 6, 0x17, 192 }, /* 0101 11 */ {6, 0x17, 192}, /* 0101 11 */
{ 7, 0x37, 256 }, /* 0110 111 */ {7, 0x37, 256}, /* 0110 111 */
{ 8, 0x36, 320 }, /* 0011 0110 */ {8, 0x36, 320}, /* 0011 0110 */
{ 8, 0x37, 384 }, /* 0011 0111 */ {8, 0x37, 384}, /* 0011 0111 */
{ 8, 0x64, 448 }, /* 0110 0100 */ {8, 0x64, 448}, /* 0110 0100 */
{ 8, 0x65, 512 }, /* 0110 0101 */ {8, 0x65, 512}, /* 0110 0101 */
{ 8, 0x68, 576 }, /* 0110 1000 */ {8, 0x68, 576}, /* 0110 1000 */
{ 8, 0x67, 640 }, /* 0110 0111 */ {8, 0x67, 640}, /* 0110 0111 */
{ 9, 0xCC, 704 }, /* 0110 0110 0 */ {9, 0xCC, 704}, /* 0110 0110 0 */
{ 9, 0xCD, 768 }, /* 0110 0110 1 */ {9, 0xCD, 768}, /* 0110 0110 1 */
{ 9, 0xD2, 832 }, /* 0110 1001 0 */ {9, 0xD2, 832}, /* 0110 1001 0 */
{ 9, 0xD3, 896 }, /* 0110 1001 1 */ {9, 0xD3, 896}, /* 0110 1001 1 */
{ 9, 0xD4, 960 }, /* 0110 1010 0 */ {9, 0xD4, 960}, /* 0110 1010 0 */
{ 9, 0xD5, 1024 }, /* 0110 1010 1 */ {9, 0xD5, 1024}, /* 0110 1010 1 */
{ 9, 0xD6, 1088 }, /* 0110 1011 0 */ {9, 0xD6, 1088}, /* 0110 1011 0 */
{ 9, 0xD7, 1152 }, /* 0110 1011 1 */ {9, 0xD7, 1152}, /* 0110 1011 1 */
{ 9, 0xD8, 1216 }, /* 0110 1100 0 */ {9, 0xD8, 1216}, /* 0110 1100 0 */
{ 9, 0xD9, 1280 }, /* 0110 1100 1 */ {9, 0xD9, 1280}, /* 0110 1100 1 */
{ 9, 0xDA, 1344 }, /* 0110 1101 0 */ {9, 0xDA, 1344}, /* 0110 1101 0 */
{ 9, 0xDB, 1408 }, /* 0110 1101 1 */ {9, 0xDB, 1408}, /* 0110 1101 1 */
{ 9, 0x98, 1472 }, /* 0100 1100 0 */ {9, 0x98, 1472}, /* 0100 1100 0 */
{ 9, 0x99, 1536 }, /* 0100 1100 1 */ {9, 0x99, 1536}, /* 0100 1100 1 */
{ 9, 0x9A, 1600 }, /* 0100 1101 0 */ {9, 0x9A, 1600}, /* 0100 1101 0 */
{ 6, 0x18, 1664 }, /* 0110 00 */ {6, 0x18, 1664}, /* 0110 00 */
{ 9, 0x9B, 1728 }, /* 0100 1101 1 */ {9, 0x9B, 1728}, /* 0100 1101 1 */
{ 11, 0x8, 1792 }, /* 0000 0001 000 */ {11, 0x8, 1792}, /* 0000 0001 000 */
{ 11, 0xC, 1856 }, /* 0000 0001 100 */ {11, 0xC, 1856}, /* 0000 0001 100 */
{ 11, 0xD, 1920 }, /* 0000 0001 101 */ {11, 0xD, 1920}, /* 0000 0001 101 */
{ 12, 0x12, 1984 }, /* 0000 0001 0010 */ {12, 0x12, 1984}, /* 0000 0001 0010 */
{ 12, 0x13, 2048 }, /* 0000 0001 0011 */ {12, 0x13, 2048}, /* 0000 0001 0011 */
{ 12, 0x14, 2112 }, /* 0000 0001 0100 */ {12, 0x14, 2112}, /* 0000 0001 0100 */
{ 12, 0x15, 2176 }, /* 0000 0001 0101 */ {12, 0x15, 2176}, /* 0000 0001 0101 */
{ 12, 0x16, 2240 }, /* 0000 0001 0110 */ {12, 0x16, 2240}, /* 0000 0001 0110 */
{ 12, 0x17, 2304 }, /* 0000 0001 0111 */ {12, 0x17, 2304}, /* 0000 0001 0111 */
{ 12, 0x1C, 2368 }, /* 0000 0001 1100 */ {12, 0x1C, 2368}, /* 0000 0001 1100 */
{ 12, 0x1D, 2432 }, /* 0000 0001 1101 */ {12, 0x1D, 2432}, /* 0000 0001 1101 */
{ 12, 0x1E, 2496 }, /* 0000 0001 1110 */ {12, 0x1E, 2496}, /* 0000 0001 1110 */
{ 12, 0x1F, 2560 }, /* 0000 0001 1111 */ {12, 0x1F, 2560}, /* 0000 0001 1111 */
{ 12, 0x1, G3CODE_EOL }, /* 0000 0000 0001 */ {12, 0x1, G3CODE_EOL}, /* 0000 0000 0001 */
{ 9, 0x1, G3CODE_INVALID }, /* 0000 0000 1 */ {9, 0x1, G3CODE_INVALID}, /* 0000 0000 1 */
{ 10, 0x1, G3CODE_INVALID }, /* 0000 0000 01 */ {10, 0x1, G3CODE_INVALID}, /* 0000 0000 01 */
{ 11, 0x1, G3CODE_INVALID }, /* 0000 0000 001 */ {11, 0x1, G3CODE_INVALID}, /* 0000 0000 001 */
{ 12, 0x0, G3CODE_INVALID }, /* 0000 0000 0000 */ {12, 0x0, G3CODE_INVALID}, /* 0000 0000 0000 */
}; };
const tableentry TIFFFaxBlackCodes[] = { const tableentry TIFFFaxBlackCodes[] = {
{ 10, 0x37, 0 }, /* 0000 1101 11 */ {10, 0x37, 0}, /* 0000 1101 11 */
{ 3, 0x2, 1 }, /* 010 */ {3, 0x2, 1}, /* 010 */
{ 2, 0x3, 2 }, /* 11 */ {2, 0x3, 2}, /* 11 */
{ 2, 0x2, 3 }, /* 10 */ {2, 0x2, 3}, /* 10 */
{ 3, 0x3, 4 }, /* 011 */ {3, 0x3, 4}, /* 011 */
{ 4, 0x3, 5 }, /* 0011 */ {4, 0x3, 5}, /* 0011 */
{ 4, 0x2, 6 }, /* 0010 */ {4, 0x2, 6}, /* 0010 */
{ 5, 0x3, 7 }, /* 0001 1 */ {5, 0x3, 7}, /* 0001 1 */
{ 6, 0x5, 8 }, /* 0001 01 */ {6, 0x5, 8}, /* 0001 01 */
{ 6, 0x4, 9 }, /* 0001 00 */ {6, 0x4, 9}, /* 0001 00 */
{ 7, 0x4, 10 }, /* 0000 100 */ {7, 0x4, 10}, /* 0000 100 */
{ 7, 0x5, 11 }, /* 0000 101 */ {7, 0x5, 11}, /* 0000 101 */
{ 7, 0x7, 12 }, /* 0000 111 */ {7, 0x7, 12}, /* 0000 111 */
{ 8, 0x4, 13 }, /* 0000 0100 */ {8, 0x4, 13}, /* 0000 0100 */
{ 8, 0x7, 14 }, /* 0000 0111 */ {8, 0x7, 14}, /* 0000 0111 */
{ 9, 0x18, 15 }, /* 0000 1100 0 */ {9, 0x18, 15}, /* 0000 1100 0 */
{ 10, 0x17, 16 }, /* 0000 0101 11 */ {10, 0x17, 16}, /* 0000 0101 11 */
{ 10, 0x18, 17 }, /* 0000 0110 00 */ {10, 0x18, 17}, /* 0000 0110 00 */
{ 10, 0x8, 18 }, /* 0000 0010 00 */ {10, 0x8, 18}, /* 0000 0010 00 */
{ 11, 0x67, 19 }, /* 0000 1100 111 */ {11, 0x67, 19}, /* 0000 1100 111 */
{ 11, 0x68, 20 }, /* 0000 1101 000 */ {11, 0x68, 20}, /* 0000 1101 000 */
{ 11, 0x6C, 21 }, /* 0000 1101 100 */ {11, 0x6C, 21}, /* 0000 1101 100 */
{ 11, 0x37, 22 }, /* 0000 0110 111 */ {11, 0x37, 22}, /* 0000 0110 111 */
{ 11, 0x28, 23 }, /* 0000 0101 000 */ {11, 0x28, 23}, /* 0000 0101 000 */
{ 11, 0x17, 24 }, /* 0000 0010 111 */ {11, 0x17, 24}, /* 0000 0010 111 */
{ 11, 0x18, 25 }, /* 0000 0011 000 */ {11, 0x18, 25}, /* 0000 0011 000 */
{ 12, 0xCA, 26 }, /* 0000 1100 1010 */ {12, 0xCA, 26}, /* 0000 1100 1010 */
{ 12, 0xCB, 27 }, /* 0000 1100 1011 */ {12, 0xCB, 27}, /* 0000 1100 1011 */
{ 12, 0xCC, 28 }, /* 0000 1100 1100 */ {12, 0xCC, 28}, /* 0000 1100 1100 */
{ 12, 0xCD, 29 }, /* 0000 1100 1101 */ {12, 0xCD, 29}, /* 0000 1100 1101 */
{ 12, 0x68, 30 }, /* 0000 0110 1000 */ {12, 0x68, 30}, /* 0000 0110 1000 */
{ 12, 0x69, 31 }, /* 0000 0110 1001 */ {12, 0x69, 31}, /* 0000 0110 1001 */
{ 12, 0x6A, 32 }, /* 0000 0110 1010 */ {12, 0x6A, 32}, /* 0000 0110 1010 */
{ 12, 0x6B, 33 }, /* 0000 0110 1011 */ {12, 0x6B, 33}, /* 0000 0110 1011 */
{ 12, 0xD2, 34 }, /* 0000 1101 0010 */ {12, 0xD2, 34}, /* 0000 1101 0010 */
{ 12, 0xD3, 35 }, /* 0000 1101 0011 */ {12, 0xD3, 35}, /* 0000 1101 0011 */
{ 12, 0xD4, 36 }, /* 0000 1101 0100 */ {12, 0xD4, 36}, /* 0000 1101 0100 */
{ 12, 0xD5, 37 }, /* 0000 1101 0101 */ {12, 0xD5, 37}, /* 0000 1101 0101 */
{ 12, 0xD6, 38 }, /* 0000 1101 0110 */ {12, 0xD6, 38}, /* 0000 1101 0110 */
{ 12, 0xD7, 39 }, /* 0000 1101 0111 */ {12, 0xD7, 39}, /* 0000 1101 0111 */
{ 12, 0x6C, 40 }, /* 0000 0110 1100 */ {12, 0x6C, 40}, /* 0000 0110 1100 */
{ 12, 0x6D, 41 }, /* 0000 0110 1101 */ {12, 0x6D, 41}, /* 0000 0110 1101 */
{ 12, 0xDA, 42 }, /* 0000 1101 1010 */ {12, 0xDA, 42}, /* 0000 1101 1010 */
{ 12, 0xDB, 43 }, /* 0000 1101 1011 */ {12, 0xDB, 43}, /* 0000 1101 1011 */
{ 12, 0x54, 44 }, /* 0000 0101 0100 */ {12, 0x54, 44}, /* 0000 0101 0100 */
{ 12, 0x55, 45 }, /* 0000 0101 0101 */ {12, 0x55, 45}, /* 0000 0101 0101 */
{ 12, 0x56, 46 }, /* 0000 0101 0110 */ {12, 0x56, 46}, /* 0000 0101 0110 */
{ 12, 0x57, 47 }, /* 0000 0101 0111 */ {12, 0x57, 47}, /* 0000 0101 0111 */
{ 12, 0x64, 48 }, /* 0000 0110 0100 */ {12, 0x64, 48}, /* 0000 0110 0100 */
{ 12, 0x65, 49 }, /* 0000 0110 0101 */ {12, 0x65, 49}, /* 0000 0110 0101 */
{ 12, 0x52, 50 }, /* 0000 0101 0010 */ {12, 0x52, 50}, /* 0000 0101 0010 */
{ 12, 0x53, 51 }, /* 0000 0101 0011 */ {12, 0x53, 51}, /* 0000 0101 0011 */
{ 12, 0x24, 52 }, /* 0000 0010 0100 */ {12, 0x24, 52}, /* 0000 0010 0100 */
{ 12, 0x37, 53 }, /* 0000 0011 0111 */ {12, 0x37, 53}, /* 0000 0011 0111 */
{ 12, 0x38, 54 }, /* 0000 0011 1000 */ {12, 0x38, 54}, /* 0000 0011 1000 */
{ 12, 0x27, 55 }, /* 0000 0010 0111 */ {12, 0x27, 55}, /* 0000 0010 0111 */
{ 12, 0x28, 56 }, /* 0000 0010 1000 */ {12, 0x28, 56}, /* 0000 0010 1000 */
{ 12, 0x58, 57 }, /* 0000 0101 1000 */ {12, 0x58, 57}, /* 0000 0101 1000 */
{ 12, 0x59, 58 }, /* 0000 0101 1001 */ {12, 0x59, 58}, /* 0000 0101 1001 */
{ 12, 0x2B, 59 }, /* 0000 0010 1011 */ {12, 0x2B, 59}, /* 0000 0010 1011 */
{ 12, 0x2C, 60 }, /* 0000 0010 1100 */ {12, 0x2C, 60}, /* 0000 0010 1100 */
{ 12, 0x5A, 61 }, /* 0000 0101 1010 */ {12, 0x5A, 61}, /* 0000 0101 1010 */
{ 12, 0x66, 62 }, /* 0000 0110 0110 */ {12, 0x66, 62}, /* 0000 0110 0110 */
{ 12, 0x67, 63 }, /* 0000 0110 0111 */ {12, 0x67, 63}, /* 0000 0110 0111 */
{ 10, 0xF, 64 }, /* 0000 0011 11 */ {10, 0xF, 64}, /* 0000 0011 11 */
{ 12, 0xC8, 128 }, /* 0000 1100 1000 */ {12, 0xC8, 128}, /* 0000 1100 1000 */
{ 12, 0xC9, 192 }, /* 0000 1100 1001 */ {12, 0xC9, 192}, /* 0000 1100 1001 */
{ 12, 0x5B, 256 }, /* 0000 0101 1011 */ {12, 0x5B, 256}, /* 0000 0101 1011 */
{ 12, 0x33, 320 }, /* 0000 0011 0011 */ {12, 0x33, 320}, /* 0000 0011 0011 */
{ 12, 0x34, 384 }, /* 0000 0011 0100 */ {12, 0x34, 384}, /* 0000 0011 0100 */
{ 12, 0x35, 448 }, /* 0000 0011 0101 */ {12, 0x35, 448}, /* 0000 0011 0101 */
{ 13, 0x6C, 512 }, /* 0000 0011 0110 0 */ {13, 0x6C, 512}, /* 0000 0011 0110 0 */
{ 13, 0x6D, 576 }, /* 0000 0011 0110 1 */ {13, 0x6D, 576}, /* 0000 0011 0110 1 */
{ 13, 0x4A, 640 }, /* 0000 0010 0101 0 */ {13, 0x4A, 640}, /* 0000 0010 0101 0 */
{ 13, 0x4B, 704 }, /* 0000 0010 0101 1 */ {13, 0x4B, 704}, /* 0000 0010 0101 1 */
{ 13, 0x4C, 768 }, /* 0000 0010 0110 0 */ {13, 0x4C, 768}, /* 0000 0010 0110 0 */
{ 13, 0x4D, 832 }, /* 0000 0010 0110 1 */ {13, 0x4D, 832}, /* 0000 0010 0110 1 */
{ 13, 0x72, 896 }, /* 0000 0011 1001 0 */ {13, 0x72, 896}, /* 0000 0011 1001 0 */
{ 13, 0x73, 960 }, /* 0000 0011 1001 1 */ {13, 0x73, 960}, /* 0000 0011 1001 1 */
{ 13, 0x74, 1024 }, /* 0000 0011 1010 0 */ {13, 0x74, 1024}, /* 0000 0011 1010 0 */
{ 13, 0x75, 1088 }, /* 0000 0011 1010 1 */ {13, 0x75, 1088}, /* 0000 0011 1010 1 */
{ 13, 0x76, 1152 }, /* 0000 0011 1011 0 */ {13, 0x76, 1152}, /* 0000 0011 1011 0 */
{ 13, 0x77, 1216 }, /* 0000 0011 1011 1 */ {13, 0x77, 1216}, /* 0000 0011 1011 1 */
{ 13, 0x52, 1280 }, /* 0000 0010 1001 0 */ {13, 0x52, 1280}, /* 0000 0010 1001 0 */
{ 13, 0x53, 1344 }, /* 0000 0010 1001 1 */ {13, 0x53, 1344}, /* 0000 0010 1001 1 */
{ 13, 0x54, 1408 }, /* 0000 0010 1010 0 */ {13, 0x54, 1408}, /* 0000 0010 1010 0 */
{ 13, 0x55, 1472 }, /* 0000 0010 1010 1 */ {13, 0x55, 1472}, /* 0000 0010 1010 1 */
{ 13, 0x5A, 1536 }, /* 0000 0010 1101 0 */ {13, 0x5A, 1536}, /* 0000 0010 1101 0 */
{ 13, 0x5B, 1600 }, /* 0000 0010 1101 1 */ {13, 0x5B, 1600}, /* 0000 0010 1101 1 */
{ 13, 0x64, 1664 }, /* 0000 0011 0010 0 */ {13, 0x64, 1664}, /* 0000 0011 0010 0 */
{ 13, 0x65, 1728 }, /* 0000 0011 0010 1 */ {13, 0x65, 1728}, /* 0000 0011 0010 1 */
{ 11, 0x8, 1792 }, /* 0000 0001 000 */ {11, 0x8, 1792}, /* 0000 0001 000 */
{ 11, 0xC, 1856 }, /* 0000 0001 100 */ {11, 0xC, 1856}, /* 0000 0001 100 */
{ 11, 0xD, 1920 }, /* 0000 0001 101 */ {11, 0xD, 1920}, /* 0000 0001 101 */
{ 12, 0x12, 1984 }, /* 0000 0001 0010 */ {12, 0x12, 1984}, /* 0000 0001 0010 */
{ 12, 0x13, 2048 }, /* 0000 0001 0011 */ {12, 0x13, 2048}, /* 0000 0001 0011 */
{ 12, 0x14, 2112 }, /* 0000 0001 0100 */ {12, 0x14, 2112}, /* 0000 0001 0100 */
{ 12, 0x15, 2176 }, /* 0000 0001 0101 */ {12, 0x15, 2176}, /* 0000 0001 0101 */
{ 12, 0x16, 2240 }, /* 0000 0001 0110 */ {12, 0x16, 2240}, /* 0000 0001 0110 */
{ 12, 0x17, 2304 }, /* 0000 0001 0111 */ {12, 0x17, 2304}, /* 0000 0001 0111 */
{ 12, 0x1C, 2368 }, /* 0000 0001 1100 */ {12, 0x1C, 2368}, /* 0000 0001 1100 */
{ 12, 0x1D, 2432 }, /* 0000 0001 1101 */ {12, 0x1D, 2432}, /* 0000 0001 1101 */
{ 12, 0x1E, 2496 }, /* 0000 0001 1110 */ {12, 0x1E, 2496}, /* 0000 0001 1110 */
{ 12, 0x1F, 2560 }, /* 0000 0001 1111 */ {12, 0x1F, 2560}, /* 0000 0001 1111 */
{ 12, 0x1, G3CODE_EOL }, /* 0000 0000 0001 */ {12, 0x1, G3CODE_EOL}, /* 0000 0000 0001 */
{ 9, 0x1, G3CODE_INVALID }, /* 0000 0000 1 */ {9, 0x1, G3CODE_INVALID}, /* 0000 0000 1 */
{ 10, 0x1, G3CODE_INVALID }, /* 0000 0000 01 */ {10, 0x1, G3CODE_INVALID}, /* 0000 0000 01 */
{ 11, 0x1, G3CODE_INVALID }, /* 0000 0000 001 */ {11, 0x1, G3CODE_INVALID}, /* 0000 0000 001 */
{ 12, 0x0, G3CODE_INVALID }, /* 0000 0000 0000 */ {12, 0x0, G3CODE_INVALID}, /* 0000 0000 0000 */
}; };
#else #else
extern const tableentry TIFFFaxWhiteCodes[]; extern const tableentry TIFFFaxWhiteCodes[];
extern const tableentry TIFFFaxBlackCodes[]; extern const tableentry TIFFFaxBlackCodes[];
#endif #endif
#endif /* _T4_ */ #endif /* _T4_ */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

647
libs/tiff/libtiff/tif_aux.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1991-1997 Sam Leffler * Copyright (c) 1991-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -27,173 +27,180 @@
* *
* Auxiliary Support Routines. * Auxiliary Support Routines.
*/ */
#include "tiffiop.h"
#include "tif_predict.h" #include "tif_predict.h"
#include <math.h> #include "tiffiop.h"
#include <float.h> #include <float.h>
#include <math.h>
uint32_t uint32_t _TIFFMultiply32(TIFF *tif, uint32_t first, uint32_t second,
_TIFFMultiply32(TIFF* tif, uint32_t first, uint32_t second, const char* where) const char *where)
{ {
if (second && first > UINT32_MAX / second) { if (second && first > UINT32_MAX / second)
TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
return 0;
}
return first * second;
}
uint64_t
_TIFFMultiply64(TIFF* tif, uint64_t first, uint64_t second, const char* where)
{
if (second && first > UINT64_MAX / second) {
TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
return 0;
}
return first * second;
}
tmsize_t
_TIFFMultiplySSize(TIFF* tif, tmsize_t first, tmsize_t second, const char* where)
{
if( first <= 0 || second <= 0 )
{ {
if( tif != NULL && where != NULL ) TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
return 0;
}
return first * second;
}
uint64_t _TIFFMultiply64(TIFF *tif, uint64_t first, uint64_t second,
const char *where)
{
if (second && first > UINT64_MAX / second)
{
TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
return 0;
}
return first * second;
}
tmsize_t _TIFFMultiplySSize(TIFF *tif, tmsize_t first, tmsize_t second,
const char *where)
{
if (first <= 0 || second <= 0)
{
if (tif != NULL && where != NULL)
{ {
TIFFErrorExt(tif->tif_clientdata, where, TIFFErrorExtR(tif, where,
"Invalid argument to _TIFFMultiplySSize() in %s", where); "Invalid argument to _TIFFMultiplySSize() in %s",
where);
} }
return 0; return 0;
} }
if( first > TIFF_TMSIZE_T_MAX / second ) if (first > TIFF_TMSIZE_T_MAX / second)
{ {
if( tif != NULL && where != NULL ) if (tif != NULL && where != NULL)
{ {
TIFFErrorExt(tif->tif_clientdata, where, TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
"Integer overflow in %s", where);
} }
return 0; return 0;
} }
return first * second; return first * second;
} }
tmsize_t _TIFFCastUInt64ToSSize(TIFF* tif, uint64_t val, const char* module) tmsize_t _TIFFCastUInt64ToSSize(TIFF *tif, uint64_t val, const char *module)
{ {
if( val > (uint64_t)TIFF_TMSIZE_T_MAX ) if (val > (uint64_t)TIFF_TMSIZE_T_MAX)
{ {
if( tif != NULL && module != NULL ) if (tif != NULL && module != NULL)
{ {
TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); TIFFErrorExtR(tif, module, "Integer overflow");
} }
return 0; return 0;
} }
return (tmsize_t)val; return (tmsize_t)val;
} }
void* void *_TIFFCheckRealloc(TIFF *tif, void *buffer, tmsize_t nmemb,
_TIFFCheckRealloc(TIFF* tif, void* buffer, tmsize_t elem_size, const char *what)
tmsize_t nmemb, tmsize_t elem_size, const char* what)
{ {
void* cp = NULL; void *cp = NULL;
tmsize_t count = _TIFFMultiplySSize(tif, nmemb, elem_size, NULL); tmsize_t count = _TIFFMultiplySSize(tif, nmemb, elem_size, NULL);
/* /*
* Check for integer overflow. * Check for integer overflow.
*/ */
if (count != 0) if (count != 0)
{ {
cp = _TIFFrealloc(buffer, count); cp = _TIFFreallocExt(tif, buffer, count);
} }
if (cp == NULL) { if (cp == NULL)
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, {
"Failed to allocate memory for %s " TIFFErrorExtR(tif, tif->tif_name,
"(%"TIFF_SSIZE_FORMAT" elements of %"TIFF_SSIZE_FORMAT" bytes each)", "Failed to allocate memory for %s "
what, nmemb, elem_size); "(%" TIFF_SSIZE_FORMAT " elements of %" TIFF_SSIZE_FORMAT
} " bytes each)",
what, nmemb, elem_size);
}
return cp; return cp;
} }
void* void *_TIFFCheckMalloc(TIFF *tif, tmsize_t nmemb, tmsize_t elem_size,
_TIFFCheckMalloc(TIFF* tif, tmsize_t nmemb, tmsize_t elem_size, const char* what) const char *what)
{ {
return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what); return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what);
} }
static int static int TIFFDefaultTransferFunction(TIFF *tif, TIFFDirectory *td)
TIFFDefaultTransferFunction(TIFFDirectory* td)
{ {
uint16_t **tf = td->td_transferfunction; uint16_t **tf = td->td_transferfunction;
tmsize_t i, n, nbytes; tmsize_t i, n, nbytes;
tf[0] = tf[1] = tf[2] = 0; tf[0] = tf[1] = tf[2] = 0;
if (td->td_bitspersample >= sizeof(tmsize_t) * 8 - 2) if (td->td_bitspersample >= sizeof(tmsize_t) * 8 - 2)
return 0; return 0;
n = ((tmsize_t)1)<<td->td_bitspersample; n = ((tmsize_t)1) << td->td_bitspersample;
nbytes = n * sizeof (uint16_t); nbytes = n * sizeof(uint16_t);
tf[0] = (uint16_t *)_TIFFmalloc(nbytes); tf[0] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
if (tf[0] == NULL) if (tf[0] == NULL)
return 0; return 0;
tf[0][0] = 0; tf[0][0] = 0;
for (i = 1; i < n; i++) { for (i = 1; i < n; i++)
double t = (double)i/((double) n-1.); {
tf[0][i] = (uint16_t)floor(65535. * pow(t, 2.2) + .5); double t = (double)i / ((double)n - 1.);
} tf[0][i] = (uint16_t)floor(65535. * pow(t, 2.2) + .5);
}
if (td->td_samplesperpixel - td->td_extrasamples > 1) { if (td->td_samplesperpixel - td->td_extrasamples > 1)
tf[1] = (uint16_t *)_TIFFmalloc(nbytes); {
if(tf[1] == NULL) tf[1] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
goto bad; if (tf[1] == NULL)
_TIFFmemcpy(tf[1], tf[0], nbytes); goto bad;
tf[2] = (uint16_t *)_TIFFmalloc(nbytes); _TIFFmemcpy(tf[1], tf[0], nbytes);
if (tf[2] == NULL) tf[2] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
goto bad; if (tf[2] == NULL)
_TIFFmemcpy(tf[2], tf[0], nbytes); goto bad;
} _TIFFmemcpy(tf[2], tf[0], nbytes);
return 1; }
return 1;
bad: bad:
if (tf[0]) if (tf[0])
_TIFFfree(tf[0]); _TIFFfreeExt(tif, tf[0]);
if (tf[1]) if (tf[1])
_TIFFfree(tf[1]); _TIFFfreeExt(tif, tf[1]);
if (tf[2]) if (tf[2])
_TIFFfree(tf[2]); _TIFFfreeExt(tif, tf[2]);
tf[0] = tf[1] = tf[2] = 0; tf[0] = tf[1] = tf[2] = 0;
return 0; return 0;
} }
static int static int TIFFDefaultRefBlackWhite(TIFF *tif, TIFFDirectory *td)
TIFFDefaultRefBlackWhite(TIFFDirectory* td)
{ {
int i; int i;
td->td_refblackwhite = (float *)_TIFFmalloc(6*sizeof (float)); td->td_refblackwhite = (float *)_TIFFmallocExt(tif, 6 * sizeof(float));
if (td->td_refblackwhite == NULL) if (td->td_refblackwhite == NULL)
return 0; return 0;
if (td->td_photometric == PHOTOMETRIC_YCBCR) { if (td->td_photometric == PHOTOMETRIC_YCBCR)
/* {
* YCbCr (Class Y) images must have the ReferenceBlackWhite /*
* tag set. Fix the broken images, which lacks that tag. * YCbCr (Class Y) images must have the ReferenceBlackWhite
*/ * tag set. Fix the broken images, which lacks that tag.
td->td_refblackwhite[0] = 0.0F; */
td->td_refblackwhite[1] = td->td_refblackwhite[3] = td->td_refblackwhite[0] = 0.0F;
td->td_refblackwhite[5] = 255.0F; td->td_refblackwhite[1] = td->td_refblackwhite[3] =
td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0F; td->td_refblackwhite[5] = 255.0F;
} else { td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0F;
/* }
* Assume RGB (Class R) else
*/ {
for (i = 0; i < 3; i++) { /*
td->td_refblackwhite[2*i+0] = 0; * Assume RGB (Class R)
td->td_refblackwhite[2*i+1] = */
(float)((1L<<td->td_bitspersample)-1L); for (i = 0; i < 3; i++)
} {
} td->td_refblackwhite[2 * i + 0] = 0;
return 1; td->td_refblackwhite[2 * i + 1] =
(float)((1L << td->td_bitspersample) - 1L);
}
}
return 1;
} }
/* /*
@ -204,216 +211,248 @@ TIFFDefaultRefBlackWhite(TIFFDirectory* td)
* explicit values so that defaults exist only one * explicit values so that defaults exist only one
* place in the library -- in TIFFDefaultDirectory. * place in the library -- in TIFFDefaultDirectory.
*/ */
int int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap)
TIFFVGetFieldDefaulted(TIFF* tif, uint32_t tag, va_list ap)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
if (TIFFVGetField(tif, tag, ap)) if (TIFFVGetField(tif, tag, ap))
return (1); return (1);
switch (tag) { switch (tag)
case TIFFTAG_SUBFILETYPE:
*va_arg(ap, uint32_t *) = td->td_subfiletype;
return (1);
case TIFFTAG_BITSPERSAMPLE:
*va_arg(ap, uint16_t *) = td->td_bitspersample;
return (1);
case TIFFTAG_THRESHHOLDING:
*va_arg(ap, uint16_t *) = td->td_threshholding;
return (1);
case TIFFTAG_FILLORDER:
*va_arg(ap, uint16_t *) = td->td_fillorder;
return (1);
case TIFFTAG_ORIENTATION:
*va_arg(ap, uint16_t *) = td->td_orientation;
return (1);
case TIFFTAG_SAMPLESPERPIXEL:
*va_arg(ap, uint16_t *) = td->td_samplesperpixel;
return (1);
case TIFFTAG_ROWSPERSTRIP:
*va_arg(ap, uint32_t *) = td->td_rowsperstrip;
return (1);
case TIFFTAG_MINSAMPLEVALUE:
*va_arg(ap, uint16_t *) = td->td_minsamplevalue;
return (1);
case TIFFTAG_MAXSAMPLEVALUE:
*va_arg(ap, uint16_t *) = td->td_maxsamplevalue;
return (1);
case TIFFTAG_PLANARCONFIG:
*va_arg(ap, uint16_t *) = td->td_planarconfig;
return (1);
case TIFFTAG_RESOLUTIONUNIT:
*va_arg(ap, uint16_t *) = td->td_resolutionunit;
return (1);
case TIFFTAG_PREDICTOR:
{ {
TIFFPredictorState* sp = (TIFFPredictorState*) tif->tif_data; case TIFFTAG_SUBFILETYPE:
if( sp == NULL ) *va_arg(ap, uint32_t *) = td->td_subfiletype;
return (1);
case TIFFTAG_BITSPERSAMPLE:
*va_arg(ap, uint16_t *) = td->td_bitspersample;
return (1);
case TIFFTAG_THRESHHOLDING:
*va_arg(ap, uint16_t *) = td->td_threshholding;
return (1);
case TIFFTAG_FILLORDER:
*va_arg(ap, uint16_t *) = td->td_fillorder;
return (1);
case TIFFTAG_ORIENTATION:
*va_arg(ap, uint16_t *) = td->td_orientation;
return (1);
case TIFFTAG_SAMPLESPERPIXEL:
*va_arg(ap, uint16_t *) = td->td_samplesperpixel;
return (1);
case TIFFTAG_ROWSPERSTRIP:
*va_arg(ap, uint32_t *) = td->td_rowsperstrip;
return (1);
case TIFFTAG_MINSAMPLEVALUE:
*va_arg(ap, uint16_t *) = td->td_minsamplevalue;
return (1);
case TIFFTAG_MAXSAMPLEVALUE:
{ {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, uint16_t maxsamplevalue;
"Cannot get \"Predictor\" tag as plugin is not configured"); /* td_bitspersample=1 is always set in TIFFDefaultDirectory().
*va_arg(ap, uint16_t*) = 0; * Therefore, td_maxsamplevalue has to be re-calculated in
return 0; * TIFFGetFieldDefaulted(). */
if (td->td_bitspersample > 0)
{
/* This shift operation into a uint16_t limits the value to
* 65535 even if td_bitspersamle is > 16 */
if (td->td_bitspersample <= 16)
{
maxsamplevalue = (1 << td->td_bitspersample) -
1; /* 2**(BitsPerSample) - 1 */
}
else
{
maxsamplevalue = 65535;
}
}
else
{
maxsamplevalue = 0;
}
*va_arg(ap, uint16_t *) = maxsamplevalue;
return (1);
} }
*va_arg(ap, uint16_t*) = (uint16_t) sp->predictor; case TIFFTAG_PLANARCONFIG:
return 1; *va_arg(ap, uint16_t *) = td->td_planarconfig;
return (1);
case TIFFTAG_RESOLUTIONUNIT:
*va_arg(ap, uint16_t *) = td->td_resolutionunit;
return (1);
case TIFFTAG_PREDICTOR:
{
TIFFPredictorState *sp = (TIFFPredictorState *)tif->tif_data;
if (sp == NULL)
{
TIFFErrorExtR(
tif, tif->tif_name,
"Cannot get \"Predictor\" tag as plugin is not configured");
*va_arg(ap, uint16_t *) = 0;
return 0;
}
*va_arg(ap, uint16_t *) = (uint16_t)sp->predictor;
return 1;
}
case TIFFTAG_DOTRANGE:
*va_arg(ap, uint16_t *) = 0;
*va_arg(ap, uint16_t *) = (1 << td->td_bitspersample) - 1;
return (1);
case TIFFTAG_INKSET:
*va_arg(ap, uint16_t *) = INKSET_CMYK;
return 1;
case TIFFTAG_NUMBEROFINKS:
*va_arg(ap, uint16_t *) = 4;
return (1);
case TIFFTAG_EXTRASAMPLES:
*va_arg(ap, uint16_t *) = td->td_extrasamples;
*va_arg(ap, const uint16_t **) = td->td_sampleinfo;
return (1);
case TIFFTAG_MATTEING:
*va_arg(ap, uint16_t *) =
(td->td_extrasamples == 1 &&
td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
return (1);
case TIFFTAG_TILEDEPTH:
*va_arg(ap, uint32_t *) = td->td_tiledepth;
return (1);
case TIFFTAG_DATATYPE:
*va_arg(ap, uint16_t *) = td->td_sampleformat - 1;
return (1);
case TIFFTAG_SAMPLEFORMAT:
*va_arg(ap, uint16_t *) = td->td_sampleformat;
return (1);
case TIFFTAG_IMAGEDEPTH:
*va_arg(ap, uint32_t *) = td->td_imagedepth;
return (1);
case TIFFTAG_YCBCRCOEFFICIENTS:
{
/* defaults are from CCIR Recommendation 601-1 */
static const float ycbcrcoeffs[] = {0.299f, 0.587f, 0.114f};
*va_arg(ap, const float **) = ycbcrcoeffs;
return 1;
}
case TIFFTAG_YCBCRSUBSAMPLING:
*va_arg(ap, uint16_t *) = td->td_ycbcrsubsampling[0];
*va_arg(ap, uint16_t *) = td->td_ycbcrsubsampling[1];
return (1);
case TIFFTAG_YCBCRPOSITIONING:
*va_arg(ap, uint16_t *) = td->td_ycbcrpositioning;
return (1);
case TIFFTAG_WHITEPOINT:
{
/* TIFF 6.0 specification tells that it is no default
value for the WhitePoint, but AdobePhotoshop TIFF
Technical Note tells that it should be CIE D50. */
static const float whitepoint[] = {
D50_X0 / (D50_X0 + D50_Y0 + D50_Z0),
D50_Y0 / (D50_X0 + D50_Y0 + D50_Z0)};
*va_arg(ap, const float **) = whitepoint;
return 1;
}
case TIFFTAG_TRANSFERFUNCTION:
if (!td->td_transferfunction[0] &&
!TIFFDefaultTransferFunction(tif, td))
{
TIFFErrorExtR(tif, tif->tif_name,
"No space for \"TransferFunction\" tag");
return (0);
}
*va_arg(ap, const uint16_t **) = td->td_transferfunction[0];
if (td->td_samplesperpixel - td->td_extrasamples > 1)
{
*va_arg(ap, const uint16_t **) = td->td_transferfunction[1];
*va_arg(ap, const uint16_t **) = td->td_transferfunction[2];
}
return (1);
case TIFFTAG_REFERENCEBLACKWHITE:
if (!td->td_refblackwhite && !TIFFDefaultRefBlackWhite(tif, td))
return (0);
*va_arg(ap, const float **) = td->td_refblackwhite;
return (1);
} }
case TIFFTAG_DOTRANGE: return 0;
*va_arg(ap, uint16_t *) = 0;
*va_arg(ap, uint16_t *) = (1 << td->td_bitspersample) - 1;
return (1);
case TIFFTAG_INKSET:
*va_arg(ap, uint16_t *) = INKSET_CMYK;
return 1;
case TIFFTAG_NUMBEROFINKS:
*va_arg(ap, uint16_t *) = 4;
return (1);
case TIFFTAG_EXTRASAMPLES:
*va_arg(ap, uint16_t *) = td->td_extrasamples;
*va_arg(ap, const uint16_t **) = td->td_sampleinfo;
return (1);
case TIFFTAG_MATTEING:
*va_arg(ap, uint16_t *) =
(td->td_extrasamples == 1 &&
td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
return (1);
case TIFFTAG_TILEDEPTH:
*va_arg(ap, uint32_t *) = td->td_tiledepth;
return (1);
case TIFFTAG_DATATYPE:
*va_arg(ap, uint16_t *) = td->td_sampleformat - 1;
return (1);
case TIFFTAG_SAMPLEFORMAT:
*va_arg(ap, uint16_t *) = td->td_sampleformat;
return(1);
case TIFFTAG_IMAGEDEPTH:
*va_arg(ap, uint32_t *) = td->td_imagedepth;
return (1);
case TIFFTAG_YCBCRCOEFFICIENTS:
{
/* defaults are from CCIR Recommendation 601-1 */
static const float ycbcrcoeffs[] = { 0.299f, 0.587f, 0.114f };
*va_arg(ap, const float **) = ycbcrcoeffs;
return 1;
}
case TIFFTAG_YCBCRSUBSAMPLING:
*va_arg(ap, uint16_t *) = td->td_ycbcrsubsampling[0];
*va_arg(ap, uint16_t *) = td->td_ycbcrsubsampling[1];
return (1);
case TIFFTAG_YCBCRPOSITIONING:
*va_arg(ap, uint16_t *) = td->td_ycbcrpositioning;
return (1);
case TIFFTAG_WHITEPOINT:
{
/* TIFF 6.0 specification tells that it is no default
value for the WhitePoint, but AdobePhotoshop TIFF
Technical Note tells that it should be CIE D50. */
static const float whitepoint[] = {
D50_X0 / (D50_X0 + D50_Y0 + D50_Z0),
D50_Y0 / (D50_X0 + D50_Y0 + D50_Z0)
};
*va_arg(ap, const float **) = whitepoint;
return 1;
}
case TIFFTAG_TRANSFERFUNCTION:
if (!td->td_transferfunction[0] &&
!TIFFDefaultTransferFunction(td)) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "No space for \"TransferFunction\" tag");
return (0);
}
*va_arg(ap, const uint16_t **) = td->td_transferfunction[0];
if (td->td_samplesperpixel - td->td_extrasamples > 1) {
*va_arg(ap, const uint16_t **) = td->td_transferfunction[1];
*va_arg(ap, const uint16_t **) = td->td_transferfunction[2];
}
return (1);
case TIFFTAG_REFERENCEBLACKWHITE:
if (!td->td_refblackwhite && !TIFFDefaultRefBlackWhite(td))
return (0);
*va_arg(ap, const float **) = td->td_refblackwhite;
return (1);
}
return 0;
} }
/* /*
* Like TIFFGetField, but return any default * Like TIFFGetField, but return any default
* value if the tag is not present in the directory. * value if the tag is not present in the directory.
*/ */
int int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag, ...)
TIFFGetFieldDefaulted(TIFF* tif, uint32_t tag, ...)
{ {
int ok; int ok;
va_list ap; va_list ap;
va_start(ap, tag); va_start(ap, tag);
ok = TIFFVGetFieldDefaulted(tif, tag, ap); ok = TIFFVGetFieldDefaulted(tif, tag, ap);
va_end(ap); va_end(ap);
return (ok); return (ok);
} }
struct _Int64Parts { struct _Int64Parts
int32_t low, high; {
int32_t low, high;
}; };
typedef union { typedef union
struct _Int64Parts part; {
int64_t value; struct _Int64Parts part;
int64_t value;
} _Int64; } _Int64;
float float _TIFFUInt64ToFloat(uint64_t ui64)
_TIFFUInt64ToFloat(uint64_t ui64)
{ {
_Int64 i; _Int64 i;
i.value = ui64; i.value = ui64;
if (i.part.high >= 0) { if (i.part.high >= 0)
return (float)i.value; {
} else { return (float)i.value;
long double df; }
df = (long double)i.value; else
df += 18446744073709551616.0; /* adding 2**64 */ {
return (float)df; long double df;
} df = (long double)i.value;
df += 18446744073709551616.0; /* adding 2**64 */
return (float)df;
}
} }
double double _TIFFUInt64ToDouble(uint64_t ui64)
_TIFFUInt64ToDouble(uint64_t ui64)
{ {
_Int64 i; _Int64 i;
i.value = ui64; i.value = ui64;
if (i.part.high >= 0) { if (i.part.high >= 0)
return (double)i.value; {
} else { return (double)i.value;
long double df; }
df = (long double)i.value; else
df += 18446744073709551616.0; /* adding 2**64 */ {
return (double)df; long double df;
} df = (long double)i.value;
df += 18446744073709551616.0; /* adding 2**64 */
return (double)df;
}
} }
float _TIFFClampDoubleToFloat( double val ) float _TIFFClampDoubleToFloat(double val)
{ {
if( val > FLT_MAX ) if (val > FLT_MAX)
return FLT_MAX; return FLT_MAX;
if( val < -FLT_MAX ) if (val < -FLT_MAX)
return -FLT_MAX; return -FLT_MAX;
return (float)val; return (float)val;
} }
int _TIFFSeekOK(TIFF* tif, toff_t off) uint32_t _TIFFClampDoubleToUInt32(double val)
{
if (val < 0)
return 0;
if (val > 0xFFFFFFFFU || val != val)
return 0xFFFFFFFFU;
return (uint32_t)val;
}
int _TIFFSeekOK(TIFF *tif, toff_t off)
{ {
/* Huge offsets, especially -1 / UINT64_MAX, can cause issues */ /* Huge offsets, especially -1 / UINT64_MAX, can cause issues */
/* See http://bugzilla.maptools.org/show_bug.cgi?id=2726 */ /* See http://bugzilla.maptools.org/show_bug.cgi?id=2726 */
return off <= (~(uint64_t)0) / 2 && TIFFSeekFile(tif, off, SEEK_SET) == off; return off <= (~(uint64_t)0) / 2 && TIFFSeekFile(tif, off, SEEK_SET) == off;
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

157
libs/tiff/libtiff/tif_close.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -37,75 +37,81 @@
* completely freed, so you should save opened file handle and pointer * completely freed, so you should save opened file handle and pointer
* to the close procedure in external variables before calling * to the close procedure in external variables before calling
* _TIFFCleanup(), if you will need these ones to close the file. * _TIFFCleanup(), if you will need these ones to close the file.
* *
* @param tif A TIFF pointer. * @param tif A TIFF pointer.
*/ */
void void TIFFCleanup(TIFF *tif)
TIFFCleanup(TIFF* tif)
{ {
/* /*
* Flush buffered data and directory (if dirty). * Flush buffered data and directory (if dirty).
*/ */
if (tif->tif_mode != O_RDONLY) if (tif->tif_mode != O_RDONLY)
TIFFFlush(tif); TIFFFlush(tif);
(*tif->tif_cleanup)(tif); (*tif->tif_cleanup)(tif);
TIFFFreeDirectory(tif); TIFFFreeDirectory(tif);
if (tif->tif_dirlist) TIFFHashSetDestroy(tif->tif_map_dir_offset_to_number);
_TIFFfree(tif->tif_dirlist); TIFFHashSetDestroy(tif->tif_map_dir_number_to_offset);
/* /*
* Clean up client info links. * Clean up client info links.
*/ */
while( tif->tif_clientinfo ) while (tif->tif_clientinfo)
{ {
TIFFClientInfoLink *psLink = tif->tif_clientinfo; TIFFClientInfoLink *psLink = tif->tif_clientinfo;
tif->tif_clientinfo = psLink->next; tif->tif_clientinfo = psLink->next;
_TIFFfree( psLink->name ); _TIFFfreeExt(tif, psLink->name);
_TIFFfree( psLink ); _TIFFfreeExt(tif, psLink);
} }
if (tif->tif_rawdata && (tif->tif_flags&TIFF_MYBUFFER)) if (tif->tif_rawdata && (tif->tif_flags & TIFF_MYBUFFER))
_TIFFfree(tif->tif_rawdata); _TIFFfreeExt(tif, tif->tif_rawdata);
if (isMapped(tif)) if (isMapped(tif))
TIFFUnmapFileContents(tif, tif->tif_base, (toff_t)tif->tif_size); TIFFUnmapFileContents(tif, tif->tif_base, (toff_t)tif->tif_size);
/* /*
* Clean up custom fields. * Clean up custom fields.
*/ */
if (tif->tif_fields && tif->tif_nfields > 0) { if (tif->tif_fields && tif->tif_nfields > 0)
uint32_t i; {
uint32_t i;
for (i = 0; i < tif->tif_nfields; i++) { for (i = 0; i < tif->tif_nfields; i++)
TIFFField *fld = tif->tif_fields[i]; {
if (fld->field_name != NULL) { TIFFField *fld = tif->tif_fields[i];
if (fld->field_bit == FIELD_CUSTOM && if (fld->field_name != NULL)
/* caution: tif_fields[i] must not be the beginning of a fields-array. {
* Otherwise the following tags are also freed with the first free(). if (fld->field_bit == FIELD_CUSTOM &&
*/ /* caution: tif_fields[i] must not be the beginning of a
TIFFFieldIsAnonymous(fld)) { * fields-array. Otherwise the following tags are also freed
_TIFFfree(fld->field_name); * with the first free().
_TIFFfree(fld); */
} TIFFFieldIsAnonymous(fld))
} {
} _TIFFfreeExt(tif, fld->field_name);
_TIFFfreeExt(tif, fld);
_TIFFfree(tif->tif_fields);
}
if (tif->tif_nfieldscompat > 0) {
uint32_t i;
for (i = 0; i < tif->tif_nfieldscompat; i++) {
if (tif->tif_fieldscompat[i].allocated_size)
_TIFFfree(tif->tif_fieldscompat[i].fields);
} }
_TIFFfree(tif->tif_fieldscompat); }
} }
_TIFFfree(tif); _TIFFfreeExt(tif, tif->tif_fields);
}
if (tif->tif_nfieldscompat > 0)
{
uint32_t i;
for (i = 0; i < tif->tif_nfieldscompat; i++)
{
if (tif->tif_fieldscompat[i].allocated_size)
_TIFFfreeExt(tif, tif->tif_fieldscompat[i].fields);
}
_TIFFfreeExt(tif, tif->tif_fieldscompat);
}
_TIFFfreeExt(NULL, tif);
} }
/************************************************************************/ /************************************************************************/
@ -118,26 +124,15 @@ TIFFCleanup(TIFF* tif)
* TIFFClose closes a file that was previously opened with TIFFOpen(). * TIFFClose closes a file that was previously opened with TIFFOpen().
* Any buffered data are flushed to the file, including the contents of * Any buffered data are flushed to the file, including the contents of
* the current directory (if modified); and all resources are reclaimed. * the current directory (if modified); and all resources are reclaimed.
* *
* @param tif A TIFF pointer. * @param tif A TIFF pointer.
*/ */
void void TIFFClose(TIFF *tif)
TIFFClose(TIFF* tif)
{ {
TIFFCloseProc closeproc = tif->tif_closeproc; TIFFCloseProc closeproc = tif->tif_closeproc;
thandle_t fd = tif->tif_clientdata; thandle_t fd = tif->tif_clientdata;
TIFFCleanup(tif); TIFFCleanup(tif);
(void) (*closeproc)(fd); (void)(*closeproc)(fd);
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

136
libs/tiff/libtiff/tif_codec.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -29,7 +29,7 @@
*/ */
#include "tiffiop.h" #include "tiffiop.h"
static int NotConfigured(TIFF*, int); static int NotConfigured(TIFF *, int);
#ifndef LZW_SUPPORT #ifndef LZW_SUPPORT
#define TIFFInitLZW NotConfigured #define TIFFInitLZW NotConfigured
@ -84,54 +84,52 @@ static int NotConfigured(TIFF*, int);
* Compression schemes statically built into the library. * Compression schemes statically built into the library.
*/ */
const TIFFCodec _TIFFBuiltinCODECS[] = { const TIFFCodec _TIFFBuiltinCODECS[] = {
{ "None", COMPRESSION_NONE, TIFFInitDumpMode }, {"None", COMPRESSION_NONE, TIFFInitDumpMode},
{ "LZW", COMPRESSION_LZW, TIFFInitLZW }, {"LZW", COMPRESSION_LZW, TIFFInitLZW},
{ "PackBits", COMPRESSION_PACKBITS, TIFFInitPackBits }, {"PackBits", COMPRESSION_PACKBITS, TIFFInitPackBits},
{ "ThunderScan", COMPRESSION_THUNDERSCAN,TIFFInitThunderScan }, {"ThunderScan", COMPRESSION_THUNDERSCAN, TIFFInitThunderScan},
{ "NeXT", COMPRESSION_NEXT, TIFFInitNeXT }, {"NeXT", COMPRESSION_NEXT, TIFFInitNeXT},
{ "JPEG", COMPRESSION_JPEG, TIFFInitJPEG }, {"JPEG", COMPRESSION_JPEG, TIFFInitJPEG},
{ "Old-style JPEG", COMPRESSION_OJPEG, TIFFInitOJPEG }, {"Old-style JPEG", COMPRESSION_OJPEG, TIFFInitOJPEG},
{ "CCITT RLE", COMPRESSION_CCITTRLE, TIFFInitCCITTRLE }, {"CCITT RLE", COMPRESSION_CCITTRLE, TIFFInitCCITTRLE},
{ "CCITT RLE/W", COMPRESSION_CCITTRLEW, TIFFInitCCITTRLEW }, {"CCITT RLE/W", COMPRESSION_CCITTRLEW, TIFFInitCCITTRLEW},
{ "CCITT Group 3", COMPRESSION_CCITTFAX3, TIFFInitCCITTFax3 }, {"CCITT Group 3", COMPRESSION_CCITTFAX3, TIFFInitCCITTFax3},
{ "CCITT Group 4", COMPRESSION_CCITTFAX4, TIFFInitCCITTFax4 }, {"CCITT Group 4", COMPRESSION_CCITTFAX4, TIFFInitCCITTFax4},
{ "ISO JBIG", COMPRESSION_JBIG, TIFFInitJBIG }, {"ISO JBIG", COMPRESSION_JBIG, TIFFInitJBIG},
{ "Deflate", COMPRESSION_DEFLATE, TIFFInitZIP }, {"Deflate", COMPRESSION_DEFLATE, TIFFInitZIP},
{ "AdobeDeflate", COMPRESSION_ADOBE_DEFLATE , TIFFInitZIP }, {"AdobeDeflate", COMPRESSION_ADOBE_DEFLATE, TIFFInitZIP},
{ "PixarLog", COMPRESSION_PIXARLOG, TIFFInitPixarLog }, {"PixarLog", COMPRESSION_PIXARLOG, TIFFInitPixarLog},
{ "SGILog", COMPRESSION_SGILOG, TIFFInitSGILog }, {"SGILog", COMPRESSION_SGILOG, TIFFInitSGILog},
{ "SGILog24", COMPRESSION_SGILOG24, TIFFInitSGILog }, {"SGILog24", COMPRESSION_SGILOG24, TIFFInitSGILog},
{ "LZMA", COMPRESSION_LZMA, TIFFInitLZMA }, {"LZMA", COMPRESSION_LZMA, TIFFInitLZMA},
{ "ZSTD", COMPRESSION_ZSTD, TIFFInitZSTD }, {"ZSTD", COMPRESSION_ZSTD, TIFFInitZSTD},
{ "WEBP", COMPRESSION_WEBP, TIFFInitWebP }, {"WEBP", COMPRESSION_WEBP, TIFFInitWebP},
{ "LERC", COMPRESSION_LERC, TIFFInitLERC }, {"LERC", COMPRESSION_LERC, TIFFInitLERC},
{ NULL, 0, NULL } {NULL, 0, NULL}};
};
static int static int _notConfigured(TIFF *tif)
_notConfigured(TIFF* tif)
{ {
const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression); const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression);
char compression_code[20]; char compression_code[20];
sprintf(compression_code, "%"PRIu16, tif->tif_dir.td_compression ); snprintf(compression_code, sizeof(compression_code), "%" PRIu16,
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, tif->tif_dir.td_compression);
"%s compression support is not configured", TIFFErrorExtR(tif, tif->tif_name,
c ? c->name : compression_code ); "%s compression support is not configured",
return (0); c ? c->name : compression_code);
return (0);
} }
static int static int NotConfigured(TIFF *tif, int scheme)
NotConfigured(TIFF* tif, int scheme)
{ {
(void) scheme; (void)scheme;
tif->tif_fixuptags = _notConfigured; tif->tif_fixuptags = _notConfigured;
tif->tif_decodestatus = FALSE; tif->tif_decodestatus = FALSE;
tif->tif_setupdecode = _notConfigured; tif->tif_setupdecode = _notConfigured;
tif->tif_encodestatus = FALSE; tif->tif_encodestatus = FALSE;
tif->tif_setupencode = _notConfigured; tif->tif_setupencode = _notConfigured;
return (1); return (1);
} }
/************************************************************************/ /************************************************************************/
@ -145,27 +143,21 @@ NotConfigured(TIFF* tif, int scheme)
* 0 will be returned. * 0 will be returned.
*/ */
int int TIFFIsCODECConfigured(uint16_t scheme)
TIFFIsCODECConfigured(uint16_t scheme)
{ {
const TIFFCodec* codec = TIFFFindCODEC(scheme); const TIFFCodec *codec = TIFFFindCODEC(scheme);
if(codec == NULL) { if (codec == NULL)
return 0; {
} return 0;
if(codec->init == NULL) { }
return 0; if (codec->init == NULL)
} {
if(codec->init != NotConfigured){ return 0;
return 1; }
} if (codec->init != NotConfigured)
return 0; {
return 1;
}
return 0;
} }
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

412
libs/tiff/libtiff/tif_compress.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -29,145 +29,152 @@
*/ */
#include "tiffiop.h" #include "tiffiop.h"
static int static int TIFFNoEncode(TIFF *tif, const char *method)
TIFFNoEncode(TIFF* tif, const char* method)
{ {
const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression); const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression);
if (c) { if (c)
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, {
"%s %s encoding is not implemented", TIFFErrorExtR(tif, tif->tif_name, "%s %s encoding is not implemented",
c->name, method); c->name, method);
} else { }
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, else
"Compression scheme %"PRIu16" %s encoding is not implemented", {
tif->tif_dir.td_compression, method); TIFFErrorExtR(tif, tif->tif_name,
} "Compression scheme %" PRIu16
return (-1); " %s encoding is not implemented",
tif->tif_dir.td_compression, method);
}
return (-1);
} }
int int _TIFFNoRowEncode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
_TIFFNoRowEncode(TIFF* tif, uint8_t* pp, tmsize_t cc, uint16_t s)
{ {
(void) pp; (void) cc; (void) s; (void)pp;
return (TIFFNoEncode(tif, "scanline")); (void)cc;
(void)s;
return (TIFFNoEncode(tif, "scanline"));
} }
int int _TIFFNoStripEncode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
_TIFFNoStripEncode(TIFF* tif, uint8_t* pp, tmsize_t cc, uint16_t s)
{ {
(void) pp; (void) cc; (void) s; (void)pp;
return (TIFFNoEncode(tif, "strip")); (void)cc;
(void)s;
return (TIFFNoEncode(tif, "strip"));
} }
int int _TIFFNoTileEncode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
_TIFFNoTileEncode(TIFF* tif, uint8_t* pp, tmsize_t cc, uint16_t s)
{ {
(void) pp; (void) cc; (void) s; (void)pp;
return (TIFFNoEncode(tif, "tile")); (void)cc;
(void)s;
return (TIFFNoEncode(tif, "tile"));
} }
static int static int TIFFNoDecode(TIFF *tif, const char *method)
TIFFNoDecode(TIFF* tif, const char* method)
{ {
const TIFFCodec* c = TIFFFindCODEC(tif->tif_dir.td_compression); const TIFFCodec *c = TIFFFindCODEC(tif->tif_dir.td_compression);
if (c) if (c)
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, TIFFErrorExtR(tif, tif->tif_name, "%s %s decoding is not implemented",
"%s %s decoding is not implemented", c->name, method);
c->name, method); else
else TIFFErrorExtR(tif, tif->tif_name,
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Compression scheme %" PRIu16
"Compression scheme %"PRIu16" %s decoding is not implemented", " %s decoding is not implemented",
tif->tif_dir.td_compression, method); tif->tif_dir.td_compression, method);
return (0); return (0);
} }
static int static int _TIFFNoFixupTags(TIFF *tif)
_TIFFNoFixupTags(TIFF* tif)
{ {
(void) tif; (void)tif;
return (1); return (1);
} }
int int _TIFFNoRowDecode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
_TIFFNoRowDecode(TIFF* tif, uint8_t* pp, tmsize_t cc, uint16_t s)
{ {
(void) pp; (void) cc; (void) s; (void)pp;
return (TIFFNoDecode(tif, "scanline")); (void)cc;
(void)s;
return (TIFFNoDecode(tif, "scanline"));
} }
int int _TIFFNoStripDecode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
_TIFFNoStripDecode(TIFF* tif, uint8_t* pp, tmsize_t cc, uint16_t s)
{ {
(void) pp; (void) cc; (void) s; (void)pp;
return (TIFFNoDecode(tif, "strip")); (void)cc;
(void)s;
return (TIFFNoDecode(tif, "strip"));
} }
int int _TIFFNoTileDecode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
_TIFFNoTileDecode(TIFF* tif, uint8_t* pp, tmsize_t cc, uint16_t s)
{ {
(void) pp; (void) cc; (void) s; (void)pp;
return (TIFFNoDecode(tif, "tile")); (void)cc;
(void)s;
return (TIFFNoDecode(tif, "tile"));
} }
int int _TIFFNoSeek(TIFF *tif, uint32_t off)
_TIFFNoSeek(TIFF* tif, uint32_t off)
{ {
(void) off; (void)off;
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, TIFFErrorExtR(tif, tif->tif_name,
"Compression algorithm does not support random access"); "Compression algorithm does not support random access");
return (0); return (0);
} }
int int _TIFFNoPreCode(TIFF *tif, uint16_t s)
_TIFFNoPreCode(TIFF* tif, uint16_t s)
{ {
(void) tif; (void) s; (void)tif;
return (1); (void)s;
return (1);
} }
static int _TIFFtrue(TIFF* tif) { (void) tif; return (1); } static int _TIFFtrue(TIFF *tif)
static void _TIFFvoid(TIFF* tif) { (void) tif; }
void
_TIFFSetDefaultCompressionState(TIFF* tif)
{ {
tif->tif_fixuptags = _TIFFNoFixupTags; (void)tif;
tif->tif_decodestatus = TRUE; return (1);
tif->tif_setupdecode = _TIFFtrue; }
tif->tif_predecode = _TIFFNoPreCode; static void _TIFFvoid(TIFF *tif) { (void)tif; }
tif->tif_decoderow = _TIFFNoRowDecode;
tif->tif_decodestrip = _TIFFNoStripDecode; void _TIFFSetDefaultCompressionState(TIFF *tif)
tif->tif_decodetile = _TIFFNoTileDecode; {
tif->tif_encodestatus = TRUE; tif->tif_fixuptags = _TIFFNoFixupTags;
tif->tif_setupencode = _TIFFtrue; tif->tif_decodestatus = TRUE;
tif->tif_preencode = _TIFFNoPreCode; tif->tif_setupdecode = _TIFFtrue;
tif->tif_postencode = _TIFFtrue; tif->tif_predecode = _TIFFNoPreCode;
tif->tif_encoderow = _TIFFNoRowEncode; tif->tif_decoderow = _TIFFNoRowDecode;
tif->tif_encodestrip = _TIFFNoStripEncode; tif->tif_decodestrip = _TIFFNoStripDecode;
tif->tif_encodetile = _TIFFNoTileEncode; tif->tif_decodetile = _TIFFNoTileDecode;
tif->tif_close = _TIFFvoid; tif->tif_encodestatus = TRUE;
tif->tif_seek = _TIFFNoSeek; tif->tif_setupencode = _TIFFtrue;
tif->tif_cleanup = _TIFFvoid; tif->tif_preencode = _TIFFNoPreCode;
tif->tif_defstripsize = _TIFFDefaultStripSize; tif->tif_postencode = _TIFFtrue;
tif->tif_deftilesize = _TIFFDefaultTileSize; tif->tif_encoderow = _TIFFNoRowEncode;
tif->tif_flags &= ~(TIFF_NOBITREV|TIFF_NOREADRAW); tif->tif_encodestrip = _TIFFNoStripEncode;
tif->tif_encodetile = _TIFFNoTileEncode;
tif->tif_close = _TIFFvoid;
tif->tif_seek = _TIFFNoSeek;
tif->tif_cleanup = _TIFFvoid;
tif->tif_defstripsize = _TIFFDefaultStripSize;
tif->tif_deftilesize = _TIFFDefaultTileSize;
tif->tif_flags &= ~(TIFF_NOBITREV | TIFF_NOREADRAW);
} }
int int TIFFSetCompressionScheme(TIFF *tif, int scheme)
TIFFSetCompressionScheme(TIFF* tif, int scheme)
{ {
const TIFFCodec *c = TIFFFindCODEC((uint16_t) scheme); const TIFFCodec *c = TIFFFindCODEC((uint16_t)scheme);
_TIFFSetDefaultCompressionState(tif); _TIFFSetDefaultCompressionState(tif);
/* /*
* Don't treat an unknown compression scheme as an error. * Don't treat an unknown compression scheme as an error.
* This permits applications to open files with data that * This permits applications to open files with data that
* the library does not have builtin support for, but which * the library does not have builtin support for, but which
* may still be meaningful. * may still be meaningful.
*/ */
return (c ? (*c->init)(tif, scheme) : 1); return (c ? (*c->init)(tif, scheme) : 1);
} }
/* /*
@ -175,64 +182,68 @@ TIFFSetCompressionScheme(TIFF* tif, int scheme)
* schemes can also override the builtin versions provided * schemes can also override the builtin versions provided
* by this library. * by this library.
*/ */
typedef struct _codec { typedef struct _codec
struct _codec* next; {
TIFFCodec* info; struct _codec *next;
TIFFCodec *info;
} codec_t; } codec_t;
static codec_t* registeredCODECS = NULL; static codec_t *registeredCODECS = NULL;
const TIFFCodec* const TIFFCodec *TIFFFindCODEC(uint16_t scheme)
TIFFFindCODEC(uint16_t scheme)
{ {
const TIFFCodec* c; const TIFFCodec *c;
codec_t* cd; codec_t *cd;
for (cd = registeredCODECS; cd; cd = cd->next) for (cd = registeredCODECS; cd; cd = cd->next)
if (cd->info->scheme == scheme) if (cd->info->scheme == scheme)
return ((const TIFFCodec*) cd->info); return ((const TIFFCodec *)cd->info);
for (c = _TIFFBuiltinCODECS; c->name; c++) for (c = _TIFFBuiltinCODECS; c->name; c++)
if (c->scheme == scheme) if (c->scheme == scheme)
return (c); return (c);
return ((const TIFFCodec*) 0); return ((const TIFFCodec *)0);
} }
TIFFCodec* TIFFCodec *TIFFRegisterCODEC(uint16_t scheme, const char *name,
TIFFRegisterCODEC(uint16_t scheme, const char* name, TIFFInitMethod init) TIFFInitMethod init)
{ {
codec_t* cd = (codec_t*) codec_t *cd = (codec_t *)_TIFFmallocExt(
_TIFFmalloc((tmsize_t)(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1)); NULL,
(tmsize_t)(sizeof(codec_t) + sizeof(TIFFCodec) + strlen(name) + 1));
if (cd != NULL) { if (cd != NULL)
cd->info = (TIFFCodec*) ((uint8_t*) cd + sizeof (codec_t)); {
cd->info->name = (char*) cd->info = (TIFFCodec *)((uint8_t *)cd + sizeof(codec_t));
((uint8_t*) cd->info + sizeof (TIFFCodec)); cd->info->name = (char *)((uint8_t *)cd->info + sizeof(TIFFCodec));
strcpy(cd->info->name, name); strcpy(cd->info->name, name);
cd->info->scheme = scheme; cd->info->scheme = scheme;
cd->info->init = init; cd->info->init = init;
cd->next = registeredCODECS; cd->next = registeredCODECS;
registeredCODECS = cd; registeredCODECS = cd;
} else { }
TIFFErrorExt(0, "TIFFRegisterCODEC", else
"No space to register compression scheme %s", name); {
return NULL; TIFFErrorExt(0, "TIFFRegisterCODEC",
} "No space to register compression scheme %s", name);
return (cd->info); return NULL;
}
return (cd->info);
} }
void void TIFFUnRegisterCODEC(TIFFCodec *c)
TIFFUnRegisterCODEC(TIFFCodec* c)
{ {
codec_t* cd; codec_t *cd;
codec_t** pcd; codec_t **pcd;
for (pcd = &registeredCODECS; (cd = *pcd) != NULL; pcd = &cd->next) for (pcd = &registeredCODECS; (cd = *pcd) != NULL; pcd = &cd->next)
if (cd->info == c) { if (cd->info == c)
*pcd = cd->next; {
_TIFFfree(cd); *pcd = cd->next;
return; _TIFFfreeExt(NULL, cd);
} return;
TIFFErrorExt(0, "TIFFUnRegisterCODEC", }
"Cannot remove compression scheme %s; not registered", c->name); TIFFErrorExt(0, "TIFFUnRegisterCODEC",
"Cannot remove compression scheme %s; not registered",
c->name);
} }
/************************************************************************/ /************************************************************************/
@ -242,61 +253,58 @@ TIFFUnRegisterCODEC(TIFFCodec* c)
/** /**
* Get list of configured codecs, both built-in and registered by user. * Get list of configured codecs, both built-in and registered by user.
* Caller is responsible to free this structure. * Caller is responsible to free this structure.
* *
* @return returns array of TIFFCodec records (the last record should be NULL) * @return returns array of TIFFCodec records (the last record should be NULL)
* or NULL if function failed. * or NULL if function failed.
*/ */
TIFFCodec* TIFFCodec *TIFFGetConfiguredCODECs()
TIFFGetConfiguredCODECs()
{ {
int i = 1; int i = 1;
codec_t *cd; codec_t *cd;
const TIFFCodec* c; const TIFFCodec *c;
TIFFCodec* codecs = NULL; TIFFCodec *codecs = NULL;
TIFFCodec* new_codecs; TIFFCodec *new_codecs;
for (cd = registeredCODECS; cd; cd = cd->next) { for (cd = registeredCODECS; cd; cd = cd->next)
new_codecs = (TIFFCodec *) {
_TIFFrealloc(codecs, i * sizeof(TIFFCodec)); new_codecs =
if (!new_codecs) { (TIFFCodec *)_TIFFreallocExt(NULL, codecs, i * sizeof(TIFFCodec));
_TIFFfree (codecs); if (!new_codecs)
return NULL; {
} _TIFFfreeExt(NULL, codecs);
codecs = new_codecs; return NULL;
_TIFFmemcpy(codecs + i - 1, cd->info, sizeof(TIFFCodec)); }
i++; codecs = new_codecs;
} _TIFFmemcpy(codecs + i - 1, cd->info, sizeof(TIFFCodec));
for (c = _TIFFBuiltinCODECS; c->name; c++) { i++;
if (TIFFIsCODECConfigured(c->scheme)) { }
new_codecs = (TIFFCodec *) for (c = _TIFFBuiltinCODECS; c->name; c++)
_TIFFrealloc(codecs, i * sizeof(TIFFCodec)); {
if (!new_codecs) { if (TIFFIsCODECConfigured(c->scheme))
_TIFFfree (codecs); {
return NULL; new_codecs = (TIFFCodec *)_TIFFreallocExt(NULL, codecs,
} i * sizeof(TIFFCodec));
codecs = new_codecs; if (!new_codecs)
_TIFFmemcpy(codecs + i - 1, (const void*)c, sizeof(TIFFCodec)); {
i++; _TIFFfreeExt(NULL, codecs);
} return NULL;
} }
codecs = new_codecs;
_TIFFmemcpy(codecs + i - 1, (const void *)c, sizeof(TIFFCodec));
i++;
}
}
new_codecs = (TIFFCodec *) _TIFFrealloc(codecs, i * sizeof(TIFFCodec)); new_codecs =
if (!new_codecs) { (TIFFCodec *)_TIFFreallocExt(NULL, codecs, i * sizeof(TIFFCodec));
_TIFFfree (codecs); if (!new_codecs)
return NULL; {
} _TIFFfreeExt(NULL, codecs);
codecs = new_codecs; return NULL;
_TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec)); }
codecs = new_codecs;
_TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec));
return codecs; return codecs;
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

6
libs/tiff/libtiff/tif_config.h
View file

@ -99,7 +99,7 @@
#define PACKAGE_NAME "LibTIFF Software" #define PACKAGE_NAME "LibTIFF Software"
/* Define to the full name and version of this package. */ /* Define to the full name and version of this package. */
#define PACKAGE_STRING "LibTIFF Software 4.4.0" #define PACKAGE_STRING "LibTIFF Software 4.5.0"
/* Define to the one symbol short name of this package. */ /* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "tiff" #define PACKAGE_TARNAME "tiff"
@ -108,7 +108,7 @@
#define PACKAGE_URL "" #define PACKAGE_URL ""
/* Define to the version of this package. */ /* Define to the version of this package. */
#define PACKAGE_VERSION "4.4.0" #define PACKAGE_VERSION "4.5.0"
/* The size of `size_t', as computed by sizeof. */ /* The size of `size_t', as computed by sizeof. */
#define SIZEOF_SIZE_T 4 #define SIZEOF_SIZE_T 4
@ -120,7 +120,7 @@
#define USE_WIN32_FILEIO 1 #define USE_WIN32_FILEIO 1
/* Version number of package */ /* Version number of package */
#define VERSION "4.4.0" #define VERSION "4.5.0"
/* Support webp compression */ /* Support webp compression */
/* #undef WEBP_SUPPORT */ /* #undef WEBP_SUPPORT */

3601
libs/tiff/libtiff/tif_dir.c
View file

File diff suppressed because it is too large Load diff

461
libs/tiff/libtiff/tif_dir.h
View file

@ -2,28 +2,28 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
#ifndef _TIFFDIR_ #ifndef _TIFFDIR_
#define _TIFFDIR_ #define _TIFFDIR_
#include "tiff.h" #include "tiff.h"
#include "tiffio.h" #include "tiffio.h"
@ -32,10 +32,11 @@
* ``Library-private'' Directory-related Definitions. * ``Library-private'' Directory-related Definitions.
*/ */
typedef struct { typedef struct
const TIFFField *info; {
int count; const TIFFField *info;
void *value; int count;
void *value;
} TIFFTagValue; } TIFFTagValue;
/* /*
@ -49,79 +50,91 @@ typedef struct {
* BigTIFF, then it is placed in the offset field to save space. If so, * BigTIFF, then it is placed in the offset field to save space. If so,
* it is left-justified in the offset field. * it is left-justified in the offset field.
*/ */
typedef struct { typedef struct
uint16_t tdir_tag; /* see below */ {
uint16_t tdir_type; /* data type; see below */ uint16_t tdir_tag; /* see below */
uint64_t tdir_count; /* number of items; length in spec */ uint16_t tdir_type; /* data type; see below */
union { uint64_t tdir_count; /* number of items; length in spec */
uint16_t toff_short; union
uint32_t toff_long; {
uint64_t toff_long8; uint16_t toff_short;
} tdir_offset; /* either offset or the data itself if fits */ uint32_t toff_long;
uint8_t tdir_ignore; /* flag status to ignore tag when parsing tags in tif_dirread.c */ uint64_t toff_long8;
} tdir_offset; /* either offset or the data itself if fits */
uint8_t tdir_ignore; /* flag status to ignore tag when parsing tags in
tif_dirread.c */
} TIFFDirEntry; } TIFFDirEntry;
/* /*
* Internal format of a TIFF directory entry. * Internal format of a TIFF directory entry.
*/ */
typedef struct { typedef struct
{
#define FIELD_SETLONGS 4 #define FIELD_SETLONGS 4
/* bit vector of fields that are set */ /* bit vector of fields that are set */
unsigned long td_fieldsset[FIELD_SETLONGS]; unsigned long td_fieldsset[FIELD_SETLONGS];
uint32_t td_imagewidth, td_imagelength, td_imagedepth; uint32_t td_imagewidth, td_imagelength, td_imagedepth;
uint32_t td_tilewidth, td_tilelength, td_tiledepth; uint32_t td_tilewidth, td_tilelength, td_tiledepth;
uint32_t td_subfiletype; uint32_t td_subfiletype;
uint16_t td_bitspersample; uint16_t td_bitspersample;
uint16_t td_sampleformat; uint16_t td_sampleformat;
uint16_t td_compression; uint16_t td_compression;
uint16_t td_photometric; uint16_t td_photometric;
uint16_t td_threshholding; uint16_t td_threshholding;
uint16_t td_fillorder; uint16_t td_fillorder;
uint16_t td_orientation; uint16_t td_orientation;
uint16_t td_samplesperpixel; uint16_t td_samplesperpixel;
uint32_t td_rowsperstrip; uint32_t td_rowsperstrip;
uint16_t td_minsamplevalue, td_maxsamplevalue; uint16_t td_minsamplevalue, td_maxsamplevalue;
double* td_sminsamplevalue; double *td_sminsamplevalue;
double* td_smaxsamplevalue; double *td_smaxsamplevalue;
float td_xresolution, td_yresolution; float td_xresolution, td_yresolution;
uint16_t td_resolutionunit; uint16_t td_resolutionunit;
uint16_t td_planarconfig; uint16_t td_planarconfig;
float td_xposition, td_yposition; float td_xposition, td_yposition;
uint16_t td_pagenumber[2]; uint16_t td_pagenumber[2];
uint16_t* td_colormap[3]; uint16_t *td_colormap[3];
uint16_t td_halftonehints[2]; uint16_t td_halftonehints[2];
uint16_t td_extrasamples; uint16_t td_extrasamples;
uint16_t* td_sampleinfo; uint16_t *td_sampleinfo;
/* even though the name is misleading, td_stripsperimage is the number /* even though the name is misleading, td_stripsperimage is the number
* of striles (=strips or tiles) per plane, and td_nstrips the total * of striles (=strips or tiles) per plane, and td_nstrips the total
* number of striles */ * number of striles */
uint32_t td_stripsperimage; uint32_t td_stripsperimage;
uint32_t td_nstrips; /* size of offset & bytecount arrays */ uint32_t td_nstrips; /* size of offset & bytecount arrays */
uint64_t* td_stripoffset_p; /* should be accessed with TIFFGetStrileOffset */ uint64_t
uint64_t* td_stripbytecount_p; /* should be accessed with TIFFGetStrileByteCount */ *td_stripoffset_p; /* should be accessed with TIFFGetStrileOffset */
uint32_t td_stripoffsetbyteallocsize; /* number of elements currently allocated for td_stripoffset/td_stripbytecount. Only used if TIFF_LAZYSTRILELOAD is set */ uint64_t *td_stripbytecount_p; /* should be accessed with
TIFFGetStrileByteCount */
uint32_t
td_stripoffsetbyteallocsize; /* number of elements currently allocated
for td_stripoffset/td_stripbytecount.
Only used if TIFF_LAZYSTRILELOAD is set
*/
#ifdef STRIPBYTECOUNTSORTED_UNUSED #ifdef STRIPBYTECOUNTSORTED_UNUSED
int td_stripbytecountsorted; /* is the bytecount array sorted ascending? */ int td_stripbytecountsorted; /* is the bytecount array sorted ascending? */
#endif #endif
TIFFDirEntry td_stripoffset_entry; /* for deferred loading */ TIFFDirEntry td_stripoffset_entry; /* for deferred loading */
TIFFDirEntry td_stripbytecount_entry; /* for deferred loading */ TIFFDirEntry td_stripbytecount_entry; /* for deferred loading */
uint16_t td_nsubifd; uint16_t td_nsubifd;
uint64_t* td_subifd; uint64_t *td_subifd;
/* YCbCr parameters */ /* YCbCr parameters */
uint16_t td_ycbcrsubsampling[2]; uint16_t td_ycbcrsubsampling[2];
uint16_t td_ycbcrpositioning; uint16_t td_ycbcrpositioning;
/* Colorimetry parameters */ /* Colorimetry parameters */
uint16_t* td_transferfunction[3]; uint16_t *td_transferfunction[3];
float* td_refblackwhite; float *td_refblackwhite;
/* CMYK parameters */ /* CMYK parameters */
int td_inknameslen; int td_inknameslen;
char* td_inknames; char *td_inknames;
uint16_t td_numberofinks; /* number of inks in InkNames string */
int td_customValueCount; int td_customValueCount;
TIFFTagValue *td_customValues; TIFFTagValue *td_customValues;
unsigned char td_deferstrilearraywriting; /* see TIFFDeferStrileArrayWriting() */ unsigned char
td_deferstrilearraywriting; /* see TIFFDeferStrileArrayWriting() */
} TIFFDirectory; } TIFFDirectory;
/* /*
@ -135,49 +148,49 @@ typedef struct {
* Note that a bit *is* allocated for ignored tags; this is understood by the * Note that a bit *is* allocated for ignored tags; this is understood by the
* directory reading logic which uses this fact to avoid special-case handling * directory reading logic which uses this fact to avoid special-case handling
*/ */
#define FIELD_IGNORE 0 #define FIELD_IGNORE 0
/* multi-item fields */ /* multi-item fields */
#define FIELD_IMAGEDIMENSIONS 1 #define FIELD_IMAGEDIMENSIONS 1
#define FIELD_TILEDIMENSIONS 2 #define FIELD_TILEDIMENSIONS 2
#define FIELD_RESOLUTION 3 #define FIELD_RESOLUTION 3
#define FIELD_POSITION 4 #define FIELD_POSITION 4
/* single-item fields */ /* single-item fields */
#define FIELD_SUBFILETYPE 5 #define FIELD_SUBFILETYPE 5
#define FIELD_BITSPERSAMPLE 6 #define FIELD_BITSPERSAMPLE 6
#define FIELD_COMPRESSION 7 #define FIELD_COMPRESSION 7
#define FIELD_PHOTOMETRIC 8 #define FIELD_PHOTOMETRIC 8
#define FIELD_THRESHHOLDING 9 #define FIELD_THRESHHOLDING 9
#define FIELD_FILLORDER 10 #define FIELD_FILLORDER 10
#define FIELD_ORIENTATION 15 #define FIELD_ORIENTATION 15
#define FIELD_SAMPLESPERPIXEL 16 #define FIELD_SAMPLESPERPIXEL 16
#define FIELD_ROWSPERSTRIP 17 #define FIELD_ROWSPERSTRIP 17
#define FIELD_MINSAMPLEVALUE 18 #define FIELD_MINSAMPLEVALUE 18
#define FIELD_MAXSAMPLEVALUE 19 #define FIELD_MAXSAMPLEVALUE 19
#define FIELD_PLANARCONFIG 20 #define FIELD_PLANARCONFIG 20
#define FIELD_RESOLUTIONUNIT 22 #define FIELD_RESOLUTIONUNIT 22
#define FIELD_PAGENUMBER 23 #define FIELD_PAGENUMBER 23
#define FIELD_STRIPBYTECOUNTS 24 #define FIELD_STRIPBYTECOUNTS 24
#define FIELD_STRIPOFFSETS 25 #define FIELD_STRIPOFFSETS 25
#define FIELD_COLORMAP 26 #define FIELD_COLORMAP 26
#define FIELD_EXTRASAMPLES 31 #define FIELD_EXTRASAMPLES 31
#define FIELD_SAMPLEFORMAT 32 #define FIELD_SAMPLEFORMAT 32
#define FIELD_SMINSAMPLEVALUE 33 #define FIELD_SMINSAMPLEVALUE 33
#define FIELD_SMAXSAMPLEVALUE 34 #define FIELD_SMAXSAMPLEVALUE 34
#define FIELD_IMAGEDEPTH 35 #define FIELD_IMAGEDEPTH 35
#define FIELD_TILEDEPTH 36 #define FIELD_TILEDEPTH 36
#define FIELD_HALFTONEHINTS 37 #define FIELD_HALFTONEHINTS 37
#define FIELD_YCBCRSUBSAMPLING 39 #define FIELD_YCBCRSUBSAMPLING 39
#define FIELD_YCBCRPOSITIONING 40 #define FIELD_YCBCRPOSITIONING 40
#define FIELD_REFBLACKWHITE 41 #define FIELD_REFBLACKWHITE 41
#define FIELD_TRANSFERFUNCTION 44 #define FIELD_TRANSFERFUNCTION 44
#define FIELD_INKNAMES 46 #define FIELD_INKNAMES 46
#define FIELD_SUBIFD 49 #define FIELD_SUBIFD 49
#define FIELD_NUMBEROFINKS 50
/* FIELD_CUSTOM (see tiffio.h) 65 */ /* FIELD_CUSTOM (see tiffio.h) 65 */
/* end of support for well-known tags; codec-private tags follow */ /* end of support for well-known tags; codec-private tags follow */
#define FIELD_CODEC 66 /* base of codec-private tags */ #define FIELD_CODEC 66 /* base of codec-private tags */
/* /*
* Pseudo-tags don't normally need field bits since they are not written to an * Pseudo-tags don't normally need field bits since they are not written to an
@ -187,131 +200,137 @@ typedef struct {
* or ``unset'' then it can do using internal state flags without polluting * or ``unset'' then it can do using internal state flags without polluting
* the field bit space defined for real tags. * the field bit space defined for real tags.
*/ */
#define FIELD_PSEUDO 0 #define FIELD_PSEUDO 0
#define FIELD_LAST (32*FIELD_SETLONGS-1) #define FIELD_LAST (32 * FIELD_SETLONGS - 1)
#define BITn(n) (((unsigned long)1L)<<((n)&0x1f)) #define BITn(n) (((unsigned long)1L) << ((n)&0x1f))
#define BITFIELDn(tif, n) ((tif)->tif_dir.td_fieldsset[(n)/32]) #define BITFIELDn(tif, n) ((tif)->tif_dir.td_fieldsset[(n) / 32])
#define TIFFFieldSet(tif, field) (BITFIELDn(tif, field) & BITn(field)) #define TIFFFieldSet(tif, field) (BITFIELDn(tif, field) & BITn(field))
#define TIFFSetFieldBit(tif, field) (BITFIELDn(tif, field) |= BITn(field)) #define TIFFSetFieldBit(tif, field) (BITFIELDn(tif, field) |= BITn(field))
#define TIFFClrFieldBit(tif, field) (BITFIELDn(tif, field) &= ~BITn(field)) #define TIFFClrFieldBit(tif, field) (BITFIELDn(tif, field) &= ~BITn(field))
#define FieldSet(fields, f) (fields[(f)/32] & BITn(f)) #define FieldSet(fields, f) (fields[(f) / 32] & BITn(f))
#define ResetFieldBit(fields, f) (fields[(f)/32] &= ~BITn(f)) #define ResetFieldBit(fields, f) (fields[(f) / 32] &= ~BITn(f))
typedef enum { typedef enum
TIFF_SETGET_UNDEFINED = 0, {
TIFF_SETGET_ASCII = 1, TIFF_SETGET_UNDEFINED = 0,
TIFF_SETGET_UINT8 = 2, TIFF_SETGET_ASCII = 1,
TIFF_SETGET_SINT8 = 3, TIFF_SETGET_UINT8 = 2,
TIFF_SETGET_UINT16 = 4, TIFF_SETGET_SINT8 = 3,
TIFF_SETGET_SINT16 = 5, TIFF_SETGET_UINT16 = 4,
TIFF_SETGET_UINT32 = 6, TIFF_SETGET_SINT16 = 5,
TIFF_SETGET_SINT32 = 7, TIFF_SETGET_UINT32 = 6,
TIFF_SETGET_UINT64 = 8, TIFF_SETGET_SINT32 = 7,
TIFF_SETGET_SINT64 = 9, TIFF_SETGET_UINT64 = 8,
TIFF_SETGET_FLOAT = 10, TIFF_SETGET_SINT64 = 9,
TIFF_SETGET_DOUBLE = 11, TIFF_SETGET_FLOAT = 10,
TIFF_SETGET_IFD8 = 12, TIFF_SETGET_DOUBLE = 11,
TIFF_SETGET_INT = 13, TIFF_SETGET_IFD8 = 12,
TIFF_SETGET_UINT16_PAIR = 14, TIFF_SETGET_INT = 13,
TIFF_SETGET_C0_ASCII = 15, TIFF_SETGET_UINT16_PAIR = 14,
TIFF_SETGET_C0_UINT8 = 16, TIFF_SETGET_C0_ASCII = 15,
TIFF_SETGET_C0_SINT8 = 17, TIFF_SETGET_C0_UINT8 = 16,
TIFF_SETGET_C0_UINT16 = 18, TIFF_SETGET_C0_SINT8 = 17,
TIFF_SETGET_C0_SINT16 = 19, TIFF_SETGET_C0_UINT16 = 18,
TIFF_SETGET_C0_UINT32 = 20, TIFF_SETGET_C0_SINT16 = 19,
TIFF_SETGET_C0_SINT32 = 21, TIFF_SETGET_C0_UINT32 = 20,
TIFF_SETGET_C0_UINT64 = 22, TIFF_SETGET_C0_SINT32 = 21,
TIFF_SETGET_C0_SINT64 = 23, TIFF_SETGET_C0_UINT64 = 22,
TIFF_SETGET_C0_FLOAT = 24, TIFF_SETGET_C0_SINT64 = 23,
TIFF_SETGET_C0_DOUBLE = 25, TIFF_SETGET_C0_FLOAT = 24,
TIFF_SETGET_C0_IFD8 = 26, TIFF_SETGET_C0_DOUBLE = 25,
TIFF_SETGET_C16_ASCII = 27, TIFF_SETGET_C0_IFD8 = 26,
TIFF_SETGET_C16_UINT8 = 28, TIFF_SETGET_C16_ASCII = 27,
TIFF_SETGET_C16_SINT8 = 29, TIFF_SETGET_C16_UINT8 = 28,
TIFF_SETGET_C16_UINT16 = 30, TIFF_SETGET_C16_SINT8 = 29,
TIFF_SETGET_C16_SINT16 = 31, TIFF_SETGET_C16_UINT16 = 30,
TIFF_SETGET_C16_UINT32 = 32, TIFF_SETGET_C16_SINT16 = 31,
TIFF_SETGET_C16_SINT32 = 33, TIFF_SETGET_C16_UINT32 = 32,
TIFF_SETGET_C16_UINT64 = 34, TIFF_SETGET_C16_SINT32 = 33,
TIFF_SETGET_C16_SINT64 = 35, TIFF_SETGET_C16_UINT64 = 34,
TIFF_SETGET_C16_FLOAT = 36, TIFF_SETGET_C16_SINT64 = 35,
TIFF_SETGET_C16_DOUBLE = 37, TIFF_SETGET_C16_FLOAT = 36,
TIFF_SETGET_C16_IFD8 = 38, TIFF_SETGET_C16_DOUBLE = 37,
TIFF_SETGET_C32_ASCII = 39, TIFF_SETGET_C16_IFD8 = 38,
TIFF_SETGET_C32_UINT8 = 40, TIFF_SETGET_C32_ASCII = 39,
TIFF_SETGET_C32_SINT8 = 41, TIFF_SETGET_C32_UINT8 = 40,
TIFF_SETGET_C32_UINT16 = 42, TIFF_SETGET_C32_SINT8 = 41,
TIFF_SETGET_C32_SINT16 = 43, TIFF_SETGET_C32_UINT16 = 42,
TIFF_SETGET_C32_UINT32 = 44, TIFF_SETGET_C32_SINT16 = 43,
TIFF_SETGET_C32_SINT32 = 45, TIFF_SETGET_C32_UINT32 = 44,
TIFF_SETGET_C32_UINT64 = 46, TIFF_SETGET_C32_SINT32 = 45,
TIFF_SETGET_C32_SINT64 = 47, TIFF_SETGET_C32_UINT64 = 46,
TIFF_SETGET_C32_FLOAT = 48, TIFF_SETGET_C32_SINT64 = 47,
TIFF_SETGET_C32_DOUBLE = 49, TIFF_SETGET_C32_FLOAT = 48,
TIFF_SETGET_C32_IFD8 = 50, TIFF_SETGET_C32_DOUBLE = 49,
TIFF_SETGET_OTHER = 51 TIFF_SETGET_C32_IFD8 = 50,
TIFF_SETGET_OTHER = 51
} TIFFSetGetFieldType; } TIFFSetGetFieldType;
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C"
{
#endif #endif
extern const TIFFFieldArray* _TIFFGetFields(void); extern const TIFFFieldArray *_TIFFGetFields(void);
extern const TIFFFieldArray* _TIFFGetExifFields(void); extern const TIFFFieldArray *_TIFFGetExifFields(void);
extern const TIFFFieldArray* _TIFFGetGpsFields(void); extern const TIFFFieldArray *_TIFFGetGpsFields(void);
extern void _TIFFSetupFields(TIFF* tif, const TIFFFieldArray* infoarray); extern void _TIFFSetupFields(TIFF *tif, const TIFFFieldArray *infoarray);
extern void _TIFFPrintFieldInfo(TIFF*, FILE*); extern void _TIFFPrintFieldInfo(TIFF *, FILE *);
extern int _TIFFFillStriles(TIFF*); extern int _TIFFFillStriles(TIFF *);
typedef enum { typedef enum
tfiatImage, {
tfiatExif, tfiatImage,
tfiatGps, /* EXIF-GPS fields array type */ tfiatExif,
tfiatOther tfiatGps, /* EXIF-GPS fields array type */
} TIFFFieldArrayType; tfiatOther
} TIFFFieldArrayType;
struct _TIFFFieldArray { struct _TIFFFieldArray
TIFFFieldArrayType type; /* array type, will be used to determine if IFD is image and such */ {
uint32_t allocated_size; /* 0 if array is constant, other if modified by future definition extension support */ TIFFFieldArrayType type; /* array type, will be used to determine if IFD
uint32_t count; /* number of elements in fields array */ is image and such */
TIFFField* fields; /* actual field info */ uint32_t allocated_size; /* 0 if array is constant, other if modified by
}; future definition extension support */
uint32_t count; /* number of elements in fields array */
TIFFField *fields; /* actual field info */
};
struct _TIFFField { struct _TIFFField
uint32_t field_tag; /* field's tag */ {
short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */ uint32_t field_tag; /* field's tag */
short field_writecount; /* write count/TIFF_VARIABLE */ short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */
TIFFDataType field_type; /* type of associated data */ short field_writecount; /* write count/TIFF_VARIABLE */
uint32_t field_anonymous; /* if true, this is a unknown / anonymous tag */ TIFFDataType field_type; /* type of associated data */
TIFFSetGetFieldType set_field_type; /* type to be passed to TIFFSetField */ uint32_t
TIFFSetGetFieldType get_field_type; /* type to be passed to TIFFGetField */ field_anonymous; /* if true, this is a unknown / anonymous tag */
unsigned short field_bit; /* bit in fieldsset bit vector */ TIFFSetGetFieldType
unsigned char field_oktochange; /* if true, can change while writing */ set_field_type; /* type to be passed to TIFFSetField */
unsigned char field_passcount; /* if true, pass dir count on set */ TIFFSetGetFieldType
char* field_name; /* ASCII name */ get_field_type; /* type to be passed to TIFFGetField */
TIFFFieldArray* field_subfields; /* if field points to child ifds, child ifd field definition array */ unsigned short field_bit; /* bit in fieldsset bit vector */
}; unsigned char field_oktochange; /* if true, can change while writing */
unsigned char field_passcount; /* if true, pass dir count on set */
char *field_name; /* ASCII name */
TIFFFieldArray *field_subfields; /* if field points to child ifds, child
ifd field definition array */
};
extern int _TIFFMergeFields(TIFF*, const TIFFField[], uint32_t); extern int _TIFFMergeFields(TIFF *, const TIFFField[], uint32_t);
extern const TIFFField* _TIFFFindOrRegisterField(TIFF *, uint32_t, TIFFDataType); extern const TIFFField *_TIFFFindOrRegisterField(TIFF *, uint32_t,
extern TIFFField* _TIFFCreateAnonField(TIFF *, uint32_t, TIFFDataType); TIFFDataType);
extern int _TIFFCheckFieldIsValidForCodec(TIFF *tif, ttag_t tag); extern TIFFField *_TIFFCreateAnonField(TIFF *, uint32_t, TIFFDataType);
extern int _TIFFCheckFieldIsValidForCodec(TIFF *tif, ttag_t tag);
extern int _TIFFCheckDirNumberAndOffset(TIFF *tif, tdir_t dirn,
uint64_t diroff);
extern int _TIFFGetDirNumberFromOffset(TIFF *tif, uint64_t diroff,
tdir_t *dirn);
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif #endif
#endif /* _TIFFDIR_ */ #endif /* _TIFFDIR_ */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

2493
libs/tiff/libtiff/tif_dirinfo.c
View file

File diff suppressed because it is too large Load diff

13144
libs/tiff/libtiff/tif_dirread.c
View file

File diff suppressed because it is too large Load diff

5868
libs/tiff/libtiff/tif_dirwrite.c
View file

File diff suppressed because it is too large Load diff

151
libs/tiff/libtiff/tif_dumpmode.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -29,105 +29,94 @@
*/ */
#include "tiffiop.h" #include "tiffiop.h"
static int static int DumpFixupTags(TIFF *tif)
DumpFixupTags(TIFF* tif)
{ {
(void) tif; (void)tif;
return (1); return (1);
} }
/* /*
* Encode a hunk of pixels. * Encode a hunk of pixels.
*/ */
static int static int DumpModeEncode(TIFF *tif, uint8_t *pp, tmsize_t cc, uint16_t s)
DumpModeEncode(TIFF* tif, uint8_t* pp, tmsize_t cc, uint16_t s)
{ {
(void) s; (void)s;
while (cc > 0) { while (cc > 0)
tmsize_t n; {
tmsize_t n;
n = cc; n = cc;
if (tif->tif_rawcc + n > tif->tif_rawdatasize) if (tif->tif_rawcc + n > tif->tif_rawdatasize)
n = tif->tif_rawdatasize - tif->tif_rawcc; n = tif->tif_rawdatasize - tif->tif_rawcc;
assert( n > 0 ); assert(n > 0);
/* /*
* Avoid copy if client has setup raw * Avoid copy if client has setup raw
* data buffer to avoid extra copy. * data buffer to avoid extra copy.
*/ */
if (tif->tif_rawcp != pp) if (tif->tif_rawcp != pp)
_TIFFmemcpy(tif->tif_rawcp, pp, n); _TIFFmemcpy(tif->tif_rawcp, pp, n);
tif->tif_rawcp += n; tif->tif_rawcp += n;
tif->tif_rawcc += n; tif->tif_rawcc += n;
pp += n; pp += n;
cc -= n; cc -= n;
if (tif->tif_rawcc >= tif->tif_rawdatasize && if (tif->tif_rawcc >= tif->tif_rawdatasize && !TIFFFlushData1(tif))
!TIFFFlushData1(tif)) return (0);
return (0); }
} return (1);
return (1);
} }
/* /*
* Decode a hunk of pixels. * Decode a hunk of pixels.
*/ */
static int static int DumpModeDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
DumpModeDecode(TIFF* tif, uint8_t* buf, tmsize_t cc, uint16_t s)
{ {
static const char module[] = "DumpModeDecode"; static const char module[] = "DumpModeDecode";
(void) s; (void)s;
if (tif->tif_rawcc < cc) { if (tif->tif_rawcc < cc)
TIFFErrorExt(tif->tif_clientdata, module, {
"Not enough data for scanline %"PRIu32", expected a request for at most %"TIFF_SSIZE_FORMAT" bytes, got a request for %"TIFF_SSIZE_FORMAT" bytes", TIFFErrorExtR(tif, module,
tif->tif_row, "Not enough data for scanline %" PRIu32
tif->tif_rawcc, ", expected a request for at most %" TIFF_SSIZE_FORMAT
cc); " bytes, got a request for %" TIFF_SSIZE_FORMAT " bytes",
return (0); tif->tif_row, tif->tif_rawcc, cc);
} return (0);
/* }
* Avoid copy if client has setup raw /*
* data buffer to avoid extra copy. * Avoid copy if client has setup raw
*/ * data buffer to avoid extra copy.
if (tif->tif_rawcp != buf) */
_TIFFmemcpy(buf, tif->tif_rawcp, cc); if (tif->tif_rawcp != buf)
tif->tif_rawcp += cc; _TIFFmemcpy(buf, tif->tif_rawcp, cc);
tif->tif_rawcc -= cc; tif->tif_rawcp += cc;
return (1); tif->tif_rawcc -= cc;
return (1);
} }
/* /*
* Seek forwards nrows in the current strip. * Seek forwards nrows in the current strip.
*/ */
static int static int DumpModeSeek(TIFF *tif, uint32_t nrows)
DumpModeSeek(TIFF* tif, uint32_t nrows)
{ {
tif->tif_rawcp += nrows * tif->tif_scanlinesize; tif->tif_rawcp += nrows * tif->tif_scanlinesize;
tif->tif_rawcc -= nrows * tif->tif_scanlinesize; tif->tif_rawcc -= nrows * tif->tif_scanlinesize;
return (1); return (1);
} }
/* /*
* Initialize dump mode. * Initialize dump mode.
*/ */
int int TIFFInitDumpMode(TIFF *tif, int scheme)
TIFFInitDumpMode(TIFF* tif, int scheme)
{ {
(void) scheme; (void)scheme;
tif->tif_fixuptags = DumpFixupTags; tif->tif_fixuptags = DumpFixupTags;
tif->tif_decoderow = DumpModeDecode; tif->tif_decoderow = DumpModeDecode;
tif->tif_decodestrip = DumpModeDecode; tif->tif_decodestrip = DumpModeDecode;
tif->tif_decodetile = DumpModeDecode; tif->tif_decodetile = DumpModeDecode;
tif->tif_encoderow = DumpModeEncode; tif->tif_encoderow = DumpModeEncode;
tif->tif_encodestrip = DumpModeEncode; tif->tif_encodestrip = DumpModeEncode;
tif->tif_encodetile = DumpModeEncode; tif->tif_encodetile = DumpModeEncode;
tif->tif_seek = DumpModeSeek; tif->tif_seek = DumpModeSeek;
return (1); return (1);
} }
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

148
libs/tiff/libtiff/tif_error.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -29,58 +29,104 @@
TIFFErrorHandlerExt _TIFFerrorHandlerExt = NULL; TIFFErrorHandlerExt _TIFFerrorHandlerExt = NULL;
TIFFErrorHandler TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler handler)
TIFFSetErrorHandler(TIFFErrorHandler handler)
{ {
TIFFErrorHandler prev = _TIFFerrorHandler; TIFFErrorHandler prev = _TIFFerrorHandler;
_TIFFerrorHandler = handler; _TIFFerrorHandler = handler;
return (prev); return (prev);
} }
TIFFErrorHandlerExt TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt handler)
TIFFSetErrorHandlerExt(TIFFErrorHandlerExt handler)
{ {
TIFFErrorHandlerExt prev = _TIFFerrorHandlerExt; TIFFErrorHandlerExt prev = _TIFFerrorHandlerExt;
_TIFFerrorHandlerExt = handler; _TIFFerrorHandlerExt = handler;
return (prev); return (prev);
} }
void void TIFFError(const char *module, const char *fmt, ...)
TIFFError(const char* module, const char* fmt, ...)
{ {
va_list ap; va_list ap;
if (_TIFFerrorHandler) { if (_TIFFerrorHandler)
va_start(ap, fmt); {
(*_TIFFerrorHandler)(module, fmt, ap); va_start(ap, fmt);
va_end(ap); (*_TIFFerrorHandler)(module, fmt, ap);
} va_end(ap);
if (_TIFFerrorHandlerExt) { }
va_start(ap, fmt); if (_TIFFerrorHandlerExt)
(*_TIFFerrorHandlerExt)(0, module, fmt, ap); {
va_end(ap); va_start(ap, fmt);
} (*_TIFFerrorHandlerExt)(0, module, fmt, ap);
va_end(ap);
}
} }
void void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt, ...)
TIFFErrorExt(thandle_t fd, const char* module, const char* fmt, ...)
{ {
va_list ap; va_list ap;
if (_TIFFerrorHandler) { if (_TIFFerrorHandler)
va_start(ap, fmt); {
(*_TIFFerrorHandler)(module, fmt, ap); va_start(ap, fmt);
va_end(ap); (*_TIFFerrorHandler)(module, fmt, ap);
} va_end(ap);
if (_TIFFerrorHandlerExt) { }
va_start(ap, fmt); if (_TIFFerrorHandlerExt)
(*_TIFFerrorHandlerExt)(fd, module, fmt, ap); {
va_end(ap); va_start(ap, fmt);
} (*_TIFFerrorHandlerExt)(fd, module, fmt, ap);
va_end(ap);
}
} }
/* void _TIFFErrorEarly(TIFFOpenOptions *opts, thandle_t clientdata,
* Local Variables: const char *module, const char *fmt, ...)
* mode: c {
* c-basic-offset: 8 va_list ap;
* fill-column: 78 if (opts && opts->errorhandler)
* End: {
*/ va_start(ap, fmt);
int stop = opts->errorhandler(NULL, opts->errorhandler_user_data,
module, fmt, ap);
va_end(ap);
if (stop)
return;
}
if (_TIFFerrorHandler)
{
va_start(ap, fmt);
(*_TIFFerrorHandler)(module, fmt, ap);
va_end(ap);
}
if (_TIFFerrorHandlerExt)
{
va_start(ap, fmt);
(*_TIFFerrorHandlerExt)(clientdata, module, fmt, ap);
va_end(ap);
}
}
void TIFFErrorExtR(TIFF *tif, const char *module, const char *fmt, ...)
{
va_list ap;
if (tif && tif->tif_errorhandler)
{
va_start(ap, fmt);
int stop = (*tif->tif_errorhandler)(
tif, tif->tif_errorhandler_user_data, module, fmt, ap);
va_end(ap);
if (stop)
return;
}
if (_TIFFerrorHandler)
{
va_start(ap, fmt);
(*_TIFFerrorHandler)(module, fmt, ap);
va_end(ap);
}
if (_TIFFerrorHandlerExt)
{
va_start(ap, fmt);
(*_TIFFerrorHandlerExt)(tif ? tif->tif_clientdata : NULL, module, fmt,
ap);
va_end(ap);
}
}

2671
libs/tiff/libtiff/tif_fax3.c
View file

File diff suppressed because it is too large Load diff

899
libs/tiff/libtiff/tif_fax3.h
View file

@ -2,28 +2,28 @@
* Copyright (c) 1990-1997 Sam Leffler * Copyright (c) 1990-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
#ifndef _FAX3_ #ifndef _FAX3_
#define _FAX3_ #define _FAX3_
/* /*
* TIFF Library. * TIFF Library.
* *
@ -50,41 +50,47 @@
* data in the run array as needed (e.g. to append zero runs to bring * data in the run array as needed (e.g. to append zero runs to bring
* the count up to a nice multiple). * the count up to a nice multiple).
*/ */
typedef void (*TIFFFaxFillFunc)(unsigned char*, uint32_t*, uint32_t*, uint32_t); typedef void (*TIFFFaxFillFunc)(unsigned char *, uint32_t *, uint32_t *,
uint32_t);
/* /*
* The default run filler; made external for other decoders. * The default run filler; made external for other decoders.
*/ */
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C"
{
#endif #endif
extern void _TIFFFax3fillruns(unsigned char*, uint32_t*, uint32_t*, uint32_t); extern void _TIFFFax3fillruns(unsigned char *, uint32_t *, uint32_t *,
uint32_t);
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif #endif
/* finite state machine codes */ /* finite state machine codes */
#define S_Null 0 #define S_Null 0
#define S_Pass 1 #define S_Pass 1
#define S_Horiz 2 #define S_Horiz 2
#define S_V0 3 #define S_V0 3
#define S_VR 4 #define S_VR 4
#define S_VL 5 #define S_VL 5
#define S_Ext 6 #define S_Ext 6
#define S_TermW 7 #define S_TermW 7
#define S_TermB 8 #define S_TermB 8
#define S_MakeUpW 9 #define S_MakeUpW 9
#define S_MakeUpB 10 #define S_MakeUpB 10
#define S_MakeUp 11 #define S_MakeUp 11
#define S_EOL 12 #define S_EOL 12
/* WARNING: do not change the layout of this structure as the HylaFAX software */ /* WARNING: do not change the layout of this structure as the HylaFAX software
/* really depends on it. See http://bugzilla.maptools.org/show_bug.cgi?id=2636 */ */
typedef struct { /* state table entry */ /* really depends on it. See http://bugzilla.maptools.org/show_bug.cgi?id=2636
unsigned char State; /* see above */ */
unsigned char Width; /* width of code in bits */ typedef struct
uint32_t Param; /* unsigned 32-bit run length in bits (holds on 16 bit actually, but cannot be changed. See above warning) */ { /* state table entry */
unsigned char State; /* see above */
unsigned char Width; /* width of code in bits */
uint32_t Param; /* unsigned 32-bit run length in bits (holds on 16 bit
actually, but cannot be changed. See above warning) */
} TIFFFaxTabEnt; } TIFFFaxTabEnt;
extern const TIFFFaxTabEnt TIFFFaxMainTable[]; extern const TIFFFaxTabEnt TIFFFaxMainTable[];
@ -108,7 +114,7 @@ extern const TIFFFaxTabEnt TIFFFaxBlackTable[];
*/ */
#ifndef EndOfData #ifndef EndOfData
#define EndOfData() (cp >= ep) #define EndOfData() (cp >= ep)
#endif #endif
/* /*
* Need <=8 or <=16 bits of input data. Unlike viewfax we * Need <=8 or <=16 bits of input data. Unlike viewfax we
@ -134,121 +140,143 @@ extern const TIFFFaxTabEnt TIFFFaxBlackTable[];
* otherwise we should get the right answer. * otherwise we should get the right answer.
*/ */
#ifndef NeedBits8 #ifndef NeedBits8
#define NeedBits8(n,eoflab) do { \ #define NeedBits8(n, eoflab) \
if (BitsAvail < (n)) { \ do \
if (EndOfData()) { \ { \
if (BitsAvail == 0) /* no valid bits */ \ if (BitsAvail < (n)) \
goto eoflab; \ { \
BitsAvail = (n); /* pad with zeros */ \ if (EndOfData()) \
} else { \ { \
BitAcc |= ((uint32_t) bitmap[*cp++])<<BitsAvail; \ if (BitsAvail == 0) /* no valid bits */ \
BitsAvail += 8; \ goto eoflab; \
} \ BitsAvail = (n); /* pad with zeros */ \
} \ } \
} while (0) else \
{ \
BitAcc |= ((uint32_t)bitmap[*cp++]) << BitsAvail; \
BitsAvail += 8; \
} \
} \
} while (0)
#endif #endif
#ifndef NeedBits16 #ifndef NeedBits16
#define NeedBits16(n,eoflab) do { \ #define NeedBits16(n, eoflab) \
if (BitsAvail < (n)) { \ do \
if (EndOfData()) { \ { \
if (BitsAvail == 0) /* no valid bits */ \ if (BitsAvail < (n)) \
goto eoflab; \ { \
BitsAvail = (n); /* pad with zeros */ \ if (EndOfData()) \
} else { \ { \
BitAcc |= ((uint32_t) bitmap[*cp++])<<BitsAvail; \ if (BitsAvail == 0) /* no valid bits */ \
if ((BitsAvail += 8) < (n)) { \ goto eoflab; \
if (EndOfData()) { \ BitsAvail = (n); /* pad with zeros */ \
/* NB: we know BitsAvail is non-zero here */ \ } \
BitsAvail = (n); /* pad with zeros */ \ else \
} else { \ { \
BitAcc |= ((uint32_t) bitmap[*cp++])<<BitsAvail; \ BitAcc |= ((uint32_t)bitmap[*cp++]) << BitsAvail; \
BitsAvail += 8; \ if ((BitsAvail += 8) < (n)) \
} \ { \
} \ if (EndOfData()) \
} \ { \
} \ /* NB: we know BitsAvail is non-zero here */ \
} while (0) BitsAvail = (n); /* pad with zeros */ \
} \
else \
{ \
BitAcc |= ((uint32_t)bitmap[*cp++]) << BitsAvail; \
BitsAvail += 8; \
} \
} \
} \
} \
} while (0)
#endif #endif
#define GetBits(n) (BitAcc & ((1<<(n))-1)) #define GetBits(n) (BitAcc & ((1 << (n)) - 1))
#define ClrBits(n) do { \ #define ClrBits(n) \
BitsAvail -= (n); \ do \
BitAcc >>= (n); \ { \
} while (0) BitsAvail -= (n); \
BitAcc >>= (n); \
} while (0)
#ifdef FAX3_DEBUG #ifdef FAX3_DEBUG
static const char* StateNames[] = { static const char *StateNames[] = {
"Null ", "Null ", "Pass ", "Horiz ", "V0 ", "VR ", "VL ", "Ext ",
"Pass ", "TermW ", "TermB ", "MakeUpW", "MakeUpB", "MakeUp ", "EOL ",
"Horiz ",
"V0 ",
"VR ",
"VL ",
"Ext ",
"TermW ",
"TermB ",
"MakeUpW",
"MakeUpB",
"MakeUp ",
"EOL ",
}; };
#define DEBUG_SHOW putchar(BitAcc & (1 << t) ? '1' : '0') #define DEBUG_SHOW putchar(BitAcc & (1 << t) ? '1' : '0')
#define LOOKUP8(wid,tab,eoflab) do { \ #define LOOKUP8(wid, tab, eoflab) \
int t; \ do \
NeedBits8(wid,eoflab); \ { \
TabEnt = tab + GetBits(wid); \ int t; \
printf("%08lX/%d: %s%5d\t", (long) BitAcc, BitsAvail, \ NeedBits8(wid, eoflab); \
StateNames[TabEnt->State], TabEnt->Param); \ TabEnt = tab + GetBits(wid); \
for (t = 0; t < TabEnt->Width; t++) \ printf("%08lX/%d: %s%5d\t", (long)BitAcc, BitsAvail, \
DEBUG_SHOW; \ StateNames[TabEnt->State], TabEnt->Param); \
putchar('\n'); \ for (t = 0; t < TabEnt->Width; t++) \
fflush(stdout); \ DEBUG_SHOW; \
ClrBits(TabEnt->Width); \ putchar('\n'); \
} while (0) fflush(stdout); \
#define LOOKUP16(wid,tab,eoflab) do { \ ClrBits(TabEnt->Width); \
int t; \ } while (0)
NeedBits16(wid,eoflab); \ #define LOOKUP16(wid, tab, eoflab) \
TabEnt = tab + GetBits(wid); \ do \
printf("%08lX/%d: %s%5d\t", (long) BitAcc, BitsAvail, \ { \
StateNames[TabEnt->State], TabEnt->Param); \ int t; \
for (t = 0; t < TabEnt->Width; t++) \ NeedBits16(wid, eoflab); \
DEBUG_SHOW; \ TabEnt = tab + GetBits(wid); \
putchar('\n'); \ printf("%08lX/%d: %s%5d\t", (long)BitAcc, BitsAvail, \
fflush(stdout); \ StateNames[TabEnt->State], TabEnt->Param); \
ClrBits(TabEnt->Width); \ for (t = 0; t < TabEnt->Width; t++) \
} while (0) DEBUG_SHOW; \
putchar('\n'); \
fflush(stdout); \
ClrBits(TabEnt->Width); \
} while (0)
#define SETVALUE(x) do { \ #define SETVALUE(x) \
*pa++ = RunLength + (x); \ do \
printf("SETVALUE: %d\t%d\n", RunLength + (x), a0); \ { \
a0 += x; \ *pa++ = RunLength + (x); \
RunLength = 0; \ printf("SETVALUE: %d\t%d\n", RunLength + (x), a0); \
} while (0) a0 += x; \
RunLength = 0; \
} while (0)
#else #else
#define LOOKUP8(wid,tab,eoflab) do { \ #define LOOKUP8(wid, tab, eoflab) \
NeedBits8(wid,eoflab); \ do \
TabEnt = tab + GetBits(wid); \ { \
ClrBits(TabEnt->Width); \ NeedBits8(wid, eoflab); \
} while (0) TabEnt = tab + GetBits(wid); \
#define LOOKUP16(wid,tab,eoflab) do { \ ClrBits(TabEnt->Width); \
NeedBits16(wid,eoflab); \ } while (0)
TabEnt = tab + GetBits(wid); \ #define LOOKUP16(wid, tab, eoflab) \
ClrBits(TabEnt->Width); \ do \
} while (0) { \
NeedBits16(wid, eoflab); \
TabEnt = tab + GetBits(wid); \
ClrBits(TabEnt->Width); \
} while (0)
/* /*
* Append a run to the run length array for the * Append a run to the run length array for the
* current row and reset decoding state. * current row and reset decoding state.
*/ */
#define SETVALUE(x) do { \ #define SETVALUE(x) \
if (pa >= thisrun + sp->nruns) { \ do \
TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u", \ { \
sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \ if (pa >= thisrun + sp->nruns) \
return (-1); \ { \
} \ TIFFErrorExtR(tif, module, "Buffer overflow at line %u of %s %u", \
*pa++ = RunLength + (x); \ sp->line, isTiled(tif) ? "tile" : "strip", \
a0 += (x); \ isTiled(tif) ? tif->tif_curtile \
RunLength = 0; \ : tif->tif_curstrip); \
} while (0) return (-1); \
} \
*pa++ = RunLength + (x); \
a0 += (x); \
RunLength = 0; \
} while (0)
#endif #endif
/* /*
@ -261,51 +289,62 @@ static const char* StateNames[] = {
* is non-zero then we still need to scan for the final flag * is non-zero then we still need to scan for the final flag
* bit that is part of the EOL code. * bit that is part of the EOL code.
*/ */
#define SYNC_EOL(eoflab) do { \ #define SYNC_EOL(eoflab) \
if (EOLcnt == 0) { \ do \
for (;;) { \ { \
NeedBits16(11,eoflab); \ if (EOLcnt == 0) \
if (GetBits(11) == 0) \ { \
break; \ for (;;) \
ClrBits(1); \ { \
} \ NeedBits16(11, eoflab); \
} \ if (GetBits(11) == 0) \
for (;;) { \ break; \
NeedBits8(8,eoflab); \ ClrBits(1); \
if (GetBits(8)) \ } \
break; \ } \
ClrBits(8); \ for (;;) \
} \ { \
while (GetBits(1) == 0) \ NeedBits8(8, eoflab); \
ClrBits(1); \ if (GetBits(8)) \
ClrBits(1); /* EOL bit */ \ break; \
EOLcnt = 0; /* reset EOL counter/flag */ \ ClrBits(8); \
} while (0) } \
while (GetBits(1) == 0) \
ClrBits(1); \
ClrBits(1); /* EOL bit */ \
EOLcnt = 0; /* reset EOL counter/flag */ \
} while (0)
/* /*
* Cleanup the array of runs after decoding a row. * Cleanup the array of runs after decoding a row.
* We adjust final runs to insure the user buffer is not * We adjust final runs to insure the user buffer is not
* overwritten and/or undecoded area is white filled. * overwritten and/or undecoded area is white filled.
*/ */
#define CLEANUP_RUNS() do { \ #define CLEANUP_RUNS() \
if (RunLength) \ do \
SETVALUE(0); \ { \
if (a0 != lastx) { \ if (RunLength) \
badlength(a0, lastx); \ SETVALUE(0); \
while (a0 > lastx && pa > thisrun) \ if (a0 != lastx) \
a0 -= *--pa; \ { \
if (a0 < lastx) { \ badlength(a0, lastx); \
if (a0 < 0) \ while (a0 > lastx && pa > thisrun) \
a0 = 0; \ a0 -= *--pa; \
if ((pa-thisrun)&1) \ if (a0 < lastx) \
SETVALUE(0); \ { \
SETVALUE(lastx - a0); \ if (a0 < 0) \
} else if (a0 > lastx) { \ a0 = 0; \
SETVALUE(lastx); \ if ((pa - thisrun) & 1) \
SETVALUE(0); \ SETVALUE(0); \
} \ SETVALUE(lastx - a0); \
} \ } \
} while (0) else if (a0 > lastx) \
{ \
SETVALUE(lastx); \
SETVALUE(0); \
} \
} \
} while (0)
/* /*
* Decode a line of 1D-encoded data. * Decode a line of 1D-encoded data.
@ -319,249 +358,291 @@ static const char* StateNames[] = {
* the original code depended on the input data being zero-padded to * the original code depended on the input data being zero-padded to
* insure the decoder recognized an EOL before running out of data. * insure the decoder recognized an EOL before running out of data.
*/ */
#define EXPAND1D(eoflab) do { \ #define EXPAND1D(eoflab) \
for (;;) { \ do \
for (;;) { \ { \
LOOKUP16(12, TIFFFaxWhiteTable, eof1d); \ for (;;) \
switch (TabEnt->State) { \ { \
case S_EOL: \ for (;;) \
EOLcnt = 1; \ { \
goto done1d; \ LOOKUP16(12, TIFFFaxWhiteTable, eof1d); \
case S_TermW: \ switch (TabEnt->State) \
SETVALUE(TabEnt->Param); \ { \
goto doneWhite1d; \ case S_EOL: \
case S_MakeUpW: \ EOLcnt = 1; \
case S_MakeUp: \ goto done1d; \
a0 += TabEnt->Param; \ case S_TermW: \
RunLength += TabEnt->Param; \ SETVALUE(TabEnt->Param); \
break; \ goto doneWhite1d; \
default: \ case S_MakeUpW: \
unexpected("WhiteTable", a0); \ case S_MakeUp: \
goto done1d; \ a0 += TabEnt->Param; \
} \ RunLength += TabEnt->Param; \
} \ break; \
doneWhite1d: \ default: \
if (a0 >= lastx) \ unexpected("WhiteTable", a0); \
goto done1d; \ goto done1d; \
for (;;) { \ } \
LOOKUP16(13, TIFFFaxBlackTable, eof1d); \ } \
switch (TabEnt->State) { \ doneWhite1d: \
case S_EOL: \ if (a0 >= lastx) \
EOLcnt = 1; \ goto done1d; \
goto done1d; \ for (;;) \
case S_TermB: \ { \
SETVALUE(TabEnt->Param); \ LOOKUP16(13, TIFFFaxBlackTable, eof1d); \
goto doneBlack1d; \ switch (TabEnt->State) \
case S_MakeUpB: \ { \
case S_MakeUp: \ case S_EOL: \
a0 += TabEnt->Param; \ EOLcnt = 1; \
RunLength += TabEnt->Param; \ goto done1d; \
break; \ case S_TermB: \
default: \ SETVALUE(TabEnt->Param); \
unexpected("BlackTable", a0); \ goto doneBlack1d; \
goto done1d; \ case S_MakeUpB: \
} \ case S_MakeUp: \
} \ a0 += TabEnt->Param; \
doneBlack1d: \ RunLength += TabEnt->Param; \
if (a0 >= lastx) \ break; \
goto done1d; \ default: \
if( *(pa-1) == 0 && *(pa-2) == 0 ) \ unexpected("BlackTable", a0); \
pa -= 2; \ goto done1d; \
} \ } \
eof1d: \ } \
prematureEOF(a0); \ doneBlack1d: \
CLEANUP_RUNS(); \ if (a0 >= lastx) \
goto eoflab; \ goto done1d; \
done1d: \ if (*(pa - 1) == 0 && *(pa - 2) == 0) \
CLEANUP_RUNS(); \ pa -= 2; \
} while (0) } \
eof1d: \
prematureEOF(a0); \
CLEANUP_RUNS(); \
goto eoflab; \
done1d: \
CLEANUP_RUNS(); \
} while (0)
/* /*
* Update the value of b1 using the array * Update the value of b1 using the array
* of runs for the reference line. * of runs for the reference line.
*/ */
#define CHECK_b1 do { \ #define CHECK_b1 \
if (pa != thisrun) while (b1 <= a0 && b1 < lastx) { \ do \
if( pb + 1 >= sp->refruns + sp->nruns) { \ { \
TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u", \ if (pa != thisrun) \
sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \ while (b1 <= a0 && b1 < lastx) \
return (-1); \ { \
} \ if (pb + 1 >= sp->refruns + sp->nruns) \
b1 += pb[0] + pb[1]; \ { \
pb += 2; \ TIFFErrorExtR( \
} \ tif, module, "Buffer overflow at line %u of %s %u", \
} while (0) sp->line, isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \
return (-1); \
} \
b1 += pb[0] + pb[1]; \
pb += 2; \
} \
} while (0)
/* /*
* Expand a row of 2D-encoded data. * Expand a row of 2D-encoded data.
*/ */
#define EXPAND2D(eoflab) do { \ #define EXPAND2D(eoflab) \
while (a0 < lastx) { \ do \
if (pa >= thisrun + sp->nruns) { \ { \
TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u", \ while (a0 < lastx) \
sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \ { \
return (-1); \ if (pa >= thisrun + sp->nruns) \
} \ { \
LOOKUP8(7, TIFFFaxMainTable, eof2d); \ TIFFErrorExtR( \
switch (TabEnt->State) { \ tif, module, "Buffer overflow at line %u of %s %u", \
case S_Pass: \ sp->line, isTiled(tif) ? "tile" : "strip", \
CHECK_b1; \ isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \
if( pb + 1 >= sp->refruns + sp->nruns) { \ return (-1); \
TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u", \ } \
sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \ LOOKUP8(7, TIFFFaxMainTable, eof2d); \
return (-1); \ switch (TabEnt->State) \
} \ { \
b1 += *pb++; \ case S_Pass: \
RunLength += b1 - a0; \ CHECK_b1; \
a0 = b1; \ if (pb + 1 >= sp->refruns + sp->nruns) \
b1 += *pb++; \ { \
break; \ TIFFErrorExtR(tif, module, \
case S_Horiz: \ "Buffer overflow at line %u of %s %u", \
if ((pa-thisrun)&1) { \ sp->line, \
for (;;) { /* black first */ \ isTiled(tif) ? "tile" : "strip", \
LOOKUP16(13, TIFFFaxBlackTable, eof2d); \ isTiled(tif) ? tif->tif_curtile \
switch (TabEnt->State) { \ : tif->tif_curstrip); \
case S_TermB: \ return (-1); \
SETVALUE(TabEnt->Param); \ } \
goto doneWhite2da; \ b1 += *pb++; \
case S_MakeUpB: \ RunLength += b1 - a0; \
case S_MakeUp: \ a0 = b1; \
a0 += TabEnt->Param; \ b1 += *pb++; \
RunLength += TabEnt->Param; \ break; \
break; \ case S_Horiz: \
default: \ if ((pa - thisrun) & 1) \
goto badBlack2d; \ { \
} \ for (;;) \
} \ { /* black first */ \
doneWhite2da:; \ LOOKUP16(13, TIFFFaxBlackTable, eof2d); \
for (;;) { /* then white */ \ switch (TabEnt->State) \
LOOKUP16(12, TIFFFaxWhiteTable, eof2d); \ { \
switch (TabEnt->State) { \ case S_TermB: \
case S_TermW: \ SETVALUE(TabEnt->Param); \
SETVALUE(TabEnt->Param); \ goto doneWhite2da; \
goto doneBlack2da; \ case S_MakeUpB: \
case S_MakeUpW: \ case S_MakeUp: \
case S_MakeUp: \ a0 += TabEnt->Param; \
a0 += TabEnt->Param; \ RunLength += TabEnt->Param; \
RunLength += TabEnt->Param; \ break; \
break; \ default: \
default: \ goto badBlack2d; \
goto badWhite2d; \ } \
} \ } \
} \ doneWhite2da:; \
doneBlack2da:; \ for (;;) \
} else { \ { /* then white */ \
for (;;) { /* white first */ \ LOOKUP16(12, TIFFFaxWhiteTable, eof2d); \
LOOKUP16(12, TIFFFaxWhiteTable, eof2d); \ switch (TabEnt->State) \
switch (TabEnt->State) { \ { \
case S_TermW: \ case S_TermW: \
SETVALUE(TabEnt->Param); \ SETVALUE(TabEnt->Param); \
goto doneWhite2db; \ goto doneBlack2da; \
case S_MakeUpW: \ case S_MakeUpW: \
case S_MakeUp: \ case S_MakeUp: \
a0 += TabEnt->Param; \ a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \ RunLength += TabEnt->Param; \
break; \ break; \
default: \ default: \
goto badWhite2d; \ goto badWhite2d; \
} \ } \
} \ } \
doneWhite2db:; \ doneBlack2da:; \
for (;;) { /* then black */ \ } \
LOOKUP16(13, TIFFFaxBlackTable, eof2d); \ else \
switch (TabEnt->State) { \ { \
case S_TermB: \ for (;;) \
SETVALUE(TabEnt->Param); \ { /* white first */ \
goto doneBlack2db; \ LOOKUP16(12, TIFFFaxWhiteTable, eof2d); \
case S_MakeUpB: \ switch (TabEnt->State) \
case S_MakeUp: \ { \
a0 += TabEnt->Param; \ case S_TermW: \
RunLength += TabEnt->Param; \ SETVALUE(TabEnt->Param); \
break; \ goto doneWhite2db; \
default: \ case S_MakeUpW: \
goto badBlack2d; \ case S_MakeUp: \
} \ a0 += TabEnt->Param; \
} \ RunLength += TabEnt->Param; \
doneBlack2db:; \ break; \
} \ default: \
CHECK_b1; \ goto badWhite2d; \
break; \ } \
case S_V0: \ } \
CHECK_b1; \ doneWhite2db:; \
SETVALUE(b1 - a0); \ for (;;) \
if( pb >= sp->refruns + sp->nruns) { \ { /* then black */ \
TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u", \ LOOKUP16(13, TIFFFaxBlackTable, eof2d); \
sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \ switch (TabEnt->State) \
return (-1); \ { \
} \ case S_TermB: \
b1 += *pb++; \ SETVALUE(TabEnt->Param); \
break; \ goto doneBlack2db; \
case S_VR: \ case S_MakeUpB: \
CHECK_b1; \ case S_MakeUp: \
SETVALUE(b1 - a0 + TabEnt->Param); \ a0 += TabEnt->Param; \
if( pb >= sp->refruns + sp->nruns) { \ RunLength += TabEnt->Param; \
TIFFErrorExt(tif->tif_clientdata, module, "Buffer overflow at line %u of %s %u", \ break; \
sp->line, isTiled(tif) ? "tile" : "strip", isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \ default: \
return (-1); \ goto badBlack2d; \
} \ } \
b1 += *pb++; \ } \
break; \ doneBlack2db:; \
case S_VL: \ } \
CHECK_b1; \ CHECK_b1; \
if (b1 < (int) (a0 + TabEnt->Param)) { \ break; \
unexpected("VL", a0); \ case S_V0: \
goto eol2d; \ CHECK_b1; \
} \ SETVALUE(b1 - a0); \
SETVALUE(b1 - a0 - TabEnt->Param); \ if (pb >= sp->refruns + sp->nruns) \
b1 -= *--pb; \ { \
break; \ TIFFErrorExtR(tif, module, \
case S_Ext: \ "Buffer overflow at line %u of %s %u", \
*pa++ = lastx - a0; \ sp->line, \
extension(a0); \ isTiled(tif) ? "tile" : "strip", \
goto eol2d; \ isTiled(tif) ? tif->tif_curtile \
case S_EOL: \ : tif->tif_curstrip); \
*pa++ = lastx - a0; \ return (-1); \
NeedBits8(4,eof2d); \ } \
if (GetBits(4)) \ b1 += *pb++; \
unexpected("EOL", a0); \ break; \
ClrBits(4); \ case S_VR: \
EOLcnt = 1; \ CHECK_b1; \
goto eol2d; \ SETVALUE(b1 - a0 + TabEnt->Param); \
default: \ if (pb >= sp->refruns + sp->nruns) \
badMain2d: \ { \
unexpected("MainTable", a0); \ TIFFErrorExtR(tif, module, \
goto eol2d; \ "Buffer overflow at line %u of %s %u", \
badBlack2d: \ sp->line, \
unexpected("BlackTable", a0); \ isTiled(tif) ? "tile" : "strip", \
goto eol2d; \ isTiled(tif) ? tif->tif_curtile \
badWhite2d: \ : tif->tif_curstrip); \
unexpected("WhiteTable", a0); \ return (-1); \
goto eol2d; \ } \
eof2d: \ b1 += *pb++; \
prematureEOF(a0); \ break; \
CLEANUP_RUNS(); \ case S_VL: \
goto eoflab; \ CHECK_b1; \
} \ if (b1 < (int)(a0 + TabEnt->Param)) \
} \ { \
if (RunLength) { \ unexpected("VL", a0); \
if (RunLength + a0 < lastx) { \ goto eol2d; \
/* expect a final V0 */ \ } \
NeedBits8(1,eof2d); \ SETVALUE(b1 - a0 - TabEnt->Param); \
if (!GetBits(1)) \ b1 -= *--pb; \
goto badMain2d; \ break; \
ClrBits(1); \ case S_Ext: \
} \ *pa++ = lastx - a0; \
SETVALUE(0); \ extension(a0); \
} \ goto eol2d; \
eol2d: \ case S_EOL: \
CLEANUP_RUNS(); \ *pa++ = lastx - a0; \
} while (0) NeedBits8(4, eof2d); \
if (GetBits(4)) \
unexpected("EOL", a0); \
ClrBits(4); \
EOLcnt = 1; \
goto eol2d; \
default: \
badMain2d: \
unexpected("MainTable", a0); \
goto eol2d; \
badBlack2d: \
unexpected("BlackTable", a0); \
goto eol2d; \
badWhite2d: \
unexpected("WhiteTable", a0); \
goto eol2d; \
eof2d: \
prematureEOF(a0); \
CLEANUP_RUNS(); \
goto eoflab; \
} \
} \
if (RunLength) \
{ \
if (RunLength + a0 < lastx) \
{ \
/* expect a final V0 */ \
NeedBits8(1, eof2d); \
if (!GetBits(1)) \
goto badMain2d; \
ClrBits(1); \
} \
SETVALUE(0); \
} \
eol2d: \
CLEANUP_RUNS(); \
} while (0)
#endif /* _FAX3_ */ #endif /* _FAX3_ */
/* vim: set ts=8 sts=4 sw=4 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

135
libs/tiff/libtiff/tif_flush.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -27,30 +27,28 @@
*/ */
#include "tiffiop.h" #include "tiffiop.h"
int int TIFFFlush(TIFF *tif)
TIFFFlush(TIFF* tif)
{ {
if( tif->tif_mode == O_RDONLY ) if (tif->tif_mode == O_RDONLY)
return 1; return 1;
if (!TIFFFlushData(tif)) if (!TIFFFlushData(tif))
return (0); return (0);
/* In update (r+) mode we try to detect the case where /* In update (r+) mode we try to detect the case where
only the strip/tile map has been altered, and we try to only the strip/tile map has been altered, and we try to
rewrite only that portion of the directory without rewrite only that portion of the directory without
making any other changes */ making any other changes */
if( (tif->tif_flags & TIFF_DIRTYSTRIP) if ((tif->tif_flags & TIFF_DIRTYSTRIP) &&
&& !(tif->tif_flags & TIFF_DIRTYDIRECT) !(tif->tif_flags & TIFF_DIRTYDIRECT) && tif->tif_mode == O_RDWR)
&& tif->tif_mode == O_RDWR )
{ {
if( TIFFForceStrileArrayWriting(tif) ) if (TIFFForceStrileArrayWriting(tif))
return 1; return 1;
} }
if ((tif->tif_flags & (TIFF_DIRTYDIRECT|TIFF_DIRTYSTRIP)) if ((tif->tif_flags & (TIFF_DIRTYDIRECT | TIFF_DIRTYSTRIP)) &&
&& !TIFFRewriteDirectory(tif)) !TIFFRewriteDirectory(tif))
return (0); return (0);
return (1); return (1);
@ -75,45 +73,43 @@ TIFFFlush(TIFF* tif)
* *
* Returns 1 in case of success, 0 otherwise. * Returns 1 in case of success, 0 otherwise.
*/ */
int TIFFForceStrileArrayWriting(TIFF* tif) int TIFFForceStrileArrayWriting(TIFF *tif)
{ {
static const char module[] = "TIFFForceStrileArrayWriting"; static const char module[] = "TIFFForceStrileArrayWriting";
const int isTiled = TIFFIsTiled(tif); const int isTiled = TIFFIsTiled(tif);
if (tif->tif_mode == O_RDONLY) if (tif->tif_mode == O_RDONLY)
{ {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, TIFFErrorExtR(tif, tif->tif_name, "File opened in read-only mode");
"File opened in read-only mode");
return 0; return 0;
} }
if( tif->tif_diroff == 0 ) if (tif->tif_diroff == 0)
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "Directory has not yet been written");
"Directory has not yet been written");
return 0; return 0;
} }
if( (tif->tif_flags & TIFF_DIRTYDIRECT) != 0 ) if ((tif->tif_flags & TIFF_DIRTYDIRECT) != 0)
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module,
"Directory has changes other than the strile arrays. " "Directory has changes other than the strile arrays. "
"TIFFRewriteDirectory() should be called instead"); "TIFFRewriteDirectory() should be called instead");
return 0; return 0;
} }
if( !(tif->tif_flags & TIFF_DIRTYSTRIP) ) if (!(tif->tif_flags & TIFF_DIRTYSTRIP))
{ {
if( !(tif->tif_dir.td_stripoffset_entry.tdir_tag != 0 && if (!(tif->tif_dir.td_stripoffset_entry.tdir_tag != 0 &&
tif->tif_dir.td_stripoffset_entry.tdir_count == 0 && tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
tif->tif_dir.td_stripoffset_entry.tdir_type == 0 && tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 && tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 &&
tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0 && tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0 &&
tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 && tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 && tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0) ) tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0))
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module,
"Function not called together with " "Function not called together with "
"TIFFDeferStrileArrayWriting()"); "TIFFDeferStrileArrayWriting()");
return 0; return 0;
} }
@ -121,18 +117,14 @@ int TIFFForceStrileArrayWriting(TIFF* tif)
return 0; return 0;
} }
if( _TIFFRewriteField( tif, if (_TIFFRewriteField(tif,
isTiled ? TIFFTAG_TILEOFFSETS : isTiled ? TIFFTAG_TILEOFFSETS : TIFFTAG_STRIPOFFSETS,
TIFFTAG_STRIPOFFSETS, TIFF_LONG8, tif->tif_dir.td_nstrips,
TIFF_LONG8, tif->tif_dir.td_stripoffset_p) &&
tif->tif_dir.td_nstrips, _TIFFRewriteField(
tif->tif_dir.td_stripoffset_p ) tif, isTiled ? TIFFTAG_TILEBYTECOUNTS : TIFFTAG_STRIPBYTECOUNTS,
&& _TIFFRewriteField( tif, TIFF_LONG8, tif->tif_dir.td_nstrips,
isTiled ? TIFFTAG_TILEBYTECOUNTS : tif->tif_dir.td_stripbytecount_p))
TIFFTAG_STRIPBYTECOUNTS,
TIFF_LONG8,
tif->tif_dir.td_nstrips,
tif->tif_dir.td_stripbytecount_p ) )
{ {
tif->tif_flags &= ~TIFF_DIRTYSTRIP; tif->tif_flags &= ~TIFF_DIRTYSTRIP;
tif->tif_flags &= ~TIFF_BEENWRITING; tif->tif_flags &= ~TIFF_BEENWRITING;
@ -149,26 +141,17 @@ int TIFFForceStrileArrayWriting(TIFF* tif)
* is not set, so that TIFFFlush() will proceed to write out the directory. * is not set, so that TIFFFlush() will proceed to write out the directory.
* The documentation says returning 1 is an error indicator, but not having * The documentation says returning 1 is an error indicator, but not having
* been writing isn't exactly a an error. Hopefully this doesn't cause * been writing isn't exactly a an error. Hopefully this doesn't cause
* problems for other people. * problems for other people.
*/ */
int int TIFFFlushData(TIFF *tif)
TIFFFlushData(TIFF* tif)
{ {
if ((tif->tif_flags & TIFF_BEENWRITING) == 0) if ((tif->tif_flags & TIFF_BEENWRITING) == 0)
return (1); return (1);
if (tif->tif_flags & TIFF_POSTENCODE) { if (tif->tif_flags & TIFF_POSTENCODE)
tif->tif_flags &= ~TIFF_POSTENCODE; {
if (!(*tif->tif_postencode)(tif)) tif->tif_flags &= ~TIFF_POSTENCODE;
return (0); if (!(*tif->tif_postencode)(tif))
} return (0);
return (TIFFFlushData1(tif)); }
return (TIFFFlushData1(tif));
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

603
libs/tiff/libtiff/tif_hash_set.c Normal file
View file

@ -0,0 +1,603 @@
/**********************************************************************
*
* Name: tif_hash_set.c
* Purpose: Hash set functions.
* Author: Even Rouault, <even dot rouault at spatialys.com>
*
**********************************************************************
* Copyright (c) 2008-2009, Even Rouault <even dot rouault at spatialys.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
****************************************************************************/
#include "tif_hash_set.h"
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
/** List element structure. */
typedef struct _TIFFList TIFFList;
/** List element structure. */
struct _TIFFList
{
/*! Pointer to the data object. Should be allocated and freed by the
* caller.
* */
void *pData;
/*! Pointer to the next element in list. NULL, if current element is the
* last one.
*/
struct _TIFFList *psNext;
};
struct _TIFFHashSet
{
TIFFHashSetHashFunc fnHashFunc;
TIFFHashSetEqualFunc fnEqualFunc;
TIFFHashSetFreeEltFunc fnFreeEltFunc;
TIFFList **tabList;
int nSize;
int nIndiceAllocatedSize;
int nAllocatedSize;
TIFFList *psRecyclingList;
int nRecyclingListSize;
bool bRehash;
#ifdef HASH_DEBUG
int nCollisions;
#endif
};
static const int anPrimes[] = {
53, 97, 193, 389, 769, 1543, 3079,
6151, 12289, 24593, 49157, 98317, 196613, 393241,
786433, 1572869, 3145739, 6291469, 12582917, 25165843, 50331653,
100663319, 201326611, 402653189, 805306457, 1610612741};
/************************************************************************/
/* TIFFHashSetHashPointer() */
/************************************************************************/
/**
* Hash function for an arbitrary pointer
*
* @param elt the arbitrary pointer to hash
*
* @return the hash value of the pointer
*/
static unsigned long TIFFHashSetHashPointer(const void *elt)
{
return (unsigned long)(uintptr_t)((void *)(elt));
}
/************************************************************************/
/* TIFFHashSetEqualPointer() */
/************************************************************************/
/**
* Equality function for arbitrary pointers
*
* @param elt1 the first arbitrary pointer to compare
* @param elt2 the second arbitrary pointer to compare
*
* @return true if the pointers are equal
*/
static bool TIFFHashSetEqualPointer(const void *elt1, const void *elt2)
{
return elt1 == elt2;
}
/************************************************************************/
/* TIFFHashSetNew() */
/************************************************************************/
/**
* Creates a new hash set
*
* The hash function must return a hash value for the elements to insert.
* If fnHashFunc is NULL, TIFFHashSetHashPointer will be used.
*
* The equal function must return if two elements are equal.
* If fnEqualFunc is NULL, TIFFHashSetEqualPointer will be used.
*
* The free function is used to free elements inserted in the hash set,
* when the hash set is destroyed, when elements are removed or replaced.
* If fnFreeEltFunc is NULL, elements inserted into the hash set will not be
* freed.
*
* @param fnHashFunc hash function. May be NULL.
* @param fnEqualFunc equal function. May be NULL.
* @param fnFreeEltFunc element free function. May be NULL.
*
* @return a new hash set
*/
TIFFHashSet *TIFFHashSetNew(TIFFHashSetHashFunc fnHashFunc,
TIFFHashSetEqualFunc fnEqualFunc,
TIFFHashSetFreeEltFunc fnFreeEltFunc)
{
TIFFHashSet *set = (TIFFHashSet *)malloc(sizeof(TIFFHashSet));
if (set == NULL)
return NULL;
set->fnHashFunc = fnHashFunc ? fnHashFunc : TIFFHashSetHashPointer;
set->fnEqualFunc = fnEqualFunc ? fnEqualFunc : TIFFHashSetEqualPointer;
set->fnFreeEltFunc = fnFreeEltFunc;
set->nSize = 0;
set->tabList = (TIFFList **)(calloc(sizeof(TIFFList *), 53));
if (set->tabList == NULL)
{
free(set);
return NULL;
}
set->nIndiceAllocatedSize = 0;
set->nAllocatedSize = 53;
set->psRecyclingList = NULL;
set->nRecyclingListSize = 0;
set->bRehash = false;
#ifdef HASH_DEBUG
set->nCollisions = 0;
#endif
return set;
}
#ifdef notdef
/************************************************************************/
/* TIFFHashSetSize() */
/************************************************************************/
/**
* Returns the number of elements inserted in the hash set
*
* Note: this is not the internal size of the hash set
*
* @param set the hash set
*
* @return the number of elements in the hash set
*/
int TIFFHashSetSize(const TIFFHashSet *set)
{
assert(set != NULL);
return set->nSize;
}
#endif
/************************************************************************/
/* TIFFHashSetGetNewListElt() */
/************************************************************************/
static TIFFList *TIFFHashSetGetNewListElt(TIFFHashSet *set)
{
if (set->psRecyclingList)
{
TIFFList *psRet = set->psRecyclingList;
psRet->pData = NULL;
set->nRecyclingListSize--;
set->psRecyclingList = psRet->psNext;
return psRet;
}
return (TIFFList *)malloc(sizeof(TIFFList));
}
/************************************************************************/
/* TIFFHashSetReturnListElt() */
/************************************************************************/
static void TIFFHashSetReturnListElt(TIFFHashSet *set, TIFFList *psList)
{
if (set->nRecyclingListSize < 128)
{
psList->psNext = set->psRecyclingList;
set->psRecyclingList = psList;
set->nRecyclingListSize++;
}
else
{
free(psList);
}
}
/************************************************************************/
/* TIFFHashSetClearInternal() */
/************************************************************************/
static void TIFFHashSetClearInternal(TIFFHashSet *set, bool bFinalize)
{
assert(set != NULL);
for (int i = 0; i < set->nAllocatedSize; i++)
{
TIFFList *cur = set->tabList[i];
while (cur)
{
if (set->fnFreeEltFunc)
set->fnFreeEltFunc(cur->pData);
TIFFList *psNext = cur->psNext;
if (bFinalize)
free(cur);
else
TIFFHashSetReturnListElt(set, cur);
cur = psNext;
}
set->tabList[i] = NULL;
}
set->bRehash = false;
}
/************************************************************************/
/* TIFFListDestroy() */
/************************************************************************/
/**
* Destroy a list. Caller responsible for freeing data objects contained in
* list elements.
*
* @param psList pointer to list head.
*
*/
static void TIFFListDestroy(TIFFList *psList)
{
TIFFList *psCurrent = psList;
while (psCurrent)
{
TIFFList *const psNext = psCurrent->psNext;
free(psCurrent);
psCurrent = psNext;
}
}
/************************************************************************/
/* TIFFHashSetDestroy() */
/************************************************************************/
/**
* Destroys an allocated hash set.
*
* This function also frees the elements if a free function was
* provided at the creation of the hash set.
*
* @param set the hash set
*/
void TIFFHashSetDestroy(TIFFHashSet *set)
{
if (set)
{
TIFFHashSetClearInternal(set, true);
free(set->tabList);
TIFFListDestroy(set->psRecyclingList);
free(set);
}
}
#ifdef notused
/************************************************************************/
/* TIFFHashSetClear() */
/************************************************************************/
/**
* Clear all elements from a hash set.
*
* This function also frees the elements if a free function was
* provided at the creation of the hash set.
*
* @param set the hash set
*/
void TIFFHashSetClear(TIFFHashSet *set)
{
TIFFHashSetClearInternal(set, false);
set->nIndiceAllocatedSize = 0;
set->nAllocatedSize = 53;
#ifdef HASH_DEBUG
set->nCollisions = 0;
#endif
set->nSize = 0;
}
/************************************************************************/
/* TIFFHashSetForeach() */
/************************************************************************/
/**
* Walk through the hash set and runs the provided function on all the
* elements
*
* This function is provided the user_data argument of TIFFHashSetForeach.
* It must return true to go on the walk through the hash set, or FALSE to
* make it stop.
*
* Note : the structure of the hash set must *NOT* be modified during the
* walk.
*
* @param set the hash set.
* @param fnIterFunc the function called on each element.
* @param user_data the user data provided to the function.
*/
void TIFFHashSetForeach(TIFFHashSet *set, TIFFHashSetIterEltFunc fnIterFunc,
void *user_data)
{
assert(set != NULL);
if (!fnIterFunc)
return;
for (int i = 0; i < set->nAllocatedSize; i++)
{
TIFFList *cur = set->tabList[i];
while (cur)
{
if (!fnIterFunc(cur->pData, user_data))
return;
cur = cur->psNext;
}
}
}
#endif
/************************************************************************/
/* TIFFHashSetRehash() */
/************************************************************************/
static bool TIFFHashSetRehash(TIFFHashSet *set)
{
int nNewAllocatedSize = anPrimes[set->nIndiceAllocatedSize];
TIFFList **newTabList =
(TIFFList **)(calloc(sizeof(TIFFList *), nNewAllocatedSize));
if (newTabList == NULL)
return false;
#ifdef HASH_DEBUG
TIFFDebug("TIFFHASH",
"hashSet=%p, nSize=%d, nCollisions=%d, "
"fCollisionRate=%.02f",
set, set->nSize, set->nCollisions,
set->nCollisions * 100.0 / set->nSize);
set->nCollisions = 0;
#endif
for (int i = 0; i < set->nAllocatedSize; i++)
{
TIFFList *cur = set->tabList[i];
while (cur)
{
const unsigned long nNewHashVal =
set->fnHashFunc(cur->pData) % nNewAllocatedSize;
#ifdef HASH_DEBUG
if (newTabList[nNewHashVal])
set->nCollisions++;
#endif
TIFFList *psNext = cur->psNext;
cur->psNext = newTabList[nNewHashVal];
newTabList[nNewHashVal] = cur;
cur = psNext;
}
}
free(set->tabList);
set->tabList = newTabList;
set->nAllocatedSize = nNewAllocatedSize;
set->bRehash = false;
return true;
}
/************************************************************************/
/* TIFFHashSetFindPtr() */
/************************************************************************/
static void **TIFFHashSetFindPtr(TIFFHashSet *set, const void *elt)
{
const unsigned long nHashVal = set->fnHashFunc(elt) % set->nAllocatedSize;
TIFFList *cur = set->tabList[nHashVal];
while (cur)
{
if (set->fnEqualFunc(cur->pData, elt))
return &cur->pData;
cur = cur->psNext;
}
return NULL;
}
/************************************************************************/
/* TIFFHashSetInsert() */
/************************************************************************/
/**
* Inserts an element into a hash set.
*
* If the element was already inserted in the hash set, the previous
* element is replaced by the new element. If a free function was provided,
* it is used to free the previously inserted element
*
* @param set the hash set
* @param elt the new element to insert in the hash set
*
* @return true if success. If false is returned, elt has not been inserted,
* but TIFFHashSetInsert() will have run the free function if provided.
*/
bool TIFFHashSetInsert(TIFFHashSet *set, void *elt)
{
assert(set != NULL);
void **pElt = TIFFHashSetFindPtr(set, elt);
if (pElt)
{
if (set->fnFreeEltFunc)
set->fnFreeEltFunc(*pElt);
*pElt = elt;
return true;
}
if (set->nSize >= 2 * set->nAllocatedSize / 3 ||
(set->bRehash && set->nIndiceAllocatedSize > 0 &&
set->nSize <= set->nAllocatedSize / 2))
{
set->nIndiceAllocatedSize++;
if (!TIFFHashSetRehash(set))
{
set->nIndiceAllocatedSize--;
if (set->fnFreeEltFunc)
set->fnFreeEltFunc(elt);
return false;
}
}
const unsigned long nHashVal = set->fnHashFunc(elt) % set->nAllocatedSize;
#ifdef HASH_DEBUG
if (set->tabList[nHashVal])
set->nCollisions++;
#endif
TIFFList *new_elt = TIFFHashSetGetNewListElt(set);
if (new_elt == NULL)
{
if (set->fnFreeEltFunc)
set->fnFreeEltFunc(elt);
return false;
}
new_elt->pData = elt;
new_elt->psNext = set->tabList[nHashVal];
set->tabList[nHashVal] = new_elt;
set->nSize++;
return true;
}
/************************************************************************/
/* TIFFHashSetLookup() */
/************************************************************************/
/**
* Returns the element found in the hash set corresponding to the element to
* look up The element must not be modified.
*
* @param set the hash set
* @param elt the element to look up in the hash set
*
* @return the element found in the hash set or NULL
*/
void *TIFFHashSetLookup(TIFFHashSet *set, const void *elt)
{
assert(set != NULL);
void **pElt = TIFFHashSetFindPtr(set, elt);
if (pElt)
return *pElt;
return NULL;
}
/************************************************************************/
/* TIFFHashSetRemoveInternal() */
/************************************************************************/
static bool TIFFHashSetRemoveInternal(TIFFHashSet *set, const void *elt,
bool bDeferRehash)
{
assert(set != NULL);
if (set->nIndiceAllocatedSize > 0 && set->nSize <= set->nAllocatedSize / 2)
{
set->nIndiceAllocatedSize--;
if (bDeferRehash)
set->bRehash = true;
else
{
if (!TIFFHashSetRehash(set))
{
set->nIndiceAllocatedSize++;
return false;
}
}
}
int nHashVal = (int)(set->fnHashFunc(elt) % set->nAllocatedSize);
TIFFList *cur = set->tabList[nHashVal];
TIFFList *prev = NULL;
while (cur)
{
if (set->fnEqualFunc(cur->pData, elt))
{
if (prev)
prev->psNext = cur->psNext;
else
set->tabList[nHashVal] = cur->psNext;
if (set->fnFreeEltFunc)
set->fnFreeEltFunc(cur->pData);
TIFFHashSetReturnListElt(set, cur);
#ifdef HASH_DEBUG
if (set->tabList[nHashVal])
set->nCollisions--;
#endif
set->nSize--;
return true;
}
prev = cur;
cur = cur->psNext;
}
return false;
}
/************************************************************************/
/* TIFFHashSetRemove() */
/************************************************************************/
/**
* Removes an element from a hash set
*
* @param set the hash set
* @param elt the new element to remove from the hash set
*
* @return true if the element was in the hash set
*/
bool TIFFHashSetRemove(TIFFHashSet *set, const void *elt)
{
return TIFFHashSetRemoveInternal(set, elt, false);
}
#ifdef notused
/************************************************************************/
/* TIFFHashSetRemoveDeferRehash() */
/************************************************************************/
/**
* Removes an element from a hash set.
*
* This will defer potential rehashing of the set to later calls to
* TIFFHashSetInsert() or TIFFHashSetRemove().
*
* @param set the hash set
* @param elt the new element to remove from the hash set
*
* @return true if the element was in the hash set
*/
bool TIFFHashSetRemoveDeferRehash(TIFFHashSet *set, const void *elt)
{
return TIFFHashSetRemoveInternal(set, elt, true);
}
#endif

100
libs/tiff/libtiff/tif_hash_set.h Normal file
View file

@ -0,0 +1,100 @@
/**********************************************************************
* $Id$
*
* Name: tif_hash_set.h
* Project: TIFF - Common Portability Library
* Purpose: Hash set functions.
* Author: Even Rouault, <even dot rouault at spatialys.com>
*
**********************************************************************
* Copyright (c) 2008-2009, Even Rouault <even dot rouault at spatialys.com>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
****************************************************************************/
#ifndef TIFF_HASH_SET_H_INCLUDED
#define TIFF_HASH_SET_H_INCLUDED
#include <stdbool.h>
/**
* \file tif_hash_set.h
*
* Hash set implementation.
*
* An hash set is a data structure that holds elements that are unique
* according to a comparison function. Operations on the hash set, such as
* insertion, removal or lookup, are supposed to be fast if an efficient
* "hash" function is provided.
*/
#ifdef __cplusplus
extern "C"
{
#endif
/* Types */
/** Opaque type for a hash set */
typedef struct _TIFFHashSet TIFFHashSet;
/** TIFFHashSetHashFunc */
typedef unsigned long (*TIFFHashSetHashFunc)(const void *elt);
/** TIFFHashSetEqualFunc */
typedef bool (*TIFFHashSetEqualFunc)(const void *elt1, const void *elt2);
/** TIFFHashSetFreeEltFunc */
typedef void (*TIFFHashSetFreeEltFunc)(void *elt);
/* Functions */
TIFFHashSet *TIFFHashSetNew(TIFFHashSetHashFunc fnHashFunc,
TIFFHashSetEqualFunc fnEqualFunc,
TIFFHashSetFreeEltFunc fnFreeEltFunc);
void TIFFHashSetDestroy(TIFFHashSet *set);
#ifdef notused
void TIFFHashSetClear(TIFFHashSet *set);
int TIFFHashSetSize(const TIFFHashSet *set);
/** TIFFHashSetIterEltFunc */
typedef int (*TIFFHashSetIterEltFunc)(void *elt, void *user_data);
void TIFFHashSetForeach(TIFFHashSet *set, TIFFHashSetIterEltFunc fnIterFunc,
void *user_data);
#endif
bool TIFFHashSetInsert(TIFFHashSet *set, void *elt);
void *TIFFHashSetLookup(TIFFHashSet *set, const void *elt);
bool TIFFHashSetRemove(TIFFHashSet *set, const void *elt);
#ifdef notused
bool TIFFHashSetRemoveDeferRehash(TIFFHashSet *set, const void *elt);
#endif
#ifdef __cplusplus
}
#endif
#endif /* TIFF_HASH_SET_H_INCLUDED */

3986
libs/tiff/libtiff/tif_jpeg.c
View file

File diff suppressed because it is too large Load diff

2854
libs/tiff/libtiff/tif_luv.c
View file

File diff suppressed because it is too large Load diff

2208
libs/tiff/libtiff/tif_lzw.c
View file

File diff suppressed because it is too large Load diff

301
libs/tiff/libtiff/tif_next.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -30,158 +30,165 @@
* NeXT 2-bit Grey Scale Compression Algorithm Support * NeXT 2-bit Grey Scale Compression Algorithm Support
*/ */
#define SETPIXEL(op, v) { \ #define SETPIXEL(op, v) \
switch (npixels++ & 3) { \ { \
case 0: op[0] = (unsigned char) ((v) << 6); break; \ switch (npixels++ & 3) \
case 1: op[0] |= (v) << 4; break; \ { \
case 2: op[0] |= (v) << 2; break; \ case 0: \
case 3: *op++ |= (v); op_offset++; break; \ op[0] = (unsigned char)((v) << 6); \
} \ break; \
} case 1: \
op[0] |= (v) << 4; \
break; \
case 2: \
op[0] |= (v) << 2; \
break; \
case 3: \
*op++ |= (v); \
op_offset++; \
break; \
} \
}
#define LITERALROW 0x00 #define LITERALROW 0x00
#define LITERALSPAN 0x40 #define LITERALSPAN 0x40
#define WHITE ((1<<2)-1) #define WHITE ((1 << 2) - 1)
static int static int NeXTDecode(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
NeXTDecode(TIFF* tif, uint8_t* buf, tmsize_t occ, uint16_t s)
{ {
static const char module[] = "NeXTDecode"; static const char module[] = "NeXTDecode";
unsigned char *bp, *op; unsigned char *bp, *op;
tmsize_t cc; tmsize_t cc;
uint8_t* row; uint8_t *row;
tmsize_t scanline, n; tmsize_t scanline, n;
(void) s; (void)s;
/* /*
* Each scanline is assumed to start off as all * Each scanline is assumed to start off as all
* white (we assume a PhotometricInterpretation * white (we assume a PhotometricInterpretation
* of ``min-is-black''). * of ``min-is-black'').
*/ */
for (op = (unsigned char*) buf, cc = occ; cc-- > 0;) for (op = (unsigned char *)buf, cc = occ; cc-- > 0;)
*op++ = 0xff; *op++ = 0xff;
bp = (unsigned char *)tif->tif_rawcp; bp = (unsigned char *)tif->tif_rawcp;
cc = tif->tif_rawcc; cc = tif->tif_rawcc;
scanline = tif->tif_scanlinesize; scanline = tif->tif_scanlinesize;
if (occ % scanline) if (occ % scanline)
{ {
TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read"); TIFFErrorExtR(tif, module, "Fractional scanlines cannot be read");
return (0); return (0);
} }
for (row = buf; cc > 0 && occ > 0; occ -= scanline, row += scanline) { for (row = buf; cc > 0 && occ > 0; occ -= scanline, row += scanline)
n = *bp++; {
cc--; n = *bp++;
switch (n) { cc--;
case LITERALROW: switch (n)
/* {
* The entire scanline is given as literal values. case LITERALROW:
*/ /*
if (cc < scanline) * The entire scanline is given as literal values.
goto bad; */
_TIFFmemcpy(row, bp, scanline); if (cc < scanline)
bp += scanline; goto bad;
cc -= scanline; _TIFFmemcpy(row, bp, scanline);
break; bp += scanline;
case LITERALSPAN: { cc -= scanline;
tmsize_t off; break;
/* case LITERALSPAN:
* The scanline has a literal span that begins at some {
* offset. tmsize_t off;
*/ /*
if( cc < 4 ) * The scanline has a literal span that begins at some
goto bad; * offset.
off = (bp[0] * 256) + bp[1]; */
n = (bp[2] * 256) + bp[3]; if (cc < 4)
if (cc < 4+n || off+n > scanline) goto bad;
goto bad; off = (bp[0] * 256) + bp[1];
_TIFFmemcpy(row+off, bp+4, n); n = (bp[2] * 256) + bp[3];
bp += 4+n; if (cc < 4 + n || off + n > scanline)
cc -= 4+n; goto bad;
break; _TIFFmemcpy(row + off, bp + 4, n);
} bp += 4 + n;
default: { cc -= 4 + n;
uint32_t npixels = 0, grey; break;
tmsize_t op_offset = 0; }
uint32_t imagewidth = tif->tif_dir.td_imagewidth; default:
if( isTiled(tif) ) {
imagewidth = tif->tif_dir.td_tilewidth; uint32_t npixels = 0, grey;
tmsize_t op_offset = 0;
uint32_t imagewidth = tif->tif_dir.td_imagewidth;
if (isTiled(tif))
imagewidth = tif->tif_dir.td_tilewidth;
/* /*
* The scanline is composed of a sequence of constant * The scanline is composed of a sequence of constant
* color ``runs''. We shift into ``run mode'' and * color ``runs''. We shift into ``run mode'' and
* interpret bytes as codes of the form * interpret bytes as codes of the form
* <color><npixels> until we've filled the scanline. * <color><npixels> until we've filled the scanline.
*/ */
op = row; op = row;
for (;;) { for (;;)
grey = (uint32_t)((n >> 6) & 0x3); {
n &= 0x3f; grey = (uint32_t)((n >> 6) & 0x3);
/* n &= 0x3f;
* Ensure the run does not exceed the scanline /*
* bounds, potentially resulting in a security * Ensure the run does not exceed the scanline
* issue. * bounds, potentially resulting in a security
*/ * issue.
while (n-- > 0 && npixels < imagewidth && op_offset < scanline) */
SETPIXEL(op, grey); while (n-- > 0 && npixels < imagewidth &&
if (npixels >= imagewidth) op_offset < scanline)
break; SETPIXEL(op, grey);
if (op_offset >= scanline ) { if (npixels >= imagewidth)
TIFFErrorExt(tif->tif_clientdata, module, "Invalid data for scanline %"PRIu32, break;
tif->tif_row); if (op_offset >= scanline)
return (0); {
TIFFErrorExtR(tif, module,
"Invalid data for scanline %" PRIu32,
tif->tif_row);
return (0);
}
if (cc == 0)
goto bad;
n = *bp++;
cc--;
} }
if (cc == 0) break;
goto bad; }
n = *bp++; }
cc--; }
} tif->tif_rawcp = (uint8_t *)bp;
break; tif->tif_rawcc = cc;
} return (1);
}
}
tif->tif_rawcp = (uint8_t*) bp;
tif->tif_rawcc = cc;
return (1);
bad: bad:
TIFFErrorExt(tif->tif_clientdata, module, "Not enough data for scanline %"PRIu32, TIFFErrorExtR(tif, module, "Not enough data for scanline %" PRIu32,
tif->tif_row); tif->tif_row);
return (0); return (0);
} }
static int static int NeXTPreDecode(TIFF *tif, uint16_t s)
NeXTPreDecode(TIFF* tif, uint16_t s)
{ {
static const char module[] = "NeXTPreDecode"; static const char module[] = "NeXTPreDecode";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
(void)s; (void)s;
if( td->td_bitspersample != 2 ) if (td->td_bitspersample != 2)
{ {
TIFFErrorExt(tif->tif_clientdata, module, "Unsupported BitsPerSample = %"PRIu16, TIFFErrorExtR(tif, module, "Unsupported BitsPerSample = %" PRIu16,
td->td_bitspersample); td->td_bitspersample);
return (0); return (0);
} }
return (1); return (1);
} }
int int TIFFInitNeXT(TIFF *tif, int scheme)
TIFFInitNeXT(TIFF* tif, int scheme)
{ {
(void) scheme; (void)scheme;
tif->tif_predecode = NeXTPreDecode; tif->tif_predecode = NeXTPreDecode;
tif->tif_decoderow = NeXTDecode; tif->tif_decoderow = NeXTDecode;
tif->tif_decodestrip = NeXTDecode; tif->tif_decodestrip = NeXTDecode;
tif->tif_decodetile = NeXTDecode; tif->tif_decodetile = NeXTDecode;
return (1); return (1);
} }
#endif /* NEXT_SUPPORT */ #endif /* NEXT_SUPPORT */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

1221
libs/tiff/libtiff/tif_open.c
View file

File diff suppressed because it is too large Load diff

510
libs/tiff/libtiff/tif_packbits.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -31,157 +31,178 @@
*/ */
#include <stdio.h> #include <stdio.h>
static int static int PackBitsPreEncode(TIFF *tif, uint16_t s)
PackBitsPreEncode(TIFF* tif, uint16_t s)
{ {
(void) s; (void)s;
tif->tif_data = (uint8_t*)_TIFFmalloc(sizeof(tmsize_t)); tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(tmsize_t));
if (tif->tif_data == NULL) if (tif->tif_data == NULL)
return (0); return (0);
/* /*
* Calculate the scanline/tile-width size in bytes. * Calculate the scanline/tile-width size in bytes.
*/ */
if (isTiled(tif)) if (isTiled(tif))
*(tmsize_t*)tif->tif_data = TIFFTileRowSize(tif); *(tmsize_t *)tif->tif_data = TIFFTileRowSize(tif);
else else
*(tmsize_t*)tif->tif_data = TIFFScanlineSize(tif); *(tmsize_t *)tif->tif_data = TIFFScanlineSize(tif);
return (1); return (1);
} }
static int static int PackBitsPostEncode(TIFF *tif)
PackBitsPostEncode(TIFF* tif)
{ {
if (tif->tif_data) if (tif->tif_data)
_TIFFfree(tif->tif_data); _TIFFfreeExt(tif, tif->tif_data);
return (1); return (1);
} }
/* /*
* Encode a run of pixels. * Encode a run of pixels.
*/ */
static int static int PackBitsEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
PackBitsEncode(TIFF* tif, uint8_t* buf, tmsize_t cc, uint16_t s)
{ {
unsigned char* bp = (unsigned char*) buf; unsigned char *bp = (unsigned char *)buf;
uint8_t* op; uint8_t *op;
uint8_t* ep; uint8_t *ep;
uint8_t* lastliteral; uint8_t *lastliteral;
long n, slop; long n, slop;
int b; int b;
enum { BASE, LITERAL, RUN, LITERAL_RUN } state; enum
{
BASE,
LITERAL,
RUN,
LITERAL_RUN
} state;
(void) s; (void)s;
op = tif->tif_rawcp; op = tif->tif_rawcp;
ep = tif->tif_rawdata + tif->tif_rawdatasize; ep = tif->tif_rawdata + tif->tif_rawdatasize;
state = BASE; state = BASE;
lastliteral = 0; lastliteral = 0;
while (cc > 0) { while (cc > 0)
/* {
* Find the longest string of identical bytes. /*
*/ * Find the longest string of identical bytes.
b = *bp++; */
cc--; b = *bp++;
n = 1; cc--;
for (; cc > 0 && b == *bp; cc--, bp++) n = 1;
n++; for (; cc > 0 && b == *bp; cc--, bp++)
again: n++;
if (op + 2 >= ep) { /* insure space for new data */ again:
/* if (op + 2 >= ep)
* Be careful about writing the last { /* insure space for new data */
* literal. Must write up to that point /*
* and then copy the remainder to the * Be careful about writing the last
* front of the buffer. * literal. Must write up to that point
*/ * and then copy the remainder to the
if (state == LITERAL || state == LITERAL_RUN) { * front of the buffer.
slop = (long)(op - lastliteral); */
tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp); if (state == LITERAL || state == LITERAL_RUN)
if (!TIFFFlushData1(tif)) {
return (0); slop = (long)(op - lastliteral);
op = tif->tif_rawcp; tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp);
while (slop-- > 0) if (!TIFFFlushData1(tif))
*op++ = *lastliteral++; return (0);
lastliteral = tif->tif_rawcp; op = tif->tif_rawcp;
} else { while (slop-- > 0)
tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp); *op++ = *lastliteral++;
if (!TIFFFlushData1(tif)) lastliteral = tif->tif_rawcp;
return (0); }
op = tif->tif_rawcp; else
} {
} tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
switch (state) { if (!TIFFFlushData1(tif))
case BASE: /* initial state, set run/literal */ return (0);
if (n > 1) { op = tif->tif_rawcp;
state = RUN; }
if (n > 128) { }
*op++ = (uint8_t) -127; switch (state)
*op++ = (uint8_t) b; {
n -= 128; case BASE: /* initial state, set run/literal */
goto again; if (n > 1)
} {
*op++ = (uint8_t)(-(n - 1)); state = RUN;
*op++ = (uint8_t) b; if (n > 128)
} else { {
lastliteral = op; *op++ = (uint8_t)-127;
*op++ = 0; *op++ = (uint8_t)b;
*op++ = (uint8_t) b; n -= 128;
state = LITERAL; goto again;
} }
break; *op++ = (uint8_t)(-(n - 1));
case LITERAL: /* last object was literal string */ *op++ = (uint8_t)b;
if (n > 1) { }
state = LITERAL_RUN; else
if (n > 128) { {
*op++ = (uint8_t) -127; lastliteral = op;
*op++ = (uint8_t) b; *op++ = 0;
n -= 128; *op++ = (uint8_t)b;
goto again; state = LITERAL;
} }
*op++ = (uint8_t)(-(n - 1)); /* encode run */ break;
*op++ = (uint8_t) b; case LITERAL: /* last object was literal string */
} else { /* extend literal */ if (n > 1)
if (++(*lastliteral) == 127) {
state = BASE; state = LITERAL_RUN;
*op++ = (uint8_t) b; if (n > 128)
} {
break; *op++ = (uint8_t)-127;
case RUN: /* last object was run */ *op++ = (uint8_t)b;
if (n > 1) { n -= 128;
if (n > 128) { goto again;
*op++ = (uint8_t) -127; }
*op++ = (uint8_t) b; *op++ = (uint8_t)(-(n - 1)); /* encode run */
n -= 128; *op++ = (uint8_t)b;
goto again; }
} else
*op++ = (uint8_t)(-(n - 1)); { /* extend literal */
*op++ = (uint8_t) b; if (++(*lastliteral) == 127)
} else { state = BASE;
lastliteral = op; *op++ = (uint8_t)b;
*op++ = 0; }
*op++ = (uint8_t) b; break;
state = LITERAL; case RUN: /* last object was run */
} if (n > 1)
break; {
case LITERAL_RUN: /* literal followed by a run */ if (n > 128)
/* {
* Check to see if previous run should *op++ = (uint8_t)-127;
* be converted to a literal, in which *op++ = (uint8_t)b;
* case we convert literal-run-literal n -= 128;
* to a single literal. goto again;
*/ }
if (n == 1 && op[-2] == (uint8_t) -1 && *op++ = (uint8_t)(-(n - 1));
*lastliteral < 126) { *op++ = (uint8_t)b;
state = (((*lastliteral) += 2) == 127 ? }
BASE : LITERAL); else
op[-2] = op[-1]; /* replicate */ {
} else lastliteral = op;
state = RUN; *op++ = 0;
goto again; *op++ = (uint8_t)b;
} state = LITERAL;
} }
tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp); break;
tif->tif_rawcp = op; case LITERAL_RUN: /* literal followed by a run */
return (1); /*
* 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) += 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);
} }
/* /*
@ -191,113 +212,112 @@ PackBitsEncode(TIFF* tif, uint8_t* buf, tmsize_t cc, uint16_t s)
* the decoder if data is read, for example, by scanlines * the decoder if data is read, for example, by scanlines
* when it was encoded by strips. * when it was encoded by strips.
*/ */
static int static int PackBitsEncodeChunk(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
PackBitsEncodeChunk(TIFF* tif, uint8_t* bp, tmsize_t cc, uint16_t s)
{ {
tmsize_t rowsize = *(tmsize_t*)tif->tif_data; tmsize_t rowsize = *(tmsize_t *)tif->tif_data;
while (cc > 0) { while (cc > 0)
tmsize_t chunk = rowsize; {
tmsize_t chunk = rowsize;
if( cc < chunk )
chunk = cc;
if (PackBitsEncode(tif, bp, chunk, s) < 0) if (cc < chunk)
return (-1); chunk = cc;
bp += chunk;
cc -= chunk; if (PackBitsEncode(tif, bp, chunk, s) < 0)
} return (-1);
return (1); bp += chunk;
cc -= chunk;
}
return (1);
} }
static int static int PackBitsDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
PackBitsDecode(TIFF* tif, uint8_t* op, tmsize_t occ, uint16_t s)
{ {
static const char module[] = "PackBitsDecode"; static const char module[] = "PackBitsDecode";
int8_t *bp; int8_t *bp;
tmsize_t cc; tmsize_t cc;
long n; long n;
int b; int b;
(void) s; (void)s;
bp = (int8_t*) tif->tif_rawcp; bp = (int8_t *)tif->tif_rawcp;
cc = tif->tif_rawcc; cc = tif->tif_rawcc;
while (cc > 0 && occ > 0) { while (cc > 0 && occ > 0)
n = (long) *bp++; {
cc--; n = (long)*bp++;
if (n < 0) { /* replicate next byte -n+1 times */ cc--;
if (n == -128) /* nop */ if (n < 0)
continue; { /* replicate next byte -n+1 times */
n = -n + 1; if (n == -128) /* nop */
if( occ < (tmsize_t)n ) continue;
{ n = -n + 1;
TIFFWarningExt(tif->tif_clientdata, module, if (occ < (tmsize_t)n)
"Discarding %"TIFF_SSIZE_FORMAT" bytes to avoid buffer overrun", {
(tmsize_t)n - occ); TIFFWarningExtR(tif, module,
n = (long)occ; "Discarding %" TIFF_SSIZE_FORMAT
} " bytes to avoid buffer overrun",
if( cc == 0 ) (tmsize_t)n - occ);
{ n = (long)occ;
TIFFWarningExt(tif->tif_clientdata, module, }
"Terminating PackBitsDecode due to lack of data."); if (cc == 0)
break; {
} TIFFWarningExtR(
occ -= n; tif, module,
b = *bp++; "Terminating PackBitsDecode due to lack of data.");
cc--; break;
while (n-- > 0) }
*op++ = (uint8_t) b; occ -= n;
} else { /* copy next n+1 bytes literally */ b = *bp++;
if (occ < (tmsize_t)(n + 1)) cc--;
{ while (n-- > 0)
TIFFWarningExt(tif->tif_clientdata, module, *op++ = (uint8_t)b;
"Discarding %"TIFF_SSIZE_FORMAT" bytes to avoid buffer overrun", }
(tmsize_t)n - occ + 1); else
n = (long)occ - 1; { /* copy next n+1 bytes literally */
} if (occ < (tmsize_t)(n + 1))
if (cc < (tmsize_t) (n+1)) {
{ TIFFWarningExtR(tif, module,
TIFFWarningExt(tif->tif_clientdata, module, "Discarding %" TIFF_SSIZE_FORMAT
"Terminating PackBitsDecode due to lack of data."); " bytes to avoid buffer overrun",
break; (tmsize_t)n - occ + 1);
} n = (long)occ - 1;
_TIFFmemcpy(op, bp, ++n); }
op += n; occ -= n; if (cc < (tmsize_t)(n + 1))
bp += n; cc -= n; {
} TIFFWarningExtR(
} tif, module,
tif->tif_rawcp = (uint8_t*) bp; "Terminating PackBitsDecode due to lack of data.");
tif->tif_rawcc = cc; break;
if (occ > 0) { }
TIFFErrorExt(tif->tif_clientdata, module, _TIFFmemcpy(op, bp, ++n);
"Not enough data for scanline %"PRIu32, op += n;
tif->tif_row); occ -= n;
return (0); bp += n;
} cc -= n;
return (1); }
}
tif->tif_rawcp = (uint8_t *)bp;
tif->tif_rawcc = cc;
if (occ > 0)
{
TIFFErrorExtR(tif, module, "Not enough data for scanline %" PRIu32,
tif->tif_row);
return (0);
}
return (1);
} }
int int TIFFInitPackBits(TIFF *tif, int scheme)
TIFFInitPackBits(TIFF* tif, int scheme)
{ {
(void) scheme; (void)scheme;
tif->tif_decoderow = PackBitsDecode; tif->tif_decoderow = PackBitsDecode;
tif->tif_decodestrip = PackBitsDecode; tif->tif_decodestrip = PackBitsDecode;
tif->tif_decodetile = PackBitsDecode; tif->tif_decodetile = PackBitsDecode;
tif->tif_preencode = PackBitsPreEncode; tif->tif_preencode = PackBitsPreEncode;
tif->tif_postencode = PackBitsPostEncode; tif->tif_postencode = PackBitsPostEncode;
tif->tif_encoderow = PackBitsEncode; tif->tif_encoderow = PackBitsEncode;
tif->tif_encodestrip = PackBitsEncodeChunk; tif->tif_encodestrip = PackBitsEncodeChunk;
tif->tif_encodetile = PackBitsEncodeChunk; tif->tif_encodetile = PackBitsEncodeChunk;
return (1); return (1);
} }
#endif /* PACKBITS_SUPPORT */ #endif /* PACKBITS_SUPPORT */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

2516
libs/tiff/libtiff/tif_pixarlog.c
View file

File diff suppressed because it is too large Load diff

1521
libs/tiff/libtiff/tif_predict.c
View file

File diff suppressed because it is too large Load diff

55
libs/tiff/libtiff/tif_predict.h
View file

@ -23,7 +23,7 @@
*/ */
#ifndef _TIFFPREDICT_ #ifndef _TIFFPREDICT_
#define _TIFFPREDICT_ #define _TIFFPREDICT_
#include "tiffio.h" #include "tiffio.h"
#include "tiffiop.h" #include "tiffiop.h"
@ -32,50 +32,43 @@
* ``Library-private'' Support for the Predictor Tag * ``Library-private'' Support for the Predictor Tag
*/ */
typedef int (*TIFFEncodeDecodeMethod)(TIFF* tif, uint8_t* buf, tmsize_t size); typedef int (*TIFFEncodeDecodeMethod)(TIFF *tif, uint8_t *buf, tmsize_t size);
/* /*
* Codecs that want to support the Predictor tag must place * Codecs that want to support the Predictor tag must place
* this structure first in their private state block so that * this structure first in their private state block so that
* the predictor code can cast tif_data to find its state. * the predictor code can cast tif_data to find its state.
*/ */
typedef struct { typedef struct
int predictor; /* predictor tag value */ {
tmsize_t stride; /* sample stride over data */ int predictor; /* predictor tag value */
tmsize_t rowsize; /* tile/strip row size */ tmsize_t stride; /* sample stride over data */
tmsize_t rowsize; /* tile/strip row size */
TIFFCodeMethod encoderow; /* parent codec encode/decode row */ TIFFCodeMethod encoderow; /* parent codec encode/decode row */
TIFFCodeMethod encodestrip; /* parent codec encode/decode strip */ TIFFCodeMethod encodestrip; /* parent codec encode/decode strip */
TIFFCodeMethod encodetile; /* parent codec encode/decode tile */ TIFFCodeMethod encodetile; /* parent codec encode/decode tile */
TIFFEncodeDecodeMethod encodepfunc; /* horizontal differencer */ TIFFEncodeDecodeMethod encodepfunc; /* horizontal differencer */
TIFFCodeMethod decoderow; /* parent codec encode/decode row */ TIFFCodeMethod decoderow; /* parent codec encode/decode row */
TIFFCodeMethod decodestrip; /* parent codec encode/decode strip */ TIFFCodeMethod decodestrip; /* parent codec encode/decode strip */
TIFFCodeMethod decodetile; /* parent codec encode/decode tile */ TIFFCodeMethod decodetile; /* parent codec encode/decode tile */
TIFFEncodeDecodeMethod decodepfunc; /* horizontal accumulator */ TIFFEncodeDecodeMethod decodepfunc; /* horizontal accumulator */
TIFFVGetMethod vgetparent; /* super-class method */ TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */ TIFFVSetMethod vsetparent; /* super-class method */
TIFFPrintMethod printdir; /* super-class method */ TIFFPrintMethod printdir; /* super-class method */
TIFFBoolMethod setupdecode; /* super-class method */ TIFFBoolMethod setupdecode; /* super-class method */
TIFFBoolMethod setupencode; /* super-class method */ TIFFBoolMethod setupencode; /* super-class method */
} TIFFPredictorState; } TIFFPredictorState;
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C"
{
#endif #endif
extern int TIFFPredictorInit(TIFF*); extern int TIFFPredictorInit(TIFF *);
extern int TIFFPredictorCleanup(TIFF*); extern int TIFFPredictorCleanup(TIFF *);
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif #endif
#endif /* _TIFFPREDICT_ */ #endif /* _TIFFPREDICT_ */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

2420
libs/tiff/libtiff/tif_read.c
View file

File diff suppressed because it is too large Load diff

484
libs/tiff/libtiff/tif_strip.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1991-1997 Sam Leffler * Copyright (c) 1991-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -32,146 +32,145 @@
/* /*
* Compute which strip a (row,sample) value is in. * Compute which strip a (row,sample) value is in.
*/ */
uint32_t uint32_t TIFFComputeStrip(TIFF *tif, uint32_t row, uint16_t sample)
TIFFComputeStrip(TIFF* tif, uint32_t row, uint16_t sample)
{ {
static const char module[] = "TIFFComputeStrip"; static const char module[] = "TIFFComputeStrip";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint32_t strip; uint32_t strip;
strip = row / td->td_rowsperstrip; strip = row / td->td_rowsperstrip;
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
if (sample >= td->td_samplesperpixel) { {
TIFFErrorExt(tif->tif_clientdata, module, if (sample >= td->td_samplesperpixel)
"%lu: Sample out of range, max %lu", {
(unsigned long) sample, (unsigned long) td->td_samplesperpixel); TIFFErrorExtR(tif, module, "%lu: Sample out of range, max %lu",
return (0); (unsigned long)sample,
} (unsigned long)td->td_samplesperpixel);
strip += (uint32_t)sample * td->td_stripsperimage; return (0);
} }
return (strip); strip += (uint32_t)sample * td->td_stripsperimage;
}
return (strip);
} }
/* /*
* Compute how many strips are in an image. * Compute how many strips are in an image.
*/ */
uint32_t uint32_t TIFFNumberOfStrips(TIFF *tif)
TIFFNumberOfStrips(TIFF* tif)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint32_t nstrips; uint32_t nstrips;
nstrips = (td->td_rowsperstrip == (uint32_t) -1 ? 1 : nstrips = (td->td_rowsperstrip == (uint32_t)-1
TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip)); ? 1
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) : TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip));
nstrips = _TIFFMultiply32(tif, nstrips, (uint32_t)td->td_samplesperpixel, if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
"TIFFNumberOfStrips"); nstrips =
return (nstrips); _TIFFMultiply32(tif, nstrips, (uint32_t)td->td_samplesperpixel,
"TIFFNumberOfStrips");
return (nstrips);
} }
/* /*
* Compute the # bytes in a variable height, row-aligned strip. * Compute the # bytes in a variable height, row-aligned strip.
*/ */
uint64_t uint64_t TIFFVStripSize64(TIFF *tif, uint32_t nrows)
TIFFVStripSize64(TIFF* tif, uint32_t nrows)
{ {
static const char module[] = "TIFFVStripSize64"; static const char module[] = "TIFFVStripSize64";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
if (nrows==(uint32_t)(-1)) if (nrows == (uint32_t)(-1))
nrows=td->td_imagelength; nrows = td->td_imagelength;
if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&& if ((td->td_planarconfig == PLANARCONFIG_CONTIG) &&
(td->td_photometric == PHOTOMETRIC_YCBCR)&& (td->td_photometric == PHOTOMETRIC_YCBCR) && (!isUpSampled(tif)))
(!isUpSampled(tif))) {
{ /*
/* * Packed YCbCr data contain one Cb+Cr for every
* Packed YCbCr data contain one Cb+Cr for every * HorizontalSampling*VerticalSampling Y values.
* HorizontalSampling*VerticalSampling Y values. * Must also roundup width and height when calculating
* Must also roundup width and height when calculating * since images that are not a multiple of the
* since images that are not a multiple of the * horizontal/vertical subsampling area include
* horizontal/vertical subsampling area include * YCbCr data for the extended image.
* YCbCr data for the extended image. */
*/ uint16_t ycbcrsubsampling[2];
uint16_t ycbcrsubsampling[2]; uint16_t samplingblock_samples;
uint16_t samplingblock_samples; uint32_t samplingblocks_hor;
uint32_t samplingblocks_hor; uint32_t samplingblocks_ver;
uint32_t samplingblocks_ver; uint64_t samplingrow_samples;
uint64_t samplingrow_samples; uint64_t samplingrow_size;
uint64_t samplingrow_size; if (td->td_samplesperpixel != 3)
if(td->td_samplesperpixel!=3) {
{ TIFFErrorExtR(tif, module, "Invalid td_samplesperpixel value");
TIFFErrorExt(tif->tif_clientdata,module, return 0;
"Invalid td_samplesperpixel value"); }
return 0; TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
} ycbcrsubsampling + 0, ycbcrsubsampling + 1);
TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0, if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
ycbcrsubsampling+1); ycbcrsubsampling[0] != 4) ||
if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4) (ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4)) ycbcrsubsampling[1] != 4))
{ {
TIFFErrorExt(tif->tif_clientdata,module, TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling (%dx%d)",
"Invalid YCbCr subsampling (%dx%d)", ycbcrsubsampling[0], ycbcrsubsampling[1]);
ycbcrsubsampling[0], return 0;
ycbcrsubsampling[1] ); }
return 0; samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
} samplingblocks_hor =
samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2; TIFFhowmany_32(td->td_imagewidth, ycbcrsubsampling[0]);
samplingblocks_hor=TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]); samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]); samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module); samplingblock_samples, module);
samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module)); samplingrow_size = TIFFhowmany8_64(_TIFFMultiply64(
return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module)); tif, samplingrow_samples, td->td_bitspersample, module));
} return (
else _TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
return(_TIFFMultiply64(tif,nrows,TIFFScanlineSize64(tif),module)); }
else
return (_TIFFMultiply64(tif, nrows, TIFFScanlineSize64(tif), module));
} }
tmsize_t tmsize_t TIFFVStripSize(TIFF *tif, uint32_t nrows)
TIFFVStripSize(TIFF* tif, uint32_t nrows)
{ {
static const char module[] = "TIFFVStripSize"; static const char module[] = "TIFFVStripSize";
uint64_t m; uint64_t m;
m=TIFFVStripSize64(tif,nrows); m = TIFFVStripSize64(tif, nrows);
return _TIFFCastUInt64ToSSize(tif, m, module); return _TIFFCastUInt64ToSSize(tif, m, module);
} }
/* /*
* Compute the # bytes in a raw strip. * Compute the # bytes in a raw strip.
*/ */
uint64_t uint64_t TIFFRawStripSize64(TIFF *tif, uint32_t strip)
TIFFRawStripSize64(TIFF* tif, uint32_t strip)
{ {
static const char module[] = "TIFFRawStripSize64"; static const char module[] = "TIFFRawStripSize64";
uint64_t bytecount = TIFFGetStrileByteCount(tif, strip); uint64_t bytecount = TIFFGetStrileByteCount(tif, strip);
if (bytecount == 0) if (bytecount == 0)
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module,
"%"PRIu64": Invalid strip byte count, strip %lu", "%" PRIu64 ": Invalid strip byte count, strip %lu",
(uint64_t) bytecount, (uint64_t)bytecount, (unsigned long)strip);
(unsigned long) strip); bytecount = (uint64_t)-1;
bytecount = (uint64_t) -1; }
}
return bytecount; return bytecount;
} }
tmsize_t tmsize_t TIFFRawStripSize(TIFF *tif, uint32_t strip)
TIFFRawStripSize(TIFF* tif, uint32_t strip)
{ {
static const char module[] = "TIFFRawStripSize"; static const char module[] = "TIFFRawStripSize";
uint64_t m; uint64_t m;
tmsize_t n; tmsize_t n;
m=TIFFRawStripSize64(tif,strip); m = TIFFRawStripSize64(tif, strip);
if (m==(uint64_t)(-1)) if (m == (uint64_t)(-1))
n=(tmsize_t)(-1); n = (tmsize_t)(-1);
else else
{ {
n=(tmsize_t)m; n = (tmsize_t)m;
if ((uint64_t)n != m) if ((uint64_t)n != m)
{ {
TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow"); TIFFErrorExtR(tif, module, "Integer overflow");
n=0; n = 0;
} }
} }
return(n); return (n);
} }
/* /*
@ -182,22 +181,20 @@ TIFFRawStripSize(TIFF* tif, uint32_t strip)
* truncated to reflect the actual space required * truncated to reflect the actual space required
* to hold the strip. * to hold the strip.
*/ */
uint64_t uint64_t TIFFStripSize64(TIFF *tif)
TIFFStripSize64(TIFF* tif)
{ {
TIFFDirectory* td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint32_t rps = td->td_rowsperstrip; uint32_t rps = td->td_rowsperstrip;
if (rps > td->td_imagelength) if (rps > td->td_imagelength)
rps = td->td_imagelength; rps = td->td_imagelength;
return (TIFFVStripSize64(tif, rps)); return (TIFFVStripSize64(tif, rps));
} }
tmsize_t tmsize_t TIFFStripSize(TIFF *tif)
TIFFStripSize(TIFF* tif)
{ {
static const char module[] = "TIFFStripSize"; static const char module[] = "TIFFStripSize";
uint64_t m; uint64_t m;
m=TIFFStripSize64(tif); m = TIFFStripSize64(tif);
return _TIFFCastUInt64ToSSize(tif, m, module); return _TIFFCastUInt64ToSSize(tif, m, module);
} }
/* /*
@ -206,34 +203,33 @@ TIFFStripSize(TIFF* tif)
* request is <1 then we choose a strip size according * request is <1 then we choose a strip size according
* to certain heuristics. * to certain heuristics.
*/ */
uint32_t uint32_t TIFFDefaultStripSize(TIFF *tif, uint32_t request)
TIFFDefaultStripSize(TIFF* tif, uint32_t request)
{ {
return (*tif->tif_defstripsize)(tif, request); return (*tif->tif_defstripsize)(tif, request);
} }
uint32_t uint32_t _TIFFDefaultStripSize(TIFF *tif, uint32_t s)
_TIFFDefaultStripSize(TIFF* tif, uint32_t s)
{ {
if ((int32_t) s < 1) { if ((int32_t)s < 1)
/* {
* If RowsPerStrip is unspecified, try to break the /*
* image up into strips that are approximately * If RowsPerStrip is unspecified, try to break the
* STRIP_SIZE_DEFAULT bytes long. * image up into strips that are approximately
*/ * STRIP_SIZE_DEFAULT bytes long.
uint64_t scanlinesize; */
uint64_t rows; uint64_t scanlinesize;
scanlinesize=TIFFScanlineSize64(tif); uint64_t rows;
if (scanlinesize==0) scanlinesize = TIFFScanlineSize64(tif);
scanlinesize=1; if (scanlinesize == 0)
rows= (uint64_t)STRIP_SIZE_DEFAULT / scanlinesize; scanlinesize = 1;
if (rows==0) rows = (uint64_t)STRIP_SIZE_DEFAULT / scanlinesize;
rows=1; if (rows == 0)
else if (rows>0xFFFFFFFF) rows = 1;
rows=0xFFFFFFFF; else if (rows > 0xFFFFFFFF)
s=(uint32_t)rows; rows = 0xFFFFFFFF;
} s = (uint32_t)rows;
return (s); }
return (s);
} }
/* /*
@ -246,70 +242,79 @@ _TIFFDefaultStripSize(TIFF* tif, uint32_t s)
* subsampling lines divided by vertical subsampling. It should thus make * subsampling lines divided by vertical subsampling. It should thus make
* sense when multiplied by a multiple of vertical subsampling. * sense when multiplied by a multiple of vertical subsampling.
*/ */
uint64_t uint64_t TIFFScanlineSize64(TIFF *tif)
TIFFScanlineSize64(TIFF* tif)
{ {
static const char module[] = "TIFFScanlineSize64"; static const char module[] = "TIFFScanlineSize64";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint64_t scanline_size; uint64_t scanline_size;
if (td->td_planarconfig==PLANARCONFIG_CONTIG) if (td->td_planarconfig == PLANARCONFIG_CONTIG)
{ {
if ((td->td_photometric==PHOTOMETRIC_YCBCR)&& if ((td->td_photometric == PHOTOMETRIC_YCBCR) &&
(td->td_samplesperpixel==3)&& (td->td_samplesperpixel == 3) && (!isUpSampled(tif)))
(!isUpSampled(tif)))
{
uint16_t ycbcrsubsampling[2];
uint16_t samplingblock_samples;
uint32_t samplingblocks_hor;
uint64_t samplingrow_samples;
uint64_t samplingrow_size;
if(td->td_samplesperpixel!=3)
{
TIFFErrorExt(tif->tif_clientdata,module,
"Invalid td_samplesperpixel value");
return 0;
}
TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,
ycbcrsubsampling+0,
ycbcrsubsampling+1);
if (((ycbcrsubsampling[0]!=1)&&(ycbcrsubsampling[0]!=2)&&(ycbcrsubsampling[0]!=4)) ||
((ycbcrsubsampling[1]!=1)&&(ycbcrsubsampling[1]!=2)&&(ycbcrsubsampling[1]!=4)))
{
TIFFErrorExt(tif->tif_clientdata,module,
"Invalid YCbCr subsampling");
return 0;
}
samplingblock_samples = ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
samplingblocks_hor = TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]);
samplingrow_samples = _TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
samplingrow_size = TIFFhowmany_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module),8);
scanline_size = (samplingrow_size/ycbcrsubsampling[1]);
}
else
{
uint64_t scanline_samples;
scanline_samples=_TIFFMultiply64(tif,td->td_imagewidth,td->td_samplesperpixel,module);
scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,scanline_samples,td->td_bitspersample,module),8);
}
}
else
{ {
scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,td->td_imagewidth,td->td_bitspersample,module),8); uint16_t ycbcrsubsampling[2];
} uint16_t samplingblock_samples;
if (scanline_size == 0) uint32_t samplingblocks_hor;
{ uint64_t samplingrow_samples;
TIFFErrorExt(tif->tif_clientdata,module,"Computed scanline size is zero"); uint64_t samplingrow_size;
if (td->td_samplesperpixel != 3)
{
TIFFErrorExtR(tif, module, "Invalid td_samplesperpixel value");
return 0; return 0;
}
TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
ycbcrsubsampling + 0, ycbcrsubsampling + 1);
if (((ycbcrsubsampling[0] != 1) && (ycbcrsubsampling[0] != 2) &&
(ycbcrsubsampling[0] != 4)) ||
((ycbcrsubsampling[1] != 1) && (ycbcrsubsampling[1] != 2) &&
(ycbcrsubsampling[1] != 4)))
{
TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling");
return 0;
}
samplingblock_samples =
ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
samplingblocks_hor =
TIFFhowmany_32(td->td_imagewidth, ycbcrsubsampling[0]);
samplingrow_samples = _TIFFMultiply64(
tif, samplingblocks_hor, samplingblock_samples, module);
samplingrow_size =
TIFFhowmany_64(_TIFFMultiply64(tif, samplingrow_samples,
td->td_bitspersample, module),
8);
scanline_size = (samplingrow_size / ycbcrsubsampling[1]);
} }
return(scanline_size); else
{
uint64_t scanline_samples;
scanline_samples = _TIFFMultiply64(tif, td->td_imagewidth,
td->td_samplesperpixel, module);
scanline_size =
TIFFhowmany_64(_TIFFMultiply64(tif, scanline_samples,
td->td_bitspersample, module),
8);
}
}
else
{
scanline_size =
TIFFhowmany_64(_TIFFMultiply64(tif, td->td_imagewidth,
td->td_bitspersample, module),
8);
}
if (scanline_size == 0)
{
TIFFErrorExtR(tif, module, "Computed scanline size is zero");
return 0;
}
return (scanline_size);
} }
tmsize_t tmsize_t TIFFScanlineSize(TIFF *tif)
TIFFScanlineSize(TIFF* tif)
{ {
static const char module[] = "TIFFScanlineSize"; static const char module[] = "TIFFScanlineSize";
uint64_t m; uint64_t m;
m=TIFFScanlineSize64(tif); m = TIFFScanlineSize64(tif);
return _TIFFCastUInt64ToSSize(tif, m, module); return _TIFFCastUInt64ToSSize(tif, m, module);
} }
/* /*
@ -318,35 +323,28 @@ TIFFScanlineSize(TIFF* tif)
* I/O size returned by TIFFScanlineSize which may be less * I/O size returned by TIFFScanlineSize which may be less
* if data is store as separate planes). * if data is store as separate planes).
*/ */
uint64_t uint64_t TIFFRasterScanlineSize64(TIFF *tif)
TIFFRasterScanlineSize64(TIFF* tif)
{ {
static const char module[] = "TIFFRasterScanlineSize64"; static const char module[] = "TIFFRasterScanlineSize64";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint64_t scanline; uint64_t scanline;
scanline = _TIFFMultiply64(tif, td->td_bitspersample, td->td_imagewidth, module); scanline =
if (td->td_planarconfig == PLANARCONFIG_CONTIG) { _TIFFMultiply64(tif, td->td_bitspersample, td->td_imagewidth, module);
scanline = _TIFFMultiply64(tif, scanline, td->td_samplesperpixel, module); if (td->td_planarconfig == PLANARCONFIG_CONTIG)
return (TIFFhowmany8_64(scanline)); {
} else scanline =
return (_TIFFMultiply64(tif, TIFFhowmany8_64(scanline), _TIFFMultiply64(tif, scanline, td->td_samplesperpixel, module);
td->td_samplesperpixel, module)); return (TIFFhowmany8_64(scanline));
}
else
return (_TIFFMultiply64(tif, TIFFhowmany8_64(scanline),
td->td_samplesperpixel, module));
} }
tmsize_t tmsize_t TIFFRasterScanlineSize(TIFF *tif)
TIFFRasterScanlineSize(TIFF* tif)
{ {
static const char module[] = "TIFFRasterScanlineSize"; static const char module[] = "TIFFRasterScanlineSize";
uint64_t m; uint64_t m;
m=TIFFRasterScanlineSize64(tif); m = TIFFRasterScanlineSize64(tif);
return _TIFFCastUInt64ToSSize(tif, m, module); return _TIFFCastUInt64ToSSize(tif, m, module);
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

445
libs/tiff/libtiff/tif_swab.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -30,169 +30,218 @@
#include "tiffiop.h" #include "tiffiop.h"
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabShort) #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabShort)
void void TIFFSwabShort(uint16_t *wp)
TIFFSwabShort(uint16_t* wp)
{ {
register unsigned char* cp = (unsigned char*) wp; register unsigned char *cp = (unsigned char *)wp;
unsigned char t; unsigned char t;
assert(sizeof(uint16_t) == 2); assert(sizeof(uint16_t) == 2);
t = cp[1]; cp[1] = cp[0]; cp[0] = t; t = cp[1];
cp[1] = cp[0];
cp[0] = t;
} }
#endif #endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabLong) #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabLong)
void void TIFFSwabLong(uint32_t *lp)
TIFFSwabLong(uint32_t* lp)
{ {
register unsigned char* cp = (unsigned char*) lp; register unsigned char *cp = (unsigned char *)lp;
unsigned char t; unsigned char t;
assert(sizeof(uint32_t) == 4); assert(sizeof(uint32_t) == 4);
t = cp[3]; cp[3] = cp[0]; cp[0] = t; t = cp[3];
t = cp[2]; cp[2] = cp[1]; cp[1] = t; cp[3] = cp[0];
cp[0] = t;
t = cp[2];
cp[2] = cp[1];
cp[1] = t;
} }
#endif #endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabLong8) #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabLong8)
void void TIFFSwabLong8(uint64_t *lp)
TIFFSwabLong8(uint64_t* lp)
{ {
register unsigned char* cp = (unsigned char*) lp; register unsigned char *cp = (unsigned char *)lp;
unsigned char t; unsigned char t;
assert(sizeof(uint64_t) == 8); assert(sizeof(uint64_t) == 8);
t = cp[7]; cp[7] = cp[0]; cp[0] = t; t = cp[7];
t = cp[6]; cp[6] = cp[1]; cp[1] = t; cp[7] = cp[0];
t = cp[5]; cp[5] = cp[2]; cp[2] = t; cp[0] = t;
t = cp[4]; cp[4] = cp[3]; cp[3] = t; t = cp[6];
cp[6] = cp[1];
cp[1] = t;
t = cp[5];
cp[5] = cp[2];
cp[2] = t;
t = cp[4];
cp[4] = cp[3];
cp[3] = t;
} }
#endif #endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfShort) #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfShort)
void void TIFFSwabArrayOfShort(register uint16_t *wp, tmsize_t n)
TIFFSwabArrayOfShort(register uint16_t* wp, tmsize_t n)
{ {
register unsigned char* cp; register unsigned char *cp;
register unsigned char t; register unsigned char t;
assert(sizeof(uint16_t) == 2); assert(sizeof(uint16_t) == 2);
/* XXX unroll loop some */ /* XXX unroll loop some */
while (n-- > 0) { while (n-- > 0)
cp = (unsigned char*) wp; {
t = cp[1]; cp[1] = cp[0]; cp[0] = t; cp = (unsigned char *)wp;
wp++; t = cp[1];
} cp[1] = cp[0];
cp[0] = t;
wp++;
}
} }
#endif #endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfTriples) #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfTriples)
void void TIFFSwabArrayOfTriples(register uint8_t *tp, tmsize_t n)
TIFFSwabArrayOfTriples(register uint8_t* tp, tmsize_t n)
{ {
unsigned char* cp; unsigned char *cp;
unsigned char t; unsigned char t;
/* XXX unroll loop some */ /* XXX unroll loop some */
while (n-- > 0) { while (n-- > 0)
cp = (unsigned char*) tp; {
t = cp[2]; cp[2] = cp[0]; cp[0] = t; cp = (unsigned char *)tp;
tp += 3; t = cp[2];
} cp[2] = cp[0];
cp[0] = t;
tp += 3;
}
} }
#endif #endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfLong) #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfLong)
void void TIFFSwabArrayOfLong(register uint32_t *lp, tmsize_t n)
TIFFSwabArrayOfLong(register uint32_t* lp, tmsize_t n)
{ {
register unsigned char *cp; register unsigned char *cp;
register unsigned char t; register unsigned char t;
assert(sizeof(uint32_t) == 4); assert(sizeof(uint32_t) == 4);
/* XXX unroll loop some */ /* XXX unroll loop some */
while (n-- > 0) { while (n-- > 0)
cp = (unsigned char *)lp; {
t = cp[3]; cp[3] = cp[0]; cp[0] = t; cp = (unsigned char *)lp;
t = cp[2]; cp[2] = cp[1]; cp[1] = t; t = cp[3];
lp++; cp[3] = cp[0];
} cp[0] = t;
t = cp[2];
cp[2] = cp[1];
cp[1] = t;
lp++;
}
} }
#endif #endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfLong8) #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfLong8)
void void TIFFSwabArrayOfLong8(register uint64_t *lp, tmsize_t n)
TIFFSwabArrayOfLong8(register uint64_t* lp, tmsize_t n)
{ {
register unsigned char *cp; register unsigned char *cp;
register unsigned char t; register unsigned char t;
assert(sizeof(uint64_t) == 8); assert(sizeof(uint64_t) == 8);
/* XXX unroll loop some */ /* XXX unroll loop some */
while (n-- > 0) { while (n-- > 0)
cp = (unsigned char *)lp; {
t = cp[7]; cp[7] = cp[0]; cp[0] = t; cp = (unsigned char *)lp;
t = cp[6]; cp[6] = cp[1]; cp[1] = t; t = cp[7];
t = cp[5]; cp[5] = cp[2]; cp[2] = t; cp[7] = cp[0];
t = cp[4]; cp[4] = cp[3]; cp[3] = t; cp[0] = t;
lp++; t = cp[6];
} cp[6] = cp[1];
cp[1] = t;
t = cp[5];
cp[5] = cp[2];
cp[2] = t;
t = cp[4];
cp[4] = cp[3];
cp[3] = t;
lp++;
}
} }
#endif #endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabFloat) #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabFloat)
void void TIFFSwabFloat(float *fp)
TIFFSwabFloat(float* fp)
{ {
register unsigned char* cp = (unsigned char*) fp; register unsigned char *cp = (unsigned char *)fp;
unsigned char t; unsigned char t;
assert(sizeof(float)==4); assert(sizeof(float) == 4);
t = cp[3]; cp[3] = cp[0]; cp[0] = t; t = cp[3];
t = cp[2]; cp[2] = cp[1]; cp[1] = t; cp[3] = cp[0];
cp[0] = t;
t = cp[2];
cp[2] = cp[1];
cp[1] = t;
} }
#endif #endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfFloat) #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfFloat)
void void TIFFSwabArrayOfFloat(register float *fp, tmsize_t n)
TIFFSwabArrayOfFloat(register float* fp, tmsize_t n)
{ {
register unsigned char *cp; register unsigned char *cp;
register unsigned char t; register unsigned char t;
assert(sizeof(float)==4); assert(sizeof(float) == 4);
/* XXX unroll loop some */ /* XXX unroll loop some */
while (n-- > 0) { while (n-- > 0)
cp = (unsigned char *)fp; {
t = cp[3]; cp[3] = cp[0]; cp[0] = t; cp = (unsigned char *)fp;
t = cp[2]; cp[2] = cp[1]; cp[1] = t; t = cp[3];
fp++; cp[3] = cp[0];
} cp[0] = t;
t = cp[2];
cp[2] = cp[1];
cp[1] = t;
fp++;
}
} }
#endif #endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabDouble) #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabDouble)
void void TIFFSwabDouble(double *dp)
TIFFSwabDouble(double *dp)
{ {
register unsigned char* cp = (unsigned char*) dp; register unsigned char *cp = (unsigned char *)dp;
unsigned char t; unsigned char t;
assert(sizeof(double)==8); assert(sizeof(double) == 8);
t = cp[7]; cp[7] = cp[0]; cp[0] = t; t = cp[7];
t = cp[6]; cp[6] = cp[1]; cp[1] = t; cp[7] = cp[0];
t = cp[5]; cp[5] = cp[2]; cp[2] = t; cp[0] = t;
t = cp[4]; cp[4] = cp[3]; cp[3] = t; t = cp[6];
cp[6] = cp[1];
cp[1] = t;
t = cp[5];
cp[5] = cp[2];
cp[2] = t;
t = cp[4];
cp[4] = cp[3];
cp[3] = t;
} }
#endif #endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfDouble) #if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfDouble)
void void TIFFSwabArrayOfDouble(double *dp, tmsize_t n)
TIFFSwabArrayOfDouble(double* dp, tmsize_t n)
{ {
register unsigned char *cp; register unsigned char *cp;
register unsigned char t; register unsigned char t;
assert(sizeof(double)==8); assert(sizeof(double) == 8);
/* XXX unroll loop some */ /* XXX unroll loop some */
while (n-- > 0) { while (n-- > 0)
cp = (unsigned char *)dp; {
t = cp[7]; cp[7] = cp[0]; cp[0] = t; cp = (unsigned char *)dp;
t = cp[6]; cp[6] = cp[1]; cp[1] = t; t = cp[7];
t = cp[5]; cp[5] = cp[2]; cp[2] = t; cp[7] = cp[0];
t = cp[4]; cp[4] = cp[3]; cp[3] = t; cp[0] = t;
dp++; t = cp[6];
} cp[6] = cp[1];
cp[1] = t;
t = cp[5];
cp[5] = cp[2];
cp[2] = t;
t = cp[4];
cp[4] = cp[3];
cp[3] = t;
dp++;
}
} }
#endif #endif
@ -206,105 +255,75 @@ TIFFSwabArrayOfDouble(double* dp, tmsize_t n)
* do not reverse bit values. * do not reverse bit values.
*/ */
static const unsigned char TIFFBitRevTable[256] = { static const unsigned char TIFFBitRevTable[256] = {
0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0,
0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0, 0x30, 0xb0, 0x70, 0xf0, 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x04, 0x84, 0x44, 0xc4,
0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc,
0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4, 0x3c, 0xbc, 0x7c, 0xfc, 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, 0x0a, 0x8a, 0x4a, 0xca,
0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6,
0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, 0x36, 0xb6, 0x76, 0xf6, 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 0x01, 0x81, 0x41, 0xc1,
0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9,
0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6, 0x39, 0xb9, 0x79, 0xf9, 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, 0x0d, 0x8d, 0x4d, 0xcd,
0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3,
0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1, 0x33, 0xb3, 0x73, 0xf3, 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, 0x07, 0x87, 0x47, 0xc7,
0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf,
0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, 0x3f, 0xbf, 0x7f, 0xff};
0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff
};
static const unsigned char TIFFNoBitRevTable[256] = { static const unsigned char TIFFNoBitRevTable[256] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53,
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83,
0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb,
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3,
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xfc, 0xfd, 0xfe, 0xff,
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
}; };
const unsigned char* const unsigned char *TIFFGetBitRevTable(int reversed)
TIFFGetBitRevTable(int reversed)
{ {
return (reversed ? TIFFBitRevTable : TIFFNoBitRevTable); return (reversed ? TIFFBitRevTable : TIFFNoBitRevTable);
} }
void void TIFFReverseBits(uint8_t *cp, tmsize_t n)
TIFFReverseBits(uint8_t* cp, tmsize_t n)
{ {
for (; n > 8; n -= 8) { for (; n > 8; n -= 8)
cp[0] = TIFFBitRevTable[cp[0]]; {
cp[1] = TIFFBitRevTable[cp[1]]; cp[0] = TIFFBitRevTable[cp[0]];
cp[2] = TIFFBitRevTable[cp[2]]; cp[1] = TIFFBitRevTable[cp[1]];
cp[3] = TIFFBitRevTable[cp[3]]; cp[2] = TIFFBitRevTable[cp[2]];
cp[4] = TIFFBitRevTable[cp[4]]; cp[3] = TIFFBitRevTable[cp[3]];
cp[5] = TIFFBitRevTable[cp[5]]; cp[4] = TIFFBitRevTable[cp[4]];
cp[6] = TIFFBitRevTable[cp[6]]; cp[5] = TIFFBitRevTable[cp[5]];
cp[7] = TIFFBitRevTable[cp[7]]; cp[6] = TIFFBitRevTable[cp[6]];
cp += 8; cp[7] = TIFFBitRevTable[cp[7]];
} cp += 8;
while (n-- > 0) { }
*cp = TIFFBitRevTable[*cp]; while (n-- > 0)
cp++; {
} *cp = TIFFBitRevTable[*cp];
cp++;
}
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

285
libs/tiff/libtiff/tif_thunder.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -41,157 +41,158 @@
* or 3-bit delta values are used, with the deltas packed * or 3-bit delta values are used, with the deltas packed
* into a single byte. * into a single byte.
*/ */
#define THUNDER_DATA 0x3f /* mask for 6-bit data */ #define THUNDER_DATA 0x3f /* mask for 6-bit data */
#define THUNDER_CODE 0xc0 /* mask for 2-bit code word */ #define THUNDER_CODE 0xc0 /* mask for 2-bit code word */
/* code values */ /* code values */
#define THUNDER_RUN 0x00 /* run of pixels w/ encoded count */ #define THUNDER_RUN 0x00 /* run of pixels w/ encoded count */
#define THUNDER_2BITDELTAS 0x40 /* 3 pixels w/ encoded 2-bit deltas */ #define THUNDER_2BITDELTAS 0x40 /* 3 pixels w/ encoded 2-bit deltas */
#define DELTA2_SKIP 2 /* skip code for 2-bit deltas */ #define DELTA2_SKIP 2 /* skip code for 2-bit deltas */
#define THUNDER_3BITDELTAS 0x80 /* 2 pixels w/ encoded 3-bit deltas */ #define THUNDER_3BITDELTAS 0x80 /* 2 pixels w/ encoded 3-bit deltas */
#define DELTA3_SKIP 4 /* skip code for 3-bit deltas */ #define DELTA3_SKIP 4 /* skip code for 3-bit deltas */
#define THUNDER_RAW 0xc0 /* raw data encoded */ #define THUNDER_RAW 0xc0 /* raw data encoded */
static const int twobitdeltas[4] = { 0, 1, 0, -1 }; static const int twobitdeltas[4] = {0, 1, 0, -1};
static const int threebitdeltas[8] = { 0, 1, 2, 3, 0, -3, -2, -1 }; static const int threebitdeltas[8] = {0, 1, 2, 3, 0, -3, -2, -1};
#define SETPIXEL(op, v) { \ #define SETPIXEL(op, v) \
lastpixel = (v) & 0xf; \ { \
if ( npixels < maxpixels ) \ lastpixel = (v)&0xf; \
{ \ if (npixels < maxpixels) \
if (npixels++ & 1) \ { \
*op++ |= lastpixel; \ if (npixels++ & 1) \
else \ *op++ |= lastpixel; \
op[0] = (uint8_t) (lastpixel << 4); \ else \
} \ op[0] = (uint8_t)(lastpixel << 4); \
} \
}
static int ThunderSetupDecode(TIFF *tif)
{
static const char module[] = "ThunderSetupDecode";
if (tif->tif_dir.td_bitspersample != 4)
{
TIFFErrorExtR(tif, module,
"Wrong bitspersample value (%d), Thunder decoder only "
"supports 4bits per sample.",
(int)tif->tif_dir.td_bitspersample);
return 0;
}
return (1);
} }
static int static int ThunderDecode(TIFF *tif, uint8_t *op, tmsize_t maxpixels)
ThunderSetupDecode(TIFF* tif)
{ {
static const char module[] = "ThunderSetupDecode"; static const char module[] = "ThunderDecode";
register unsigned char *bp;
register tmsize_t cc;
unsigned int lastpixel;
tmsize_t npixels;
if( tif->tif_dir.td_bitspersample != 4 ) bp = (unsigned char *)tif->tif_rawcp;
cc = tif->tif_rawcc;
lastpixel = 0;
npixels = 0;
while (cc > 0 && npixels < maxpixels)
{
int n, delta;
n = *bp++;
cc--;
switch (n & THUNDER_CODE)
{ {
TIFFErrorExt(tif->tif_clientdata, module, case THUNDER_RUN: /* pixel run */
"Wrong bitspersample value (%d), Thunder decoder only supports 4bits per sample.", /*
(int) tif->tif_dir.td_bitspersample ); * Replicate the last pixel n times,
return 0; * where n is the lower-order 6 bits.
*/
if (npixels & 1)
{
op[0] |= lastpixel;
lastpixel = *op++;
npixels++;
n--;
}
else
lastpixel |= lastpixel << 4;
npixels += n;
if (npixels < maxpixels)
{
for (; n > 0; n -= 2)
*op++ = (uint8_t)lastpixel;
}
if (n == -1)
*--op &= 0xf0;
lastpixel &= 0xf;
break;
case THUNDER_2BITDELTAS: /* 2-bit deltas */
if ((delta = ((n >> 4) & 3)) != DELTA2_SKIP)
SETPIXEL(op,
(unsigned)((int)lastpixel + twobitdeltas[delta]));
if ((delta = ((n >> 2) & 3)) != DELTA2_SKIP)
SETPIXEL(op,
(unsigned)((int)lastpixel + twobitdeltas[delta]));
if ((delta = (n & 3)) != DELTA2_SKIP)
SETPIXEL(op,
(unsigned)((int)lastpixel + twobitdeltas[delta]));
break;
case THUNDER_3BITDELTAS: /* 3-bit deltas */
if ((delta = ((n >> 3) & 7)) != DELTA3_SKIP)
SETPIXEL(
op, (unsigned)((int)lastpixel + threebitdeltas[delta]));
if ((delta = (n & 7)) != DELTA3_SKIP)
SETPIXEL(
op, (unsigned)((int)lastpixel + threebitdeltas[delta]));
break;
case THUNDER_RAW: /* raw data */
SETPIXEL(op, n);
break;
} }
}
tif->tif_rawcp = (uint8_t *)bp;
tif->tif_rawcc = cc;
if (npixels != maxpixels)
{
TIFFErrorExtR(tif, module,
"%s data at scanline %lu (%" PRIu64 " != %" PRIu64 ")",
npixels < maxpixels ? "Not enough" : "Too much",
(unsigned long)tif->tif_row, (uint64_t)npixels,
(uint64_t)maxpixels);
return (0);
}
return (1); return (1);
} }
static int static int ThunderDecodeRow(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
ThunderDecode(TIFF* tif, uint8_t* op, tmsize_t maxpixels)
{ {
static const char module[] = "ThunderDecode"; static const char module[] = "ThunderDecodeRow";
register unsigned char *bp; uint8_t *row = buf;
register tmsize_t cc;
unsigned int lastpixel;
tmsize_t npixels;
bp = (unsigned char *)tif->tif_rawcp; (void)s;
cc = tif->tif_rawcc; if (occ % tif->tif_scanlinesize)
lastpixel = 0; {
npixels = 0; TIFFErrorExtR(tif, module, "Fractional scanlines cannot be read");
while (cc > 0 && npixels < maxpixels) { return (0);
int n, delta; }
while (occ > 0)
n = *bp++; {
cc--; if (!ThunderDecode(tif, row, tif->tif_dir.td_imagewidth))
switch (n & THUNDER_CODE) { return (0);
case THUNDER_RUN: /* pixel run */ occ -= tif->tif_scanlinesize;
/* row += tif->tif_scanlinesize;
* Replicate the last pixel n times, }
* where n is the lower-order 6 bits. return (1);
*/
if (npixels & 1) {
op[0] |= lastpixel;
lastpixel = *op++; npixels++; n--;
} else
lastpixel |= lastpixel << 4;
npixels += n;
if (npixels < maxpixels) {
for (; n > 0; n -= 2)
*op++ = (uint8_t) lastpixel;
}
if (n == -1)
*--op &= 0xf0;
lastpixel &= 0xf;
break;
case THUNDER_2BITDELTAS: /* 2-bit deltas */
if ((delta = ((n >> 4) & 3)) != DELTA2_SKIP)
SETPIXEL(op, (unsigned)((int)lastpixel + twobitdeltas[delta]));
if ((delta = ((n >> 2) & 3)) != DELTA2_SKIP)
SETPIXEL(op, (unsigned)((int)lastpixel + twobitdeltas[delta]));
if ((delta = (n & 3)) != DELTA2_SKIP)
SETPIXEL(op, (unsigned)((int)lastpixel + twobitdeltas[delta]));
break;
case THUNDER_3BITDELTAS: /* 3-bit deltas */
if ((delta = ((n >> 3) & 7)) != DELTA3_SKIP)
SETPIXEL(op, (unsigned)((int)lastpixel + threebitdeltas[delta]));
if ((delta = (n & 7)) != DELTA3_SKIP)
SETPIXEL(op, (unsigned)((int)lastpixel + threebitdeltas[delta]));
break;
case THUNDER_RAW: /* raw data */
SETPIXEL(op, n);
break;
}
}
tif->tif_rawcp = (uint8_t*) bp;
tif->tif_rawcc = cc;
if (npixels != maxpixels) {
TIFFErrorExt(tif->tif_clientdata, module,
"%s data at scanline %lu (%"PRIu64" != %"PRIu64")",
npixels < maxpixels ? "Not enough" : "Too much",
(unsigned long) tif->tif_row,
(uint64_t) npixels,
(uint64_t) maxpixels);
return (0);
}
return (1);
} }
static int int TIFFInitThunderScan(TIFF *tif, int scheme)
ThunderDecodeRow(TIFF* tif, uint8_t* buf, tmsize_t occ, uint16_t s)
{ {
static const char module[] = "ThunderDecodeRow"; (void)scheme;
uint8_t* row = buf;
(void) s;
if (occ % tif->tif_scanlinesize)
{
TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read");
return (0);
}
while (occ > 0) {
if (!ThunderDecode(tif, row, tif->tif_dir.td_imagewidth))
return (0);
occ -= tif->tif_scanlinesize;
row += tif->tif_scanlinesize;
}
return (1);
}
int tif->tif_setupdecode = ThunderSetupDecode;
TIFFInitThunderScan(TIFF* tif, int scheme) tif->tif_decoderow = ThunderDecodeRow;
{ tif->tif_decodestrip = ThunderDecodeRow;
(void) scheme; return (1);
tif->tif_setupdecode = ThunderSetupDecode;
tif->tif_decoderow = ThunderDecodeRow;
tif->tif_decodestrip = ThunderDecodeRow;
return (1);
} }
#endif /* THUNDER_SUPPORT */ #endif /* THUNDER_SUPPORT */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

415
libs/tiff/libtiff/tif_tile.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1991-1997 Sam Leffler * Copyright (c) 1991-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -32,234 +32,230 @@
/* /*
* Compute which tile an (x,y,z,s) value is in. * Compute which tile an (x,y,z,s) value is in.
*/ */
uint32_t uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z,
TIFFComputeTile(TIFF* tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s) uint16_t s)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint32_t dx = td->td_tilewidth; uint32_t dx = td->td_tilewidth;
uint32_t dy = td->td_tilelength; uint32_t dy = td->td_tilelength;
uint32_t dz = td->td_tiledepth; uint32_t dz = td->td_tiledepth;
uint32_t tile = 1; uint32_t tile = 1;
if (td->td_imagedepth == 1) if (td->td_imagedepth == 1)
z = 0; z = 0;
if (dx == (uint32_t) -1) if (dx == (uint32_t)-1)
dx = td->td_imagewidth; dx = td->td_imagewidth;
if (dy == (uint32_t) -1) if (dy == (uint32_t)-1)
dy = td->td_imagelength; dy = td->td_imagelength;
if (dz == (uint32_t) -1) if (dz == (uint32_t)-1)
dz = td->td_imagedepth; dz = td->td_imagedepth;
if (dx != 0 && dy != 0 && dz != 0) { if (dx != 0 && dy != 0 && dz != 0)
uint32_t xpt = TIFFhowmany_32(td->td_imagewidth, dx); {
uint32_t ypt = TIFFhowmany_32(td->td_imagelength, dy); uint32_t xpt = TIFFhowmany_32(td->td_imagewidth, dx);
uint32_t zpt = TIFFhowmany_32(td->td_imagedepth, dz); uint32_t ypt = TIFFhowmany_32(td->td_imagelength, dy);
uint32_t zpt = TIFFhowmany_32(td->td_imagedepth, dz);
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
tile = (xpt*ypt*zpt)*s + tile = (xpt * ypt * zpt) * s + (xpt * ypt) * (z / dz) +
(xpt*ypt)*(z/dz) + xpt * (y / dy) + x / dx;
xpt*(y/dy) + else
x/dx; tile = (xpt * ypt) * (z / dz) + xpt * (y / dy) + x / dx;
else }
tile = (xpt*ypt)*(z/dz) + xpt*(y/dy) + x/dx; return (tile);
}
return (tile);
} }
/* /*
* Check an (x,y,z,s) coordinate * Check an (x,y,z,s) coordinate
* against the image bounds. * against the image bounds.
*/ */
int int TIFFCheckTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
TIFFCheckTile(TIFF* tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
if (x >= td->td_imagewidth) { if (x >= td->td_imagewidth)
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, {
"%lu: Col out of range, max %lu", TIFFErrorExtR(tif, tif->tif_name, "%lu: Col out of range, max %lu",
(unsigned long) x, (unsigned long)x, (unsigned long)(td->td_imagewidth - 1));
(unsigned long) (td->td_imagewidth - 1)); return (0);
return (0); }
} if (y >= td->td_imagelength)
if (y >= td->td_imagelength) { {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, TIFFErrorExtR(tif, tif->tif_name, "%lu: Row out of range, max %lu",
"%lu: Row out of range, max %lu", (unsigned long)y,
(unsigned long) y, (unsigned long)(td->td_imagelength - 1));
(unsigned long) (td->td_imagelength - 1)); return (0);
return (0); }
} if (z >= td->td_imagedepth)
if (z >= td->td_imagedepth) { {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, TIFFErrorExtR(tif, tif->tif_name, "%lu: Depth out of range, max %lu",
"%lu: Depth out of range, max %lu", (unsigned long)z, (unsigned long)(td->td_imagedepth - 1));
(unsigned long) z, return (0);
(unsigned long) (td->td_imagedepth - 1)); }
return (0); if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
} s >= td->td_samplesperpixel)
if (td->td_planarconfig == PLANARCONFIG_SEPARATE && {
s >= td->td_samplesperpixel) { TIFFErrorExtR(tif, tif->tif_name, "%lu: Sample out of range, max %lu",
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, (unsigned long)s,
"%lu: Sample out of range, max %lu", (unsigned long)(td->td_samplesperpixel - 1));
(unsigned long) s, return (0);
(unsigned long) (td->td_samplesperpixel - 1)); }
return (0); return (1);
}
return (1);
} }
/* /*
* Compute how many tiles are in an image. * Compute how many tiles are in an image.
*/ */
uint32_t uint32_t TIFFNumberOfTiles(TIFF *tif)
TIFFNumberOfTiles(TIFF* tif)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint32_t dx = td->td_tilewidth; uint32_t dx = td->td_tilewidth;
uint32_t dy = td->td_tilelength; uint32_t dy = td->td_tilelength;
uint32_t dz = td->td_tiledepth; uint32_t dz = td->td_tiledepth;
uint32_t ntiles; uint32_t ntiles;
if (dx == (uint32_t) -1) if (dx == (uint32_t)-1)
dx = td->td_imagewidth; dx = td->td_imagewidth;
if (dy == (uint32_t) -1) if (dy == (uint32_t)-1)
dy = td->td_imagelength; dy = td->td_imagelength;
if (dz == (uint32_t) -1) if (dz == (uint32_t)-1)
dz = td->td_imagedepth; dz = td->td_imagedepth;
ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 : ntiles =
_TIFFMultiply32(tif, _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx), (dx == 0 || dy == 0 || dz == 0)
TIFFhowmany_32(td->td_imagelength, dy), ? 0
"TIFFNumberOfTiles"), : _TIFFMultiply32(
TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles"); tif,
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel, TIFFhowmany_32(td->td_imagelength, dy),
"TIFFNumberOfTiles"); "TIFFNumberOfTiles"),
return (ntiles); TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
"TIFFNumberOfTiles");
return (ntiles);
} }
/* /*
* Compute the # bytes in each row of a tile. * Compute the # bytes in each row of a tile.
*/ */
uint64_t uint64_t TIFFTileRowSize64(TIFF *tif)
TIFFTileRowSize64(TIFF* tif)
{ {
static const char module[] = "TIFFTileRowSize64"; static const char module[] = "TIFFTileRowSize64";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint64_t rowsize; uint64_t rowsize;
uint64_t tilerowsize; uint64_t tilerowsize;
if (td->td_tilelength == 0) if (td->td_tilelength == 0)
{
TIFFErrorExtR(tif, module, "Tile length is zero");
return 0;
}
if (td->td_tilewidth == 0)
{
TIFFErrorExtR(tif, module, "Tile width is zero");
return (0);
}
rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
"TIFFTileRowSize");
if (td->td_planarconfig == PLANARCONFIG_CONTIG)
{
if (td->td_samplesperpixel == 0)
{ {
TIFFErrorExt(tif->tif_clientdata,module,"Tile length is zero"); TIFFErrorExtR(tif, module, "Samples per pixel is zero");
return 0; return 0;
} }
if (td->td_tilewidth == 0) rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
{ "TIFFTileRowSize");
TIFFErrorExt(tif->tif_clientdata,module,"Tile width is zero"); }
return (0); tilerowsize = TIFFhowmany8_64(rowsize);
} if (tilerowsize == 0)
rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth, {
"TIFFTileRowSize"); TIFFErrorExtR(tif, module, "Computed tile row size is zero");
if (td->td_planarconfig == PLANARCONFIG_CONTIG) return 0;
{ }
if (td->td_samplesperpixel == 0) return (tilerowsize);
{
TIFFErrorExt(tif->tif_clientdata,module,"Samples per pixel is zero");
return 0;
}
rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
"TIFFTileRowSize");
}
tilerowsize=TIFFhowmany8_64(rowsize);
if (tilerowsize == 0)
{
TIFFErrorExt(tif->tif_clientdata,module,"Computed tile row size is zero");
return 0;
}
return (tilerowsize);
} }
tmsize_t tmsize_t TIFFTileRowSize(TIFF *tif)
TIFFTileRowSize(TIFF* tif)
{ {
static const char module[] = "TIFFTileRowSize"; static const char module[] = "TIFFTileRowSize";
uint64_t m; uint64_t m;
m=TIFFTileRowSize64(tif); m = TIFFTileRowSize64(tif);
return _TIFFCastUInt64ToSSize(tif, m, module); return _TIFFCastUInt64ToSSize(tif, m, module);
} }
/* /*
* Compute the # bytes in a variable length, row-aligned tile. * Compute the # bytes in a variable length, row-aligned tile.
*/ */
uint64_t uint64_t TIFFVTileSize64(TIFF *tif, uint32_t nrows)
TIFFVTileSize64(TIFF* tif, uint32_t nrows)
{ {
static const char module[] = "TIFFVTileSize64"; static const char module[] = "TIFFVTileSize64";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
if (td->td_tilelength == 0 || td->td_tilewidth == 0 || if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
td->td_tiledepth == 0) td->td_tiledepth == 0)
return (0); return (0);
if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&& if ((td->td_planarconfig == PLANARCONFIG_CONTIG) &&
(td->td_photometric==PHOTOMETRIC_YCBCR)&& (td->td_photometric == PHOTOMETRIC_YCBCR) &&
(td->td_samplesperpixel==3)&& (td->td_samplesperpixel == 3) && (!isUpSampled(tif)))
(!isUpSampled(tif))) {
{ /*
/* * Packed YCbCr data contain one Cb+Cr for every
* Packed YCbCr data contain one Cb+Cr for every * HorizontalSampling*VerticalSampling Y values.
* HorizontalSampling*VerticalSampling Y values. * Must also roundup width and height when calculating
* Must also roundup width and height when calculating * since images that are not a multiple of the
* since images that are not a multiple of the * horizontal/vertical subsampling area include
* horizontal/vertical subsampling area include * YCbCr data for the extended image.
* YCbCr data for the extended image. */
*/ uint16_t ycbcrsubsampling[2];
uint16_t ycbcrsubsampling[2]; uint16_t samplingblock_samples;
uint16_t samplingblock_samples; uint32_t samplingblocks_hor;
uint32_t samplingblocks_hor; uint32_t samplingblocks_ver;
uint32_t samplingblocks_ver; uint64_t samplingrow_samples;
uint64_t samplingrow_samples; uint64_t samplingrow_size;
uint64_t samplingrow_size; TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0, ycbcrsubsampling + 0, ycbcrsubsampling + 1);
ycbcrsubsampling+1); if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4) ycbcrsubsampling[0] != 4) ||
||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4)) (ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
{ ycbcrsubsampling[1] != 4))
TIFFErrorExt(tif->tif_clientdata,module, {
"Invalid YCbCr subsampling (%dx%d)", TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling (%dx%d)",
ycbcrsubsampling[0], ycbcrsubsampling[0], ycbcrsubsampling[1]);
ycbcrsubsampling[1] ); return 0;
return 0; }
} samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2; samplingblocks_hor =
samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampling[0]); TIFFhowmany_32(td->td_tilewidth, ycbcrsubsampling[0]);
samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]); samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module); samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module)); samplingblock_samples, module);
return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module)); samplingrow_size = TIFFhowmany8_64(_TIFFMultiply64(
} tif, samplingrow_samples, td->td_bitspersample, module));
else return (
return(_TIFFMultiply64(tif,nrows,TIFFTileRowSize64(tif),module)); _TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
}
else
return (_TIFFMultiply64(tif, nrows, TIFFTileRowSize64(tif), module));
} }
tmsize_t tmsize_t TIFFVTileSize(TIFF *tif, uint32_t nrows)
TIFFVTileSize(TIFF* tif, uint32_t nrows)
{ {
static const char module[] = "TIFFVTileSize"; static const char module[] = "TIFFVTileSize";
uint64_t m; uint64_t m;
m=TIFFVTileSize64(tif,nrows); m = TIFFVTileSize64(tif, nrows);
return _TIFFCastUInt64ToSSize(tif, m, module); return _TIFFCastUInt64ToSSize(tif, m, module);
} }
/* /*
* Compute the # bytes in a row-aligned tile. * Compute the # bytes in a row-aligned tile.
*/ */
uint64_t uint64_t TIFFTileSize64(TIFF *tif)
TIFFTileSize64(TIFF* tif)
{ {
return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength)); return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
} }
tmsize_t tmsize_t TIFFTileSize(TIFF *tif)
TIFFTileSize(TIFF* tif)
{ {
static const char module[] = "TIFFTileSize"; static const char module[] = "TIFFTileSize";
uint64_t m; uint64_t m;
m=TIFFTileSize64(tif); m = TIFFTileSize64(tif);
return _TIFFCastUInt64ToSSize(tif, m, module); return _TIFFCastUInt64ToSSize(tif, m, module);
} }
/* /*
@ -268,32 +264,21 @@ TIFFTileSize(TIFF* tif)
* request is <1 then we choose a size according * request is <1 then we choose a size according
* to certain heuristics. * to certain heuristics.
*/ */
void void TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th)
TIFFDefaultTileSize(TIFF* tif, uint32_t* tw, uint32_t* th)
{ {
(*tif->tif_deftilesize)(tif, tw, th); (*tif->tif_deftilesize)(tif, tw, th);
} }
void void _TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th)
_TIFFDefaultTileSize(TIFF* tif, uint32_t* tw, uint32_t* th)
{ {
(void) tif; (void)tif;
if (*(int32_t*) tw < 1) if (*(int32_t *)tw < 1)
*tw = 256; *tw = 256;
if (*(int32_t*) th < 1) if (*(int32_t *)th < 1)
*th = 256; *th = 256;
/* roundup to a multiple of 16 per the spec */ /* roundup to a multiple of 16 per the spec */
if (*tw & 0xf) if (*tw & 0xf)
*tw = TIFFroundup_32(*tw, 16); *tw = TIFFroundup_32(*tw, 16);
if (*th & 0xf) if (*th & 0xf)
*th = TIFFroundup_32(*th, 16); *th = TIFFroundup_32(*th, 16);
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

122
libs/tiff/libtiff/tif_warning.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -29,59 +29,77 @@
TIFFErrorHandlerExt _TIFFwarningHandlerExt = NULL; TIFFErrorHandlerExt _TIFFwarningHandlerExt = NULL;
TIFFErrorHandler TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler handler)
TIFFSetWarningHandler(TIFFErrorHandler handler)
{ {
TIFFErrorHandler prev = _TIFFwarningHandler; TIFFErrorHandler prev = _TIFFwarningHandler;
_TIFFwarningHandler = handler; _TIFFwarningHandler = handler;
return (prev); return (prev);
} }
TIFFErrorHandlerExt TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt handler)
TIFFSetWarningHandlerExt(TIFFErrorHandlerExt handler)
{ {
TIFFErrorHandlerExt prev = _TIFFwarningHandlerExt; TIFFErrorHandlerExt prev = _TIFFwarningHandlerExt;
_TIFFwarningHandlerExt = handler; _TIFFwarningHandlerExt = handler;
return (prev); return (prev);
} }
void void TIFFWarning(const char *module, const char *fmt, ...)
TIFFWarning(const char* module, const char* fmt, ...)
{ {
va_list ap; va_list ap;
if (_TIFFwarningHandler) { if (_TIFFwarningHandler)
va_start(ap, fmt); {
(*_TIFFwarningHandler)(module, fmt, ap); va_start(ap, fmt);
va_end(ap); (*_TIFFwarningHandler)(module, fmt, ap);
} va_end(ap);
if (_TIFFwarningHandlerExt) { }
va_start(ap, fmt); if (_TIFFwarningHandlerExt)
(*_TIFFwarningHandlerExt)(0, module, fmt, ap); {
va_end(ap); va_start(ap, fmt);
} (*_TIFFwarningHandlerExt)(0, module, fmt, ap);
va_end(ap);
}
} }
void void TIFFWarningExt(thandle_t fd, const char *module, const char *fmt, ...)
TIFFWarningExt(thandle_t fd, const char* module, const char* fmt, ...)
{ {
va_list ap; va_list ap;
if (_TIFFwarningHandler) { if (_TIFFwarningHandler)
va_start(ap, fmt); {
(*_TIFFwarningHandler)(module, fmt, ap); va_start(ap, fmt);
va_end(ap); (*_TIFFwarningHandler)(module, fmt, ap);
} va_end(ap);
if (_TIFFwarningHandlerExt) { }
va_start(ap, fmt); if (_TIFFwarningHandlerExt)
(*_TIFFwarningHandlerExt)(fd, module, fmt, ap); {
va_end(ap); va_start(ap, fmt);
} (*_TIFFwarningHandlerExt)(fd, module, fmt, ap);
va_end(ap);
}
} }
void TIFFWarningExtR(TIFF *tif, const char *module, const char *fmt, ...)
/* {
* Local Variables: va_list ap;
* mode: c if (tif && tif->tif_warnhandler)
* c-basic-offset: 8 {
* fill-column: 78 va_start(ap, fmt);
* End: int stop = (*tif->tif_warnhandler)(tif, tif->tif_warnhandler_user_data,
*/ module, fmt, ap);
va_end(ap);
if (stop)
return;
}
if (_TIFFwarningHandler)
{
va_start(ap, fmt);
(*_TIFFwarningHandler)(module, fmt, ap);
va_end(ap);
}
if (_TIFFwarningHandlerExt)
{
va_start(ap, fmt);
(*_TIFFwarningHandlerExt)(tif ? tif->tif_clientdata : 0, module, fmt,
ap);
va_end(ap);
}
}

588
libs/tiff/libtiff/tif_win32.c
View file

@ -2,23 +2,23 @@
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
* Copyright (c) 1991-1997 Silicon Graphics, Inc. * Copyright (c) 1991-1997 Silicon Graphics, Inc.
* *
* Permission to use, copy, modify, distribute, and sell this software and * Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided * its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in * 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 * 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 * Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written * publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics. * permission of Sam Leffler and Silicon Graphics.
* *
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
* *
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, * 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 * 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 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE. * OF THIS SOFTWARE.
*/ */
@ -55,121 +55,111 @@ static inline thandle_t thandle_from_int(int ifd)
return (thandle_t)(intptr_t)ifd; return (thandle_t)(intptr_t)ifd;
} }
static inline int thandle_to_int(thandle_t fd) static inline int thandle_to_int(thandle_t fd) { return (int)(intptr_t)fd; }
static tmsize_t _tiffReadProc(thandle_t fd, void *buf, tmsize_t size)
{ {
return (int)(intptr_t)fd; /* tmsize_t is 64bit on 64bit systems, but the WinAPI ReadFile takes
* 32bit sizes, so we loop through the data in suitable 32bit sized
* chunks */
uint8_t *ma;
uint64_t mb;
DWORD n;
DWORD o;
tmsize_t p;
ma = (uint8_t *)buf;
mb = size;
p = 0;
while (mb > 0)
{
n = 0x80000000UL;
if ((uint64_t)n > mb)
n = (DWORD)mb;
if (!ReadFile(fd, (LPVOID)ma, n, &o, NULL))
return (0);
ma += o;
mb -= o;
p += o;
if (o != n)
break;
}
return (p);
} }
static tmsize_t static tmsize_t _tiffWriteProc(thandle_t fd, void *buf, tmsize_t size)
_tiffReadProc(thandle_t fd, void* buf, tmsize_t size)
{ {
/* tmsize_t is 64bit on 64bit systems, but the WinAPI ReadFile takes /* tmsize_t is 64bit on 64bit systems, but the WinAPI WriteFile takes
* 32bit sizes, so we loop through the data in suitable 32bit sized * 32bit sizes, so we loop through the data in suitable 32bit sized
* chunks */ * chunks */
uint8_t* ma; uint8_t *ma;
uint64_t mb; uint64_t mb;
DWORD n; DWORD n;
DWORD o; DWORD o;
tmsize_t p; tmsize_t p;
ma=(uint8_t*)buf; ma = (uint8_t *)buf;
mb=size; mb = size;
p=0; p = 0;
while (mb>0) while (mb > 0)
{ {
n=0x80000000UL; n = 0x80000000UL;
if ((uint64_t)n>mb) if ((uint64_t)n > mb)
n=(DWORD)mb; n = (DWORD)mb;
if (!ReadFile(fd,(LPVOID)ma,n,&o,NULL)) if (!WriteFile(fd, (LPVOID)ma, n, &o, NULL))
return(0); return (0);
ma+=o; ma += o;
mb-=o; mb -= o;
p+=o; p += o;
if (o!=n) if (o != n)
break; break;
} }
return(p); return (p);
} }
static tmsize_t static uint64_t _tiffSeekProc(thandle_t fd, uint64_t off, int whence)
_tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)
{ {
/* tmsize_t is 64bit on 64bit systems, but the WinAPI WriteFile takes LARGE_INTEGER offli;
* 32bit sizes, so we loop through the data in suitable 32bit sized DWORD dwMoveMethod;
* chunks */ offli.QuadPart = off;
uint8_t* ma; switch (whence)
uint64_t mb; {
DWORD n; case SEEK_SET:
DWORD o; dwMoveMethod = FILE_BEGIN;
tmsize_t p; break;
ma=(uint8_t*)buf; case SEEK_CUR:
mb=size; dwMoveMethod = FILE_CURRENT;
p=0; break;
while (mb>0) case SEEK_END:
{ dwMoveMethod = FILE_END;
n=0x80000000UL; break;
if ((uint64_t)n>mb) default:
n=(DWORD)mb; dwMoveMethod = FILE_BEGIN;
if (!WriteFile(fd,(LPVOID)ma,n,&o,NULL)) break;
return(0); }
ma+=o; offli.LowPart =
mb-=o; SetFilePointer(fd, offli.LowPart, &offli.HighPart, dwMoveMethod);
p+=o; if ((offli.LowPart == INVALID_SET_FILE_POINTER) &&
if (o!=n) (GetLastError() != NO_ERROR))
break; offli.QuadPart = 0;
} return (offli.QuadPart);
return(p);
} }
static uint64_t static int _tiffCloseProc(thandle_t fd) { return (CloseHandle(fd) ? 0 : -1); }
_tiffSeekProc(thandle_t fd, uint64_t off, int whence)
static uint64_t _tiffSizeProc(thandle_t fd)
{ {
LARGE_INTEGER offli; LARGE_INTEGER m;
DWORD dwMoveMethod; if (GetFileSizeEx(fd, &m))
offli.QuadPart = off; return (m.QuadPart);
switch(whence) else
{ return (0);
case SEEK_SET:
dwMoveMethod = FILE_BEGIN;
break;
case SEEK_CUR:
dwMoveMethod = FILE_CURRENT;
break;
case SEEK_END:
dwMoveMethod = FILE_END;
break;
default:
dwMoveMethod = FILE_BEGIN;
break;
}
offli.LowPart=SetFilePointer(fd,offli.LowPart,&offli.HighPart,dwMoveMethod);
if ((offli.LowPart==INVALID_SET_FILE_POINTER)&&(GetLastError()!=NO_ERROR))
offli.QuadPart=0;
return(offli.QuadPart);
} }
static int static int _tiffDummyMapProc(thandle_t fd, void **pbase, toff_t *psize)
_tiffCloseProc(thandle_t fd)
{ {
return (CloseHandle(fd) ? 0 : -1); (void)fd;
} (void)pbase;
(void)psize;
static uint64_t return (0);
_tiffSizeProc(thandle_t fd)
{
LARGE_INTEGER m;
if (GetFileSizeEx(fd,&m))
return(m.QuadPart);
else
return(0);
}
static int
_tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
{
(void) fd;
(void) pbase;
(void) psize;
return (0);
} }
/* /*
@ -183,45 +173,42 @@ _tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
* This removes a nasty OS dependency and cures a problem * This removes a nasty OS dependency and cures a problem
* with Visual C++ 5.0 * with Visual C++ 5.0
*/ */
static int static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
{ {
uint64_t size; uint64_t size;
tmsize_t sizem; tmsize_t sizem;
HANDLE hMapFile; HANDLE hMapFile;
size = _tiffSizeProc(fd); size = _tiffSizeProc(fd);
sizem = (tmsize_t)size; sizem = (tmsize_t)size;
if (!size || (uint64_t)sizem!=size) if (!size || (uint64_t)sizem != size)
return (0); return (0);
/* By passing in 0 for the maximum file size, it specifies that we /* By passing in 0 for the maximum file size, it specifies that we
create a file mapping object for the full file size. */ create a file mapping object for the full file size. */
hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, 0, NULL); hMapFile = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, 0, NULL);
if (hMapFile == NULL) if (hMapFile == NULL)
return (0); return (0);
*pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0); *pbase = MapViewOfFile(hMapFile, FILE_MAP_READ, 0, 0, 0);
CloseHandle(hMapFile); CloseHandle(hMapFile);
if (*pbase == NULL) if (*pbase == NULL)
return (0); return (0);
*psize = size; *psize = size;
return(1); return (1);
} }
static void static void _tiffDummyUnmapProc(thandle_t fd, void *base, toff_t size)
_tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size)
{ {
(void) fd; (void)fd;
(void) base; (void)base;
(void) size; (void)size;
} }
static void static void _tiffUnmapProc(thandle_t fd, void *base, toff_t size)
_tiffUnmapProc(thandle_t fd, void* base, toff_t size)
{ {
(void) fd; (void)fd;
(void) size; (void)size;
UnmapViewOfFile(base); UnmapViewOfFile(base);
} }
/* /*
@ -229,29 +216,36 @@ _tiffUnmapProc(thandle_t fd, void* base, toff_t size)
* Note that TIFFFdOpen and TIFFOpen recognise the character 'u' in the mode * Note that TIFFFdOpen and TIFFOpen recognise the character 'u' in the mode
* string, which forces the file to be opened unmapped. * string, which forces the file to be opened unmapped.
*/ */
TIFF* TIFF *TIFFFdOpen(int ifd, const char *name, const char *mode)
TIFFFdOpen(int ifd, const char* name, const char* mode)
{ {
TIFF* tif; return TIFFFdOpenExt(ifd, name, mode, NULL);
int fSuppressMap; }
int m;
fSuppressMap=0; TIFF *TIFFFdOpenExt(int ifd, const char *name, const char *mode,
for (m=0; mode[m]!=0; m++) TIFFOpenOptions *opts)
{ {
if (mode[m]=='u') TIFF *tif;
{ int fSuppressMap;
fSuppressMap=1; int m;
break;
} fSuppressMap = 0;
} for (m = 0; mode[m] != 0; m++)
tif = TIFFClientOpen(name, mode, thandle_from_int(ifd), {
_tiffReadProc, _tiffWriteProc, if (mode[m] == 'u')
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc, {
fSuppressMap ? _tiffDummyMapProc : _tiffMapProc, fSuppressMap = 1;
fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc); break;
if (tif) }
tif->tif_fd = ifd; }
return (tif);
tif = TIFFClientOpenExt(
name, mode, thandle_from_int(ifd), _tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
fSuppressMap ? _tiffDummyMapProc : _tiffMapProc,
fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc, opts);
if (tif)
tif->tif_fd = ifd;
return (tif);
} }
#ifndef _WIN32_WCE #ifndef _WIN32_WCE
@ -259,180 +253,190 @@ TIFFFdOpen(int ifd, const char* name, const char* mode)
/* /*
* Open a TIFF file for read/writing. * Open a TIFF file for read/writing.
*/ */
TIFF* TIFF *TIFFOpen(const char *name, const char *mode)
TIFFOpen(const char* name, const char* mode)
{ {
static const char module[] = "TIFFOpen"; return TIFFOpenExt(name, mode, NULL);
thandle_t fd; }
int m;
DWORD dwMode;
TIFF* tif;
m = _TIFFgetMode(mode, module); TIFF *TIFFOpenExt(const char *name, const char *mode, TIFFOpenOptions *opts)
{
static const char module[] = "TIFFOpen";
thandle_t fd;
int m;
DWORD dwMode;
TIFF *tif;
switch(m) { m = _TIFFgetMode(opts, NULL, mode, module);
case O_RDONLY: dwMode = OPEN_EXISTING; break;
case O_RDWR: dwMode = OPEN_ALWAYS; break;
case O_RDWR|O_CREAT: dwMode = OPEN_ALWAYS; break;
case O_RDWR|O_TRUNC: dwMode = CREATE_ALWAYS; break;
case O_RDWR|O_CREAT|O_TRUNC: dwMode = CREATE_ALWAYS; break;
default: return ((TIFF*)0);
}
fd = (thandle_t)CreateFileA(name,
(m == O_RDONLY)?GENERIC_READ:(GENERIC_READ | GENERIC_WRITE),
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
(m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL,
NULL);
if (fd == INVALID_HANDLE_VALUE) {
TIFFErrorExt(0, module, "%s: Cannot open", name);
return ((TIFF *)0);
}
tif = TIFFFdOpen(thandle_to_int(fd), name, mode); switch (m)
if(!tif) {
CloseHandle(fd); case O_RDONLY:
return tif; dwMode = OPEN_EXISTING;
break;
case O_RDWR:
dwMode = OPEN_ALWAYS;
break;
case O_RDWR | O_CREAT:
dwMode = OPEN_ALWAYS;
break;
case O_RDWR | O_TRUNC:
dwMode = CREATE_ALWAYS;
break;
case O_RDWR | O_CREAT | O_TRUNC:
dwMode = CREATE_ALWAYS;
break;
default:
return ((TIFF *)0);
}
fd = (thandle_t)CreateFileA(
name, (m == O_RDONLY) ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE),
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
(m == O_RDONLY) ? FILE_ATTRIBUTE_READONLY : FILE_ATTRIBUTE_NORMAL,
NULL);
if (fd == INVALID_HANDLE_VALUE)
{
_TIFFErrorEarly(opts, NULL, module, "%s: Cannot open", name);
return ((TIFF *)0);
}
tif = TIFFFdOpenExt(thandle_to_int(fd), name, mode, opts);
if (!tif)
CloseHandle(fd);
return tif;
} }
/* /*
* Open a TIFF file with a Unicode filename, for read/writing. * Open a TIFF file with a Unicode filename, for read/writing.
*/ */
TIFF* TIFF *TIFFOpenW(const wchar_t *name, const char *mode)
TIFFOpenW(const wchar_t* name, const char* mode)
{ {
static const char module[] = "TIFFOpenW"; return TIFFOpenWExt(name, mode, NULL);
thandle_t fd; }
int m;
DWORD dwMode;
int mbsize;
char *mbname;
TIFF *tif;
m = _TIFFgetMode(mode, module); TIFF *TIFFOpenWExt(const wchar_t *name, const char *mode, TIFFOpenOptions *opts)
{
static const char module[] = "TIFFOpenW";
thandle_t fd;
int m;
DWORD dwMode;
int mbsize;
char *mbname;
TIFF *tif;
switch(m) { m = _TIFFgetMode(opts, NULL, mode, module);
case O_RDONLY: dwMode = OPEN_EXISTING; break;
case O_RDWR: dwMode = OPEN_ALWAYS; break;
case O_RDWR|O_CREAT: dwMode = OPEN_ALWAYS; break;
case O_RDWR|O_TRUNC: dwMode = CREATE_ALWAYS; break;
case O_RDWR|O_CREAT|O_TRUNC: dwMode = CREATE_ALWAYS; break;
default: return ((TIFF*)0);
}
fd = (thandle_t)CreateFileW(name, switch (m)
(m == O_RDONLY)?GENERIC_READ:(GENERIC_READ|GENERIC_WRITE), {
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode, case O_RDONLY:
(m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL, dwMode = OPEN_EXISTING;
NULL); break;
if (fd == INVALID_HANDLE_VALUE) { case O_RDWR:
TIFFErrorExt(0, module, "%S: Cannot open", name); dwMode = OPEN_ALWAYS;
return ((TIFF *)0); break;
} case O_RDWR | O_CREAT:
dwMode = OPEN_ALWAYS;
break;
case O_RDWR | O_TRUNC:
dwMode = CREATE_ALWAYS;
break;
case O_RDWR | O_CREAT | O_TRUNC:
dwMode = CREATE_ALWAYS;
break;
default:
return ((TIFF *)0);
}
mbname = NULL; fd = (thandle_t)CreateFileW(
mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL); name, (m == O_RDONLY) ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE),
if (mbsize > 0) { FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
mbname = (char *)_TIFFmalloc(mbsize); (m == O_RDONLY) ? FILE_ATTRIBUTE_READONLY : FILE_ATTRIBUTE_NORMAL,
if (!mbname) { NULL);
TIFFErrorExt(0, module, if (fd == INVALID_HANDLE_VALUE)
"Can't allocate space for filename conversion buffer"); {
return ((TIFF*)0); _TIFFErrorEarly(opts, NULL, module, "%S: Cannot open", name);
} return ((TIFF *)0);
}
WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize, mbname = NULL;
NULL, NULL); mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
} if (mbsize > 0)
{
mbname = (char *)_TIFFmalloc(mbsize);
if (!mbname)
{
_TIFFErrorEarly(
opts, NULL, module,
"Can't allocate space for filename conversion buffer");
return ((TIFF *)0);
}
tif = TIFFFdOpen(thandle_to_int(fd), WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize, NULL, NULL);
(mbname != NULL) ? mbname : "<unknown>", mode); }
if(!tif)
CloseHandle(fd);
_TIFFfree(mbname); tif = TIFFFdOpenExt(thandle_to_int(fd),
(mbname != NULL) ? mbname : "<unknown>", mode, opts);
if (!tif)
CloseHandle(fd);
return tif; _TIFFfree(mbname);
return tif;
} }
#endif /* ndef _WIN32_WCE */ #endif /* ndef _WIN32_WCE */
void* void *_TIFFmalloc(tmsize_t s)
_TIFFmalloc(tmsize_t s)
{ {
if (s == 0) if (s == 0)
return ((void *) NULL); return ((void *)NULL);
return (malloc((size_t) s)); return (malloc((size_t)s));
} }
void* _TIFFcalloc(tmsize_t nmemb, tmsize_t siz) void *_TIFFcalloc(tmsize_t nmemb, tmsize_t siz)
{ {
if( nmemb == 0 || siz == 0 ) if (nmemb == 0 || siz == 0)
return ((void *) NULL); return ((void *)NULL);
return calloc((size_t) nmemb, (size_t)siz); return calloc((size_t)nmemb, (size_t)siz);
} }
void void _TIFFfree(void *p) { free(p); }
_TIFFfree(void* p)
void *_TIFFrealloc(void *p, tmsize_t s) { return (realloc(p, (size_t)s)); }
void _TIFFmemset(void *p, int v, tmsize_t c) { memset(p, v, (size_t)c); }
void _TIFFmemcpy(void *d, const void *s, tmsize_t c)
{ {
free(p); memcpy(d, s, (size_t)c);
} }
void* int _TIFFmemcmp(const void *p1, const void *p2, tmsize_t c)
_TIFFrealloc(void* p, tmsize_t s)
{ {
return (realloc(p, (size_t) s)); return (memcmp(p1, p2, (size_t)c));
}
void
_TIFFmemset(void* p, int v, tmsize_t c)
{
memset(p, v, (size_t) c);
}
void
_TIFFmemcpy(void* d, const void* s, tmsize_t c)
{
memcpy(d, s, (size_t) c);
}
int
_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
{
return (memcmp(p1, p2, (size_t) c));
} }
#ifndef _WIN32_WCE #ifndef _WIN32_WCE
static void static void Win32WarningHandler(const char *module, const char *fmt, va_list ap)
Win32WarningHandler(const char* module, const char* fmt, va_list ap)
{ {
if (module != NULL) if (module != NULL)
fprintf(stderr, "%s: ", module); fprintf(stderr, "%s: ", module);
fprintf(stderr, "Warning, "); fprintf(stderr, "Warning, ");
vfprintf(stderr, fmt, ap); vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n"); fprintf(stderr, ".\n");
} }
TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler; TIFFErrorHandler _TIFFwarningHandler = Win32WarningHandler;
static void static void Win32ErrorHandler(const char *module, const char *fmt, va_list ap)
Win32ErrorHandler(const char* module, const char* fmt, va_list ap)
{ {
if (module != NULL) if (module != NULL)
fprintf(stderr, "%s: ", module); fprintf(stderr, "%s: ", module);
vfprintf(stderr, fmt, ap); vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n"); fprintf(stderr, ".\n");
} }
TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler; TIFFErrorHandler _TIFFerrorHandler = Win32ErrorHandler;
#endif /* ndef _WIN32_WCE */ #endif /* ndef _WIN32_WCE */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

1324
libs/tiff/libtiff/tif_write.c
View file

File diff suppressed because it is too large Load diff

1055
libs/tiff/libtiff/tif_zip.c
View file

File diff suppressed because it is too large Load diff

1422
libs/tiff/libtiff/tiff.h
View file

File diff suppressed because it is too large Load diff

1
libs/tiff/libtiff/tiffconf.h
View file

@ -12,6 +12,7 @@
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <inttypes.h> #include <inttypes.h>
#include <sys/types.h>
/* Signed 16-bit type */ /* Signed 16-bit type */

825
libs/tiff/libtiff/tiffio.h
View file

@ -23,7 +23,7 @@
*/ */
#ifndef _TIFFIO_ #ifndef _TIFFIO_
#define _TIFFIO_ #define _TIFFIO_
/* /*
* TIFF I/O Library Definitions. * TIFF I/O Library Definitions.
@ -65,17 +65,17 @@ typedef struct tiff TIFF;
typedef TIFF_SSIZE_T tmsize_t; typedef TIFF_SSIZE_T tmsize_t;
#define TIFF_TMSIZE_T_MAX (tmsize_t)(SIZE_MAX >> 1) #define TIFF_TMSIZE_T_MAX (tmsize_t)(SIZE_MAX >> 1)
typedef uint64_t toff_t; /* file offset */ typedef uint64_t toff_t; /* file offset */
/* the following are deprecated and should be replaced by their defining /* the following are deprecated and should be replaced by their defining
counterparts */ counterparts */
typedef uint32_t ttag_t; /* directory tag */ typedef uint32_t ttag_t; /* directory tag */
typedef uint16_t tdir_t; /* directory index */ typedef uint32_t tdir_t; /* directory index */
typedef uint16_t tsample_t; /* sample number */ typedef uint16_t tsample_t; /* sample number */
typedef uint32_t tstrile_t; /* strip or tile number */ typedef uint32_t tstrile_t; /* strip or tile number */
typedef tstrile_t tstrip_t; /* strip number */ typedef tstrile_t tstrip_t; /* strip number */
typedef tstrile_t ttile_t; /* tile number */ typedef tstrile_t ttile_t; /* tile number */
typedef tmsize_t tsize_t; /* i/o size in bytes */ typedef tmsize_t tsize_t; /* i/o size in bytes */
typedef void* tdata_t; /* image data ref */ typedef void *tdata_t; /* image data ref */
#if !defined(__WIN32__) && (defined(_WIN32) || defined(WIN32)) #if !defined(__WIN32__) && (defined(_WIN32) || defined(WIN32))
#define __WIN32__ #define __WIN32__
@ -89,21 +89,22 @@ typedef void* tdata_t; /* image data ref */
*/ */
#if defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows) #if defined(_WINDOWS) || defined(__WIN32__) || defined(_Windows)
# if !defined(__CYGWIN) && !defined(AVOID_WIN32_FILEIO) && !defined(USE_WIN32_FILEIO) #if !defined(__CYGWIN) && !defined(AVOID_WIN32_FILEIO) && \
# define AVOID_WIN32_FILEIO !defined(USE_WIN32_FILEIO)
# endif #define AVOID_WIN32_FILEIO
#endif
#endif #endif
#if defined(USE_WIN32_FILEIO) #if defined(USE_WIN32_FILEIO)
# define VC_EXTRALEAN #define VC_EXTRALEAN
# include <windows.h> #include <windows.h>
# ifdef __WIN32__ #ifdef __WIN32__
DECLARE_HANDLE(thandle_t); /* Win32 file handle */ DECLARE_HANDLE(thandle_t); /* Win32 file handle */
# else
typedef HFILE thandle_t; /* client data handle */
# endif /* __WIN32__ */
#else #else
typedef void* thandle_t; /* client data handle */ typedef HFILE thandle_t; /* client data handle */
#endif /* __WIN32__ */
#else
typedef void *thandle_t; /* client data handle */
#endif /* USE_WIN32_FILEIO */ #endif /* USE_WIN32_FILEIO */
/* /*
@ -112,15 +113,15 @@ typedef void* thandle_t; /* client data handle */
* very large. Bit-or these flags to enable printing * very large. Bit-or these flags to enable printing
* multiple items. * multiple items.
*/ */
#define TIFFPRINT_NONE 0x0 /* no extra info */ #define TIFFPRINT_NONE 0x0 /* no extra info */
#define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */ #define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */
#define TIFFPRINT_CURVES 0x2 /* color/gray response curves */ #define TIFFPRINT_CURVES 0x2 /* color/gray response curves */
#define TIFFPRINT_COLORMAP 0x4 /* colormap */ #define TIFFPRINT_COLORMAP 0x4 /* colormap */
#define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */ #define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */
#define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */ #define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */
#define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */ #define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */
/* /*
* Colour conversion stuff * Colour conversion stuff
*/ */
@ -135,42 +136,45 @@ typedef void* thandle_t; /* client data handle */
/* Structure for holding information about a display device. */ /* Structure for holding information about a display device. */
typedef unsigned char TIFFRGBValue; /* 8-bit samples */ typedef unsigned char TIFFRGBValue; /* 8-bit samples */
typedef struct { typedef struct
float d_mat[3][3]; /* XYZ -> luminance matrix */ {
float d_YCR; /* Light o/p for reference white */ float d_mat[3][3]; /* XYZ -> luminance matrix */
float d_YCG; float d_YCR; /* Light o/p for reference white */
float d_YCB; float d_YCG;
uint32_t d_Vrwr; /* Pixel values for ref. white */ float d_YCB;
uint32_t d_Vrwg; uint32_t d_Vrwr; /* Pixel values for ref. white */
uint32_t d_Vrwb; uint32_t d_Vrwg;
float d_Y0R; /* Residual light for black pixel */ uint32_t d_Vrwb;
float d_Y0G; float d_Y0R; /* Residual light for black pixel */
float d_Y0B; float d_Y0G;
float d_gammaR; /* Gamma values for the three guns */ float d_Y0B;
float d_gammaG; float d_gammaR; /* Gamma values for the three guns */
float d_gammaB; float d_gammaG;
float d_gammaB;
} TIFFDisplay; } TIFFDisplay;
typedef struct { /* YCbCr->RGB support */ typedef struct
TIFFRGBValue* clamptab; /* range clamping table */ { /* YCbCr->RGB support */
int* Cr_r_tab; TIFFRGBValue *clamptab; /* range clamping table */
int* Cb_b_tab; int *Cr_r_tab;
int32_t* Cr_g_tab; int *Cb_b_tab;
int32_t* Cb_g_tab; int32_t *Cr_g_tab;
int32_t* Y_tab; int32_t *Cb_g_tab;
int32_t *Y_tab;
} TIFFYCbCrToRGB; } TIFFYCbCrToRGB;
typedef struct { /* CIE Lab 1976->RGB support */ typedef struct
int range; /* Size of conversion table */ { /* CIE Lab 1976->RGB support */
int range; /* Size of conversion table */
#define CIELABTORGB_TABLE_RANGE 1500 #define CIELABTORGB_TABLE_RANGE 1500
float rstep, gstep, bstep; float rstep, gstep, bstep;
float X0, Y0, Z0; /* Reference white point */ float X0, Y0, Z0; /* Reference white point */
TIFFDisplay display; TIFFDisplay display;
float Yr2r[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yr to r */ float Yr2r[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yr to r */
float Yg2g[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yg to g */ float Yg2g[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yg to g */
float Yb2b[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yb to b */ float Yb2b[CIELABTORGB_TABLE_RANGE + 1]; /* Conversion of Yb to b */
} TIFFCIELabToRGB; } TIFFCIELabToRGB;
/* /*
@ -180,63 +184,66 @@ typedef struct _TIFFRGBAImage TIFFRGBAImage;
/* /*
* The image reading and conversion routines invoke * The image reading and conversion routines invoke
* ``put routines'' to copy/image/whatever tiles of * ``put routines'' to copy/image/whatever tiles of
* raw image data. A default set of routines are * raw image data. A default set of routines are
* provided to convert/copy raw image data to 8-bit * provided to convert/copy raw image data to 8-bit
* packed ABGR format rasters. Applications can supply * packed ABGR format rasters. Applications can supply
* alternate routines that unpack the data into a * alternate routines that unpack the data into a
* different format or, for example, unpack the data * different format or, for example, unpack the data
* and draw the unpacked raster on the display. * and draw the unpacked raster on the display.
*/ */
typedef void (*tileContigRoutine) typedef void (*tileContigRoutine)(TIFFRGBAImage *, uint32_t *, uint32_t,
(TIFFRGBAImage*, uint32_t*, uint32_t, uint32_t, uint32_t, uint32_t, int32_t, int32_t, uint32_t, uint32_t, uint32_t, int32_t,
unsigned char*); int32_t, unsigned char *);
typedef void (*tileSeparateRoutine) typedef void (*tileSeparateRoutine)(TIFFRGBAImage *, uint32_t *, uint32_t,
(TIFFRGBAImage*, uint32_t*, uint32_t, uint32_t, uint32_t, uint32_t, int32_t, int32_t, uint32_t, uint32_t, uint32_t, int32_t,
unsigned char*, unsigned char*, unsigned char*, unsigned char*); int32_t, unsigned char *, unsigned char *,
unsigned char *, unsigned char *);
/* /*
* RGBA-reader state. * RGBA-reader state.
*/ */
struct _TIFFRGBAImage { struct _TIFFRGBAImage
TIFF* tif; /* image handle */ {
int stoponerr; /* stop on read error */ TIFF *tif; /* image handle */
int isContig; /* data is packed/separate */ int stoponerr; /* stop on read error */
int alpha; /* type of alpha data present */ int isContig; /* data is packed/separate */
uint32_t width; /* image width */ int alpha; /* type of alpha data present */
uint32_t height; /* image height */ uint32_t width; /* image width */
uint16_t bitspersample; /* image bits/sample */ uint32_t height; /* image height */
uint16_t samplesperpixel; /* image samples/pixel */ uint16_t bitspersample; /* image bits/sample */
uint16_t orientation; /* image orientation */ uint16_t samplesperpixel; /* image samples/pixel */
uint16_t req_orientation; /* requested orientation */ uint16_t orientation; /* image orientation */
uint16_t photometric; /* image photometric interp */ uint16_t req_orientation; /* requested orientation */
uint16_t* redcmap; /* colormap palette */ uint16_t photometric; /* image photometric interp */
uint16_t* greencmap; uint16_t *redcmap; /* colormap palette */
uint16_t* bluecmap; uint16_t *greencmap;
/* get image data routine */ uint16_t *bluecmap;
int (*get)(TIFFRGBAImage*, uint32_t*, uint32_t, uint32_t); /* get image data routine */
/* put decoded strip/tile */ int (*get)(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t);
union { /* put decoded strip/tile */
void (*any)(TIFFRGBAImage*); union
tileContigRoutine contig; {
tileSeparateRoutine separate; void (*any)(TIFFRGBAImage *);
} put; tileContigRoutine contig;
TIFFRGBValue* Map; /* sample mapping array */ tileSeparateRoutine separate;
uint32_t** BWmap; /* black&white map */ } put;
uint32_t** PALmap; /* palette image map */ TIFFRGBValue *Map; /* sample mapping array */
TIFFYCbCrToRGB* ycbcr; /* YCbCr conversion state */ uint32_t **BWmap; /* black&white map */
TIFFCIELabToRGB* cielab; /* CIE L*a*b conversion state */ uint32_t **PALmap; /* palette image map */
TIFFYCbCrToRGB *ycbcr; /* YCbCr conversion state */
TIFFCIELabToRGB *cielab; /* CIE L*a*b conversion state */
uint8_t* UaToAa; /* Unassociated alpha to associated alpha conversion LUT */ uint8_t *UaToAa; /* Unassociated alpha to associated alpha conversion LUT */
uint8_t* Bitdepth16To8; /* LUT for conversion from 16bit to 8bit values */ uint8_t *Bitdepth16To8; /* LUT for conversion from 16bit to 8bit values */
int row_offset; int row_offset;
int col_offset; int col_offset;
}; };
/* /*
* Macros for extracting components from the * Macros for extracting components from the
* packed ABGR form returned by TIFFReadRGBAImage. * packed ABGR form returned by TIFFReadRGBAImage.
*/ */
#define TIFFGetR(abgr) ((abgr) & 0xff) #define TIFFGetR(abgr) ((abgr)&0xff)
#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff) #define TIFFGetG(abgr) (((abgr) >> 8) & 0xff)
#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff) #define TIFFGetB(abgr) (((abgr) >> 16) & 0xff)
#define TIFFGetA(abgr) (((abgr) >> 24) & 0xff) #define TIFFGetA(abgr) (((abgr) >> 24) & 0xff)
@ -248,15 +255,16 @@ struct _TIFFRGBAImage {
* More codecs may be registered through calls to the library * More codecs may be registered through calls to the library
* and/or the builtin implementations may be overridden. * and/or the builtin implementations may be overridden.
*/ */
typedef int (*TIFFInitMethod)(TIFF*, int); typedef int (*TIFFInitMethod)(TIFF *, int);
typedef struct { typedef struct
char* name; {
uint16_t scheme; char *name;
TIFFInitMethod init; uint16_t scheme;
TIFFInitMethod init;
} TIFFCodec; } TIFFCodec;
#include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h>
/* share internal LogLuv conversion routines? */ /* share internal LogLuv conversion routines? */
#ifndef LOGLUV_PUBLIC #ifndef LOGLUV_PUBLIC
@ -264,315 +272,376 @@ typedef struct {
#endif #endif
#if defined(__GNUC__) || defined(__attribute__) #if defined(__GNUC__) || defined(__attribute__)
# define TIFF_ATTRIBUTE(x) __attribute__(x) #define TIFF_ATTRIBUTE(x) __attribute__(x)
#else #else
# define TIFF_ATTRIBUTE(x) /*nothing*/ #define TIFF_ATTRIBUTE(x) /*nothing*/
#endif #endif
#if defined(c_plusplus) || defined(__cplusplus) #if defined(c_plusplus) || defined(__cplusplus)
extern "C" { extern "C"
{
#endif #endif
typedef void (*TIFFErrorHandler)(const char*, const char*, va_list); typedef void (*TIFFErrorHandler)(const char *, const char *, va_list);
typedef void (*TIFFErrorHandlerExt)(thandle_t, const char*, const char*, va_list); typedef void (*TIFFErrorHandlerExt)(thandle_t, const char *, const char *,
typedef tmsize_t (*TIFFReadWriteProc)(thandle_t, void*, tmsize_t); va_list);
typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int); typedef int (*TIFFErrorHandlerExtR)(TIFF *, void *user_data, const char *,
typedef int (*TIFFCloseProc)(thandle_t); const char *, va_list);
typedef toff_t (*TIFFSizeProc)(thandle_t); typedef tmsize_t (*TIFFReadWriteProc)(thandle_t, void *, tmsize_t);
typedef int (*TIFFMapFileProc)(thandle_t, void** base, toff_t* size); typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int);
typedef void (*TIFFUnmapFileProc)(thandle_t, void* base, toff_t size); typedef int (*TIFFCloseProc)(thandle_t);
typedef void (*TIFFExtendProc)(TIFF*); typedef toff_t (*TIFFSizeProc)(thandle_t);
typedef int (*TIFFMapFileProc)(thandle_t, void **base, toff_t *size);
typedef void (*TIFFUnmapFileProc)(thandle_t, void *base, toff_t size);
typedef void (*TIFFExtendProc)(TIFF *);
extern const char* TIFFGetVersion(void); extern const char *TIFFGetVersion(void);
extern const TIFFCodec* TIFFFindCODEC(uint16_t); extern const TIFFCodec *TIFFFindCODEC(uint16_t);
extern TIFFCodec* TIFFRegisterCODEC(uint16_t, const char*, TIFFInitMethod); extern TIFFCodec *TIFFRegisterCODEC(uint16_t, const char *, TIFFInitMethod);
extern void TIFFUnRegisterCODEC(TIFFCodec*); extern void TIFFUnRegisterCODEC(TIFFCodec *);
extern int TIFFIsCODECConfigured(uint16_t); extern int TIFFIsCODECConfigured(uint16_t);
extern TIFFCodec* TIFFGetConfiguredCODECs(void); extern TIFFCodec *TIFFGetConfiguredCODECs(void);
/* /*
* Auxiliary functions. * Auxiliary functions.
*/ */
extern void* _TIFFmalloc(tmsize_t s); extern void *_TIFFmalloc(tmsize_t s);
extern void* _TIFFcalloc(tmsize_t nmemb, tmsize_t siz); extern void *_TIFFcalloc(tmsize_t nmemb, tmsize_t siz);
extern void* _TIFFrealloc(void* p, tmsize_t s); extern void *_TIFFrealloc(void *p, tmsize_t s);
extern void _TIFFmemset(void* p, int v, tmsize_t c); extern void _TIFFmemset(void *p, int v, tmsize_t c);
extern void _TIFFmemcpy(void* d, const void* s, tmsize_t c); extern void _TIFFmemcpy(void *d, const void *s, tmsize_t c);
extern int _TIFFmemcmp(const void* p1, const void* p2, tmsize_t c); extern int _TIFFmemcmp(const void *p1, const void *p2, tmsize_t c);
extern void _TIFFfree(void* p); extern void _TIFFfree(void *p);
/* /*
** Stuff, related to tag handling and creating custom tags. ** Stuff, related to tag handling and creating custom tags.
*/ */
extern int TIFFGetTagListCount( TIFF * ); extern int TIFFGetTagListCount(TIFF *);
extern uint32_t TIFFGetTagListEntry(TIFF *, int tag_index ); extern uint32_t TIFFGetTagListEntry(TIFF *, int tag_index);
#define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */
#define TIFF_VARIABLE -1 /* marker for variable length tags */
#define TIFF_SPP -2 /* marker for SamplesPerPixel tags */
#define TIFF_VARIABLE2 -3 /* marker for uint32_t var-length tags */
#define FIELD_CUSTOM 65 #define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */
#define TIFF_VARIABLE -1 /* marker for variable length tags */
#define TIFF_SPP -2 /* marker for SamplesPerPixel tags */
#define TIFF_VARIABLE2 -3 /* marker for uint32_t var-length tags */
typedef struct _TIFFField TIFFField; #define FIELD_CUSTOM 65
typedef struct _TIFFFieldArray TIFFFieldArray;
extern const TIFFField* TIFFFindField(TIFF *, uint32_t, TIFFDataType); typedef struct _TIFFField TIFFField;
extern const TIFFField* TIFFFieldWithTag(TIFF*, uint32_t); typedef struct _TIFFFieldArray TIFFFieldArray;
extern const TIFFField* TIFFFieldWithName(TIFF*, const char *);
extern uint32_t TIFFFieldTag(const TIFFField*); extern const TIFFField *TIFFFindField(TIFF *, uint32_t, TIFFDataType);
extern const char* TIFFFieldName(const TIFFField*); extern const TIFFField *TIFFFieldWithTag(TIFF *, uint32_t);
extern TIFFDataType TIFFFieldDataType(const TIFFField*); extern const TIFFField *TIFFFieldWithName(TIFF *, const char *);
extern int TIFFFieldPassCount(const TIFFField*);
extern int TIFFFieldReadCount(const TIFFField*);
extern int TIFFFieldWriteCount(const TIFFField*);
extern int TIFFFieldSetGetSize(const TIFFField*); /* returns internal storage size of TIFFSetGetFieldType in bytes. */
extern int TIFFFieldSetGetCountSize(const TIFFField*); /* returns size of count parameter 0=none, 2=uint16_t, 4=uint32_t */
extern int TIFFFieldIsAnonymous(const TIFFField *);
typedef int (*TIFFVSetMethod)(TIFF*, uint32_t, va_list); extern uint32_t TIFFFieldTag(const TIFFField *);
typedef int (*TIFFVGetMethod)(TIFF*, uint32_t, va_list); extern const char *TIFFFieldName(const TIFFField *);
typedef void (*TIFFPrintMethod)(TIFF*, FILE*, long); extern TIFFDataType TIFFFieldDataType(const TIFFField *);
extern int TIFFFieldPassCount(const TIFFField *);
extern int TIFFFieldReadCount(const TIFFField *);
extern int TIFFFieldWriteCount(const TIFFField *);
extern int
TIFFFieldSetGetSize(const TIFFField *); /* returns internal storage size of
TIFFSetGetFieldType in bytes. */
extern int TIFFFieldSetGetCountSize(
const TIFFField *); /* returns size of count parameter 0=none,
2=uint16_t, 4=uint32_t */
extern int TIFFFieldIsAnonymous(const TIFFField *);
typedef struct { typedef int (*TIFFVSetMethod)(TIFF *, uint32_t, va_list);
TIFFVSetMethod vsetfield; /* tag set routine */ typedef int (*TIFFVGetMethod)(TIFF *, uint32_t, va_list);
TIFFVGetMethod vgetfield; /* tag get routine */ typedef void (*TIFFPrintMethod)(TIFF *, FILE *, long);
TIFFPrintMethod printdir; /* directory print routine */
} TIFFTagMethods;
extern TIFFTagMethods *TIFFAccessTagMethods(TIFF *); typedef struct
extern void *TIFFGetClientInfo(TIFF *, const char *); {
extern void TIFFSetClientInfo(TIFF *, void *, const char *); TIFFVSetMethod vsetfield; /* tag set routine */
TIFFVGetMethod vgetfield; /* tag get routine */
TIFFPrintMethod printdir; /* directory print routine */
} TIFFTagMethods;
extern void TIFFCleanup(TIFF* tif); extern TIFFTagMethods *TIFFAccessTagMethods(TIFF *);
extern void TIFFClose(TIFF* tif); extern void *TIFFGetClientInfo(TIFF *, const char *);
extern int TIFFFlush(TIFF* tif); extern void TIFFSetClientInfo(TIFF *, void *, const char *);
extern int TIFFFlushData(TIFF* tif);
extern int TIFFGetField(TIFF* tif, uint32_t tag, ...); extern void TIFFCleanup(TIFF *tif);
extern int TIFFVGetField(TIFF* tif, uint32_t tag, va_list ap); extern void TIFFClose(TIFF *tif);
extern int TIFFGetFieldDefaulted(TIFF* tif, uint32_t tag, ...); extern int TIFFFlush(TIFF *tif);
extern int TIFFVGetFieldDefaulted(TIFF* tif, uint32_t tag, va_list ap); extern int TIFFFlushData(TIFF *tif);
extern int TIFFReadDirectory(TIFF* tif); extern int TIFFGetField(TIFF *tif, uint32_t tag, ...);
extern int TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, const TIFFFieldArray* infoarray); extern int TIFFVGetField(TIFF *tif, uint32_t tag, va_list ap);
extern int TIFFReadEXIFDirectory(TIFF* tif, toff_t diroff); extern int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag, ...);
extern int TIFFReadGPSDirectory(TIFF* tif, toff_t diroff); extern int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap);
extern uint64_t TIFFScanlineSize64(TIFF* tif); extern int TIFFReadDirectory(TIFF *tif);
extern tmsize_t TIFFScanlineSize(TIFF* tif); extern int TIFFReadCustomDirectory(TIFF *tif, toff_t diroff,
extern uint64_t TIFFRasterScanlineSize64(TIFF* tif); const TIFFFieldArray *infoarray);
extern tmsize_t TIFFRasterScanlineSize(TIFF* tif); extern int TIFFReadEXIFDirectory(TIFF *tif, toff_t diroff);
extern uint64_t TIFFStripSize64(TIFF* tif); extern int TIFFReadGPSDirectory(TIFF *tif, toff_t diroff);
extern tmsize_t TIFFStripSize(TIFF* tif); extern uint64_t TIFFScanlineSize64(TIFF *tif);
extern uint64_t TIFFRawStripSize64(TIFF* tif, uint32_t strip); extern tmsize_t TIFFScanlineSize(TIFF *tif);
extern tmsize_t TIFFRawStripSize(TIFF* tif, uint32_t strip); extern uint64_t TIFFRasterScanlineSize64(TIFF *tif);
extern uint64_t TIFFVStripSize64(TIFF* tif, uint32_t nrows); extern tmsize_t TIFFRasterScanlineSize(TIFF *tif);
extern tmsize_t TIFFVStripSize(TIFF* tif, uint32_t nrows); extern uint64_t TIFFStripSize64(TIFF *tif);
extern uint64_t TIFFTileRowSize64(TIFF* tif); extern tmsize_t TIFFStripSize(TIFF *tif);
extern tmsize_t TIFFTileRowSize(TIFF* tif); extern uint64_t TIFFRawStripSize64(TIFF *tif, uint32_t strip);
extern uint64_t TIFFTileSize64(TIFF* tif); extern tmsize_t TIFFRawStripSize(TIFF *tif, uint32_t strip);
extern tmsize_t TIFFTileSize(TIFF* tif); extern uint64_t TIFFVStripSize64(TIFF *tif, uint32_t nrows);
extern uint64_t TIFFVTileSize64(TIFF* tif, uint32_t nrows); extern tmsize_t TIFFVStripSize(TIFF *tif, uint32_t nrows);
extern tmsize_t TIFFVTileSize(TIFF* tif, uint32_t nrows); extern uint64_t TIFFTileRowSize64(TIFF *tif);
extern uint32_t TIFFDefaultStripSize(TIFF* tif, uint32_t request); extern tmsize_t TIFFTileRowSize(TIFF *tif);
extern void TIFFDefaultTileSize(TIFF*, uint32_t*, uint32_t*); extern uint64_t TIFFTileSize64(TIFF *tif);
extern int TIFFFileno(TIFF*); extern tmsize_t TIFFTileSize(TIFF *tif);
extern int TIFFSetFileno(TIFF*, int); extern uint64_t TIFFVTileSize64(TIFF *tif, uint32_t nrows);
extern thandle_t TIFFClientdata(TIFF*); extern tmsize_t TIFFVTileSize(TIFF *tif, uint32_t nrows);
extern thandle_t TIFFSetClientdata(TIFF*, thandle_t); extern uint32_t TIFFDefaultStripSize(TIFF *tif, uint32_t request);
extern int TIFFGetMode(TIFF*); extern void TIFFDefaultTileSize(TIFF *, uint32_t *, uint32_t *);
extern int TIFFSetMode(TIFF*, int); extern int TIFFFileno(TIFF *);
extern int TIFFIsTiled(TIFF*); extern int TIFFSetFileno(TIFF *, int);
extern int TIFFIsByteSwapped(TIFF*); extern thandle_t TIFFClientdata(TIFF *);
extern int TIFFIsUpSampled(TIFF*); extern thandle_t TIFFSetClientdata(TIFF *, thandle_t);
extern int TIFFIsMSB2LSB(TIFF*); extern int TIFFGetMode(TIFF *);
extern int TIFFIsBigEndian(TIFF*); extern int TIFFSetMode(TIFF *, int);
extern int TIFFIsBigTIFF(TIFF*); extern int TIFFIsTiled(TIFF *);
extern TIFFReadWriteProc TIFFGetReadProc(TIFF*); extern int TIFFIsByteSwapped(TIFF *);
extern TIFFReadWriteProc TIFFGetWriteProc(TIFF*); extern int TIFFIsUpSampled(TIFF *);
extern TIFFSeekProc TIFFGetSeekProc(TIFF*); extern int TIFFIsMSB2LSB(TIFF *);
extern TIFFCloseProc TIFFGetCloseProc(TIFF*); extern int TIFFIsBigEndian(TIFF *);
extern TIFFSizeProc TIFFGetSizeProc(TIFF*); extern int TIFFIsBigTIFF(TIFF *);
extern TIFFMapFileProc TIFFGetMapFileProc(TIFF*); extern TIFFReadWriteProc TIFFGetReadProc(TIFF *);
extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF*); extern TIFFReadWriteProc TIFFGetWriteProc(TIFF *);
extern uint32_t TIFFCurrentRow(TIFF*); extern TIFFSeekProc TIFFGetSeekProc(TIFF *);
extern uint16_t TIFFCurrentDirectory(TIFF*); extern TIFFCloseProc TIFFGetCloseProc(TIFF *);
extern uint16_t TIFFNumberOfDirectories(TIFF*); extern TIFFSizeProc TIFFGetSizeProc(TIFF *);
extern uint64_t TIFFCurrentDirOffset(TIFF*); extern TIFFMapFileProc TIFFGetMapFileProc(TIFF *);
extern uint32_t TIFFCurrentStrip(TIFF*); extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF *);
extern uint32_t TIFFCurrentTile(TIFF* tif); extern uint32_t TIFFCurrentRow(TIFF *);
extern int TIFFReadBufferSetup(TIFF* tif, void* bp, tmsize_t size); extern tdir_t TIFFCurrentDirectory(TIFF *);
extern int TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size); extern tdir_t TIFFNumberOfDirectories(TIFF *);
extern int TIFFSetupStrips(TIFF *); extern uint64_t TIFFCurrentDirOffset(TIFF *);
extern int TIFFWriteCheck(TIFF*, int, const char *); extern uint32_t TIFFCurrentStrip(TIFF *);
extern void TIFFFreeDirectory(TIFF*); extern uint32_t TIFFCurrentTile(TIFF *tif);
extern int TIFFCreateDirectory(TIFF*); extern int TIFFReadBufferSetup(TIFF *tif, void *bp, tmsize_t size);
extern int TIFFCreateCustomDirectory(TIFF*,const TIFFFieldArray*); extern int TIFFWriteBufferSetup(TIFF *tif, void *bp, tmsize_t size);
extern int TIFFCreateEXIFDirectory(TIFF*); extern int TIFFSetupStrips(TIFF *);
extern int TIFFCreateGPSDirectory(TIFF*); extern int TIFFWriteCheck(TIFF *, int, const char *);
extern int TIFFLastDirectory(TIFF*); extern void TIFFFreeDirectory(TIFF *);
extern int TIFFSetDirectory(TIFF*, uint16_t); extern int TIFFCreateDirectory(TIFF *);
extern int TIFFSetSubDirectory(TIFF*, uint64_t); extern int TIFFCreateCustomDirectory(TIFF *, const TIFFFieldArray *);
extern int TIFFUnlinkDirectory(TIFF*, uint16_t); extern int TIFFCreateEXIFDirectory(TIFF *);
extern int TIFFSetField(TIFF*, uint32_t, ...); extern int TIFFCreateGPSDirectory(TIFF *);
extern int TIFFVSetField(TIFF*, uint32_t, va_list); extern int TIFFLastDirectory(TIFF *);
extern int TIFFUnsetField(TIFF*, uint32_t); extern int TIFFSetDirectory(TIFF *, tdir_t);
extern int TIFFWriteDirectory(TIFF *); extern int TIFFSetSubDirectory(TIFF *, uint64_t);
extern int TIFFWriteCustomDirectory(TIFF *, uint64_t *); extern int TIFFUnlinkDirectory(TIFF *, tdir_t);
extern int TIFFCheckpointDirectory(TIFF *); extern int TIFFSetField(TIFF *, uint32_t, ...);
extern int TIFFRewriteDirectory(TIFF *); extern int TIFFVSetField(TIFF *, uint32_t, va_list);
extern int TIFFDeferStrileArrayWriting(TIFF *); extern int TIFFUnsetField(TIFF *, uint32_t);
extern int TIFFForceStrileArrayWriting(TIFF* ); extern int TIFFWriteDirectory(TIFF *);
extern int TIFFWriteCustomDirectory(TIFF *, uint64_t *);
extern int TIFFCheckpointDirectory(TIFF *);
extern int TIFFRewriteDirectory(TIFF *);
extern int TIFFDeferStrileArrayWriting(TIFF *);
extern int TIFFForceStrileArrayWriting(TIFF *);
#if defined(c_plusplus) || defined(__cplusplus) #if defined(c_plusplus) || defined(__cplusplus)
extern void TIFFPrintDirectory(TIFF*, FILE*, long = 0); extern void TIFFPrintDirectory(TIFF *, FILE *, long = 0);
extern int TIFFReadScanline(TIFF* tif, void* buf, uint32_t row, uint16_t sample = 0); extern int TIFFReadScanline(TIFF *tif, void *buf, uint32_t row,
extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32_t row, uint16_t sample = 0); uint16_t sample = 0);
extern int TIFFReadRGBAImage(TIFF*, uint32_t, uint32_t, uint32_t*, int = 0); extern int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row,
extern int TIFFReadRGBAImageOriented(TIFF*, uint32_t, uint32_t, uint32_t*, uint16_t sample = 0);
int = ORIENTATION_BOTLEFT, int = 0); extern int TIFFReadRGBAImage(TIFF *, uint32_t, uint32_t, uint32_t *,
int = 0);
extern int TIFFReadRGBAImageOriented(TIFF *, uint32_t, uint32_t, uint32_t *,
int = ORIENTATION_BOTLEFT, int = 0);
#else #else
extern void TIFFPrintDirectory(TIFF*, FILE*, long); extern void TIFFPrintDirectory(TIFF *, FILE *, long);
extern int TIFFReadScanline(TIFF* tif, void* buf, uint32_t row, uint16_t sample); extern int TIFFReadScanline(TIFF *tif, void *buf, uint32_t row,
extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32_t row, uint16_t sample); uint16_t sample);
extern int TIFFReadRGBAImage(TIFF*, uint32_t, uint32_t, uint32_t*, int); extern int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row,
extern int TIFFReadRGBAImageOriented(TIFF*, uint32_t, uint32_t, uint32_t*, int, int); uint16_t sample);
extern int TIFFReadRGBAImage(TIFF *, uint32_t, uint32_t, uint32_t *, int);
extern int TIFFReadRGBAImageOriented(TIFF *, uint32_t, uint32_t, uint32_t *,
int, int);
#endif #endif
extern int TIFFReadRGBAStrip(TIFF*, uint32_t, uint32_t * ); extern int TIFFReadRGBAStrip(TIFF *, uint32_t, uint32_t *);
extern int TIFFReadRGBATile(TIFF*, uint32_t, uint32_t, uint32_t * ); extern int TIFFReadRGBATile(TIFF *, uint32_t, uint32_t, uint32_t *);
extern int TIFFReadRGBAStripExt(TIFF*, uint32_t, uint32_t *, int stop_on_error ); extern int TIFFReadRGBAStripExt(TIFF *, uint32_t, uint32_t *,
extern int TIFFReadRGBATileExt(TIFF*, uint32_t, uint32_t, uint32_t *, int stop_on_error ); int stop_on_error);
extern int TIFFRGBAImageOK(TIFF*, char [1024]); extern int TIFFReadRGBATileExt(TIFF *, uint32_t, uint32_t, uint32_t *,
extern int TIFFRGBAImageBegin(TIFFRGBAImage*, TIFF*, int, char [1024]); int stop_on_error);
extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32_t*, uint32_t, uint32_t); extern int TIFFRGBAImageOK(TIFF *, char[1024]);
extern void TIFFRGBAImageEnd(TIFFRGBAImage*); extern int TIFFRGBAImageBegin(TIFFRGBAImage *, TIFF *, int, char[1024]);
extern TIFF* TIFFOpen(const char*, const char*); extern int TIFFRGBAImageGet(TIFFRGBAImage *, uint32_t *, uint32_t,
# ifdef __WIN32__ uint32_t);
extern TIFF* TIFFOpenW(const wchar_t*, const char*); extern void TIFFRGBAImageEnd(TIFFRGBAImage *);
# endif /* __WIN32__ */
extern TIFF* TIFFFdOpen(int, const char*, const char*);
extern TIFF* TIFFClientOpen(const char*, const char*,
thandle_t,
TIFFReadWriteProc, TIFFReadWriteProc,
TIFFSeekProc, TIFFCloseProc,
TIFFSizeProc,
TIFFMapFileProc, TIFFUnmapFileProc);
extern const char* TIFFFileName(TIFF*);
extern const char* TIFFSetFileName(TIFF*, const char *);
extern void TIFFError(const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,2,3)));
extern void TIFFErrorExt(thandle_t, const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,3,4)));
extern void TIFFWarning(const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,2,3)));
extern void TIFFWarningExt(thandle_t, const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,3,4)));
extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt);
extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt);
extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc);
extern uint32_t TIFFComputeTile(TIFF* tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s);
extern int TIFFCheckTile(TIFF* tif, uint32_t x, uint32_t y, uint32_t z, uint16_t s);
extern uint32_t TIFFNumberOfTiles(TIFF*);
extern tmsize_t TIFFReadTile(TIFF* tif, void* buf, uint32_t x, uint32_t y, uint32_t z, uint16_t s);
extern tmsize_t TIFFWriteTile(TIFF* tif, void* buf, uint32_t x, uint32_t y, uint32_t z, uint16_t s);
extern uint32_t TIFFComputeStrip(TIFF*, uint32_t, uint16_t);
extern uint32_t TIFFNumberOfStrips(TIFF*);
extern tmsize_t TIFFReadEncodedStrip(TIFF* tif, uint32_t strip, void* buf, tmsize_t size);
extern tmsize_t TIFFReadRawStrip(TIFF* tif, uint32_t strip, void* buf, tmsize_t size);
extern tmsize_t TIFFReadEncodedTile(TIFF* tif, uint32_t tile, void* buf, tmsize_t size);
extern tmsize_t TIFFReadRawTile(TIFF* tif, uint32_t tile, void* buf, tmsize_t size);
extern int TIFFReadFromUserBuffer(TIFF* tif, uint32_t strile,
void* inbuf, tmsize_t insize,
void* outbuf, tmsize_t outsize);
extern tmsize_t TIFFWriteEncodedStrip(TIFF* tif, uint32_t strip, void* data, tmsize_t cc);
extern tmsize_t TIFFWriteRawStrip(TIFF* tif, uint32_t strip, void* data, tmsize_t cc);
extern tmsize_t TIFFWriteEncodedTile(TIFF* tif, uint32_t tile, void* data, tmsize_t cc);
extern tmsize_t TIFFWriteRawTile(TIFF* tif, uint32_t tile, void* data, tmsize_t cc);
extern int TIFFDataWidth(TIFFDataType); /* table of tag datatype widths within TIFF file. */
extern void TIFFSetWriteOffset(TIFF* tif, toff_t off);
extern void TIFFSwabShort(uint16_t*);
extern void TIFFSwabLong(uint32_t*);
extern void TIFFSwabLong8(uint64_t*);
extern void TIFFSwabFloat(float*);
extern void TIFFSwabDouble(double*);
extern void TIFFSwabArrayOfShort(uint16_t* wp, tmsize_t n);
extern void TIFFSwabArrayOfTriples(uint8_t* tp, tmsize_t n);
extern void TIFFSwabArrayOfLong(uint32_t* lp, tmsize_t n);
extern void TIFFSwabArrayOfLong8(uint64_t* lp, tmsize_t n);
extern void TIFFSwabArrayOfFloat(float* fp, tmsize_t n);
extern void TIFFSwabArrayOfDouble(double* dp, tmsize_t n);
extern void TIFFReverseBits(uint8_t* cp, tmsize_t n);
extern const unsigned char* TIFFGetBitRevTable(int);
extern uint64_t TIFFGetStrileOffset(TIFF *tif, uint32_t strile); extern const char *TIFFFileName(TIFF *);
extern uint64_t TIFFGetStrileByteCount(TIFF *tif, uint32_t strile); extern const char *TIFFSetFileName(TIFF *, const char *);
extern uint64_t TIFFGetStrileOffsetWithErr(TIFF *tif, uint32_t strile, int *pbErr); extern void TIFFError(const char *, const char *, ...)
extern uint64_t TIFFGetStrileByteCountWithErr(TIFF *tif, uint32_t strile, int *pbErr); TIFF_ATTRIBUTE((__format__(__printf__, 2, 3)));
extern void TIFFErrorExt(thandle_t, const char *, const char *, ...)
TIFF_ATTRIBUTE((__format__(__printf__, 3, 4)));
extern void TIFFWarning(const char *, const char *, ...)
TIFF_ATTRIBUTE((__format__(__printf__, 2, 3)));
extern void TIFFWarningExt(thandle_t, const char *, const char *, ...)
TIFF_ATTRIBUTE((__format__(__printf__, 3, 4)));
extern TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt);
extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt);
extern void TIFFWarningExtR(TIFF *, const char *, const char *, ...)
TIFF_ATTRIBUTE((__format__(__printf__, 3, 4)));
extern void TIFFErrorExtR(TIFF *, const char *, const char *, ...)
TIFF_ATTRIBUTE((__format__(__printf__, 3, 4)));
typedef struct TIFFOpenOptions TIFFOpenOptions;
extern TIFFOpenOptions *TIFFOpenOptionsAlloc(void);
extern void TIFFOpenOptionsFree(TIFFOpenOptions *);
extern void
TIFFOpenOptionsSetMaxSingleMemAlloc(TIFFOpenOptions *opts,
tmsize_t max_single_mem_alloc);
extern void
TIFFOpenOptionsSetErrorHandlerExtR(TIFFOpenOptions *opts,
TIFFErrorHandlerExtR handler,
void *errorhandler_user_data);
extern void
TIFFOpenOptionsSetWarningHandlerExtR(TIFFOpenOptions *opts,
TIFFErrorHandlerExtR handler,
void *warnhandler_user_data);
extern TIFF *TIFFOpen(const char *, const char *);
extern TIFF *TIFFOpenExt(const char *, const char *, TIFFOpenOptions *opts);
#ifdef __WIN32__
extern TIFF *TIFFOpenW(const wchar_t *, const char *);
extern TIFF *TIFFOpenWExt(const wchar_t *, const char *,
TIFFOpenOptions *opts);
#endif /* __WIN32__ */
extern TIFF *TIFFFdOpen(int, const char *, const char *);
extern TIFF *TIFFFdOpenExt(int, const char *, const char *,
TIFFOpenOptions *opts);
extern TIFF *TIFFClientOpen(const char *, const char *, thandle_t,
TIFFReadWriteProc, TIFFReadWriteProc,
TIFFSeekProc, TIFFCloseProc, TIFFSizeProc,
TIFFMapFileProc, TIFFUnmapFileProc);
extern TIFF *TIFFClientOpenExt(const char *, const char *, thandle_t,
TIFFReadWriteProc, TIFFReadWriteProc,
TIFFSeekProc, TIFFCloseProc, TIFFSizeProc,
TIFFMapFileProc, TIFFUnmapFileProc,
TIFFOpenOptions *opts);
extern TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc);
extern uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y,
uint32_t z, uint16_t s);
extern int TIFFCheckTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z,
uint16_t s);
extern uint32_t TIFFNumberOfTiles(TIFF *);
extern tmsize_t TIFFReadTile(TIFF *tif, void *buf, uint32_t x, uint32_t y,
uint32_t z, uint16_t s);
extern tmsize_t TIFFWriteTile(TIFF *tif, void *buf, uint32_t x, uint32_t y,
uint32_t z, uint16_t s);
extern uint32_t TIFFComputeStrip(TIFF *, uint32_t, uint16_t);
extern uint32_t TIFFNumberOfStrips(TIFF *);
extern tmsize_t TIFFReadEncodedStrip(TIFF *tif, uint32_t strip, void *buf,
tmsize_t size);
extern tmsize_t TIFFReadRawStrip(TIFF *tif, uint32_t strip, void *buf,
tmsize_t size);
extern tmsize_t TIFFReadEncodedTile(TIFF *tif, uint32_t tile, void *buf,
tmsize_t size);
extern tmsize_t TIFFReadRawTile(TIFF *tif, uint32_t tile, void *buf,
tmsize_t size);
extern int TIFFReadFromUserBuffer(TIFF *tif, uint32_t strile, void *inbuf,
tmsize_t insize, void *outbuf,
tmsize_t outsize);
extern tmsize_t TIFFWriteEncodedStrip(TIFF *tif, uint32_t strip, void *data,
tmsize_t cc);
extern tmsize_t TIFFWriteRawStrip(TIFF *tif, uint32_t strip, void *data,
tmsize_t cc);
extern tmsize_t TIFFWriteEncodedTile(TIFF *tif, uint32_t tile, void *data,
tmsize_t cc);
extern tmsize_t TIFFWriteRawTile(TIFF *tif, uint32_t tile, void *data,
tmsize_t cc);
extern int TIFFDataWidth(
TIFFDataType); /* table of tag datatype widths within TIFF file. */
extern void TIFFSetWriteOffset(TIFF *tif, toff_t off);
extern void TIFFSwabShort(uint16_t *);
extern void TIFFSwabLong(uint32_t *);
extern void TIFFSwabLong8(uint64_t *);
extern void TIFFSwabFloat(float *);
extern void TIFFSwabDouble(double *);
extern void TIFFSwabArrayOfShort(uint16_t *wp, tmsize_t n);
extern void TIFFSwabArrayOfTriples(uint8_t *tp, tmsize_t n);
extern void TIFFSwabArrayOfLong(uint32_t *lp, tmsize_t n);
extern void TIFFSwabArrayOfLong8(uint64_t *lp, tmsize_t n);
extern void TIFFSwabArrayOfFloat(float *fp, tmsize_t n);
extern void TIFFSwabArrayOfDouble(double *dp, tmsize_t n);
extern void TIFFReverseBits(uint8_t *cp, tmsize_t n);
extern const unsigned char *TIFFGetBitRevTable(int);
extern uint64_t TIFFGetStrileOffset(TIFF *tif, uint32_t strile);
extern uint64_t TIFFGetStrileByteCount(TIFF *tif, uint32_t strile);
extern uint64_t TIFFGetStrileOffsetWithErr(TIFF *tif, uint32_t strile,
int *pbErr);
extern uint64_t TIFFGetStrileByteCountWithErr(TIFF *tif, uint32_t strile,
int *pbErr);
#ifdef LOGLUV_PUBLIC #ifdef LOGLUV_PUBLIC
#define U_NEU 0.210526316 #define U_NEU 0.210526316
#define V_NEU 0.473684211 #define V_NEU 0.473684211
#define UVSCALE 410. #define UVSCALE 410.
extern double LogL16toY(int); extern double LogL16toY(int);
extern double LogL10toY(int); extern double LogL10toY(int);
extern void XYZtoRGB24(float*, uint8_t*); extern void XYZtoRGB24(float *, uint8_t *);
extern int uv_decode(double*, double*, int); extern int uv_decode(double *, double *, int);
extern void LogLuv24toXYZ(uint32_t, float*); extern void LogLuv24toXYZ(uint32_t, float *);
extern void LogLuv32toXYZ(uint32_t, float*); extern void LogLuv32toXYZ(uint32_t, float *);
#if defined(c_plusplus) || defined(__cplusplus) #if defined(c_plusplus) || defined(__cplusplus)
extern int LogL16fromY(double, int = SGILOGENCODE_NODITHER); extern int LogL16fromY(double, int = SGILOGENCODE_NODITHER);
extern int LogL10fromY(double, int = SGILOGENCODE_NODITHER); extern int LogL10fromY(double, int = SGILOGENCODE_NODITHER);
extern int uv_encode(double, double, int = SGILOGENCODE_NODITHER); extern int uv_encode(double, double, int = SGILOGENCODE_NODITHER);
extern uint32_t LogLuv24fromXYZ(float*, int = SGILOGENCODE_NODITHER); extern uint32_t LogLuv24fromXYZ(float *, int = SGILOGENCODE_NODITHER);
extern uint32_t LogLuv32fromXYZ(float*, int = SGILOGENCODE_NODITHER); extern uint32_t LogLuv32fromXYZ(float *, int = SGILOGENCODE_NODITHER);
#else #else
extern int LogL16fromY(double, int); extern int LogL16fromY(double, int);
extern int LogL10fromY(double, int); extern int LogL10fromY(double, int);
extern int uv_encode(double, double, int); extern int uv_encode(double, double, int);
extern uint32_t LogLuv24fromXYZ(float*, int); extern uint32_t LogLuv24fromXYZ(float *, int);
extern uint32_t LogLuv32fromXYZ(float*, int); extern uint32_t LogLuv32fromXYZ(float *, int);
#endif #endif
#endif /* LOGLUV_PUBLIC */ #endif /* LOGLUV_PUBLIC */
extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB*, const TIFFDisplay *, float*); extern int TIFFCIELabToRGBInit(TIFFCIELabToRGB *, const TIFFDisplay *,
extern void TIFFCIELabToXYZ(TIFFCIELabToRGB *, uint32_t, int32_t, int32_t, float *);
float *, float *, float *); extern void TIFFCIELabToXYZ(TIFFCIELabToRGB *, uint32_t, int32_t, int32_t,
extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float, float *, float *, float *);
uint32_t *, uint32_t *, uint32_t *); extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float, uint32_t *,
uint32_t *, uint32_t *);
extern int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB*, float*, float*); extern int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *, float *, float *);
extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32_t, int32_t, int32_t, extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32_t, int32_t, int32_t,
uint32_t *, uint32_t *, uint32_t *); uint32_t *, uint32_t *, uint32_t *);
/**************************************************************************** /****************************************************************************
* O B S O L E T E D I N T E R F A C E S * O B S O L E T E D I N T E R F A C E S
* *
* Don't use this stuff in your applications, it may be removed in the future * Don't use this stuff in your applications, it may be removed in the
* libtiff versions. *future libtiff versions.
****************************************************************************/ ****************************************************************************/
typedef struct { typedef struct
ttag_t field_tag; /* field's tag */ {
short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */ ttag_t field_tag; /* field's tag */
short field_writecount; /* write count/TIFF_VARIABLE */ short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */
TIFFDataType field_type; /* type of associated data */ short field_writecount; /* write count/TIFF_VARIABLE */
unsigned short field_bit; /* bit in fieldsset bit vector */ TIFFDataType field_type; /* type of associated data */
unsigned char field_oktochange; /* if true, can change while writing */ unsigned short field_bit; /* bit in fieldsset bit vector */
unsigned char field_passcount; /* if true, pass dir count on set */ unsigned char field_oktochange; /* if true, can change while writing */
char *field_name; /* ASCII name */ unsigned char field_passcount; /* if true, pass dir count on set */
} TIFFFieldInfo; char *field_name; /* ASCII name */
} TIFFFieldInfo;
extern int TIFFMergeFieldInfo(TIFF *, const TIFFFieldInfo[], uint32_t);
extern int TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], uint32_t);
#if defined(c_plusplus) || defined(__cplusplus) #if defined(c_plusplus) || defined(__cplusplus)
} }
#endif #endif
#endif /* _TIFFIO_ */ #endif /* _TIFFIO_ */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

607
libs/tiff/libtiff/tiffiop.h
View file

@ -23,7 +23,7 @@
*/ */
#ifndef _TIFFIOP_ #ifndef _TIFFIOP_
#define _TIFFIOP_ #define _TIFFIOP_
/* /*
* ``Library-private'' definitions. * ``Library-private'' definitions.
*/ */
@ -31,38 +31,48 @@
#include "tif_config.h" #include "tif_config.h"
#ifdef HAVE_FCNTL_H #ifdef HAVE_FCNTL_H
# include <fcntl.h> #include <fcntl.h>
#endif #endif
#ifdef HAVE_SYS_TYPES_H #ifdef HAVE_SYS_TYPES_H
# include <sys/types.h> #include <sys/types.h>
#endif #endif
#include <string.h> #include <string.h>
#ifdef HAVE_ASSERT_H #ifdef HAVE_ASSERT_H
# include <assert.h> #include <assert.h>
#else #else
# define assert(x) #define assert(x)
#endif #endif
#include "tif_hash_set.h"
#include "tiffio.h" #include "tiffio.h"
#include "tif_dir.h" #include "tif_dir.h"
#include <limits.h>
#ifndef STRIP_SIZE_DEFAULT #ifndef STRIP_SIZE_DEFAULT
# define STRIP_SIZE_DEFAULT 8192 #define STRIP_SIZE_DEFAULT 8192
#endif #endif
#define streq(a,b) (strcmp(a,b) == 0) #ifndef TIFF_MAX_DIR_COUNT
#define strneq(a,b,n) (strncmp(a,b,n) == 0) #define TIFF_MAX_DIR_COUNT 1048576
#endif
#define TIFF_NON_EXISTENT_DIR_NUMBER UINT_MAX
#define streq(a, b) (strcmp(a, b) == 0)
#define strneq(a, b, n) (strncmp(a, b, n) == 0)
#ifndef TRUE #ifndef TRUE
#define TRUE 1 #define TRUE 1
#define FALSE 0 #define FALSE 0
#endif #endif
typedef struct client_info { typedef struct client_info
{
struct client_info *next; struct client_info *next;
void *data; void *data;
char *name; char *name;
@ -72,189 +82,232 @@ typedef struct client_info {
* Typedefs for ``method pointers'' used internally. * Typedefs for ``method pointers'' used internally.
* these are deprecated and provided only for backwards compatibility. * these are deprecated and provided only for backwards compatibility.
*/ */
typedef unsigned char tidataval_t; /* internal image data value type */ typedef unsigned char tidataval_t; /* internal image data value type */
typedef tidataval_t* tidata_t; /* reference to internal image data */ typedef tidataval_t *tidata_t; /* reference to internal image data */
typedef void (*TIFFVoidMethod)(TIFF*); typedef void (*TIFFVoidMethod)(TIFF *);
typedef int (*TIFFBoolMethod)(TIFF*); typedef int (*TIFFBoolMethod)(TIFF *);
typedef int (*TIFFPreMethod)(TIFF*, uint16_t); typedef int (*TIFFPreMethod)(TIFF *, uint16_t);
typedef int (*TIFFCodeMethod)(TIFF* tif, uint8_t* buf, tmsize_t size, uint16_t sample); typedef int (*TIFFCodeMethod)(TIFF *tif, uint8_t *buf, tmsize_t size,
typedef int (*TIFFSeekMethod)(TIFF*, uint32_t); uint16_t sample);
typedef void (*TIFFPostMethod)(TIFF* tif, uint8_t* buf, tmsize_t size); typedef int (*TIFFSeekMethod)(TIFF *, uint32_t);
typedef uint32_t (*TIFFStripMethod)(TIFF*, uint32_t); typedef void (*TIFFPostMethod)(TIFF *tif, uint8_t *buf, tmsize_t size);
typedef void (*TIFFTileMethod)(TIFF*, uint32_t*, uint32_t*); typedef uint32_t (*TIFFStripMethod)(TIFF *, uint32_t);
typedef void (*TIFFTileMethod)(TIFF *, uint32_t *, uint32_t *);
struct tiff { struct TIFFOffsetAndDirNumber
char* tif_name; /* name of open file */ {
int tif_fd; /* open file descriptor */ uint64_t offset;
int tif_mode; /* open mode (O_*) */ tdir_t dirNumber;
uint32_t tif_flags; };
#define TIFF_FILLORDER 0x00003U /* natural bit fill order for machine */ typedef struct TIFFOffsetAndDirNumber TIFFOffsetAndDirNumber;
#define TIFF_DIRTYHEADER 0x00004U /* header must be written on close */
#define TIFF_DIRTYDIRECT 0x00008U /* current directory must be written */ struct tiff
#define TIFF_BUFFERSETUP 0x00010U /* data buffers setup */ {
#define TIFF_CODERSETUP 0x00020U /* encoder/decoder setup done */ char *tif_name; /* name of open file */
#define TIFF_BEENWRITING 0x00040U /* written 1+ scanlines to file */ int tif_fd; /* open file descriptor */
#define TIFF_SWAB 0x00080U /* byte swap file information */ int tif_mode; /* open mode (O_*) */
#define TIFF_NOBITREV 0x00100U /* inhibit bit reversal logic */ uint32_t tif_flags;
#define TIFF_MYBUFFER 0x00200U /* my raw data buffer; free on close */ #define TIFF_FILLORDER 0x00003U /* natural bit fill order for machine */
#define TIFF_ISTILED 0x00400U /* file is tile, not strip- based */ #define TIFF_DIRTYHEADER 0x00004U /* header must be written on close */
#define TIFF_MAPPED 0x00800U /* file is mapped into memory */ #define TIFF_DIRTYDIRECT 0x00008U /* current directory must be written */
#define TIFF_POSTENCODE 0x01000U /* need call to postencode routine */ #define TIFF_BUFFERSETUP 0x00010U /* data buffers setup */
#define TIFF_INSUBIFD 0x02000U /* currently writing a subifd */ #define TIFF_CODERSETUP 0x00020U /* encoder/decoder setup done */
#define TIFF_UPSAMPLED 0x04000U /* library is doing data up-sampling */ #define TIFF_BEENWRITING 0x00040U /* written 1+ scanlines to file */
#define TIFF_STRIPCHOP 0x08000U /* enable strip chopping support */ #define TIFF_SWAB 0x00080U /* byte swap file information */
#define TIFF_HEADERONLY 0x10000U /* read header only, do not process the first directory */ #define TIFF_NOBITREV 0x00100U /* inhibit bit reversal logic */
#define TIFF_NOREADRAW 0x20000U /* skip reading of raw uncompressed image data */ #define TIFF_MYBUFFER 0x00200U /* my raw data buffer; free on close */
#define TIFF_INCUSTOMIFD 0x40000U /* currently writing a custom IFD */ #define TIFF_ISTILED 0x00400U /* file is tile, not strip- based */
#define TIFF_BIGTIFF 0x80000U /* read/write bigtiff */ #define TIFF_MAPPED 0x00800U /* file is mapped into memory */
#define TIFF_BUF4WRITE 0x100000U /* rawcc bytes are for writing */ #define TIFF_POSTENCODE 0x01000U /* need call to postencode routine */
#define TIFF_DIRTYSTRIP 0x200000U /* stripoffsets/stripbytecount dirty*/ #define TIFF_INSUBIFD 0x02000U /* currently writing a subifd */
#define TIFF_PERSAMPLE 0x400000U /* get/set per sample tags as arrays */ #define TIFF_UPSAMPLED 0x04000U /* library is doing data up-sampling */
#define TIFF_BUFFERMMAP 0x800000U /* read buffer (tif_rawdata) points into mmap() memory */ #define TIFF_STRIPCHOP 0x08000U /* enable strip chopping support */
#define TIFF_DEFERSTRILELOAD 0x1000000U /* defer strip/tile offset/bytecount array loading. */ #define TIFF_HEADERONLY \
#define TIFF_LAZYSTRILELOAD 0x2000000U /* lazy/ondemand loading of strip/tile offset/bytecount values. Only used if TIFF_DEFERSTRILELOAD is set and in read-only mode */ 0x10000U /* read header only, do not process the first directory */
#define TIFF_CHOPPEDUPARRAYS 0x4000000U /* set when allocChoppedUpStripArrays() has modified strip array */ #define TIFF_NOREADRAW \
uint64_t tif_diroff; /* file offset of current directory */ 0x20000U /* skip reading of raw uncompressed image data */
uint64_t tif_nextdiroff; /* file offset of following directory */ #define TIFF_INCUSTOMIFD 0x40000U /* currently writing a custom IFD */
uint64_t tif_lastdiroff; /* file offset of last directory written so far */ #define TIFF_BIGTIFF 0x80000U /* read/write bigtiff */
uint64_t* tif_dirlist; /* list of offsets to already seen directories to prevent IFD looping */ #define TIFF_BUF4WRITE 0x100000U /* rawcc bytes are for writing */
uint16_t tif_dirlistsize; /* number of entries in offset list */ #define TIFF_DIRTYSTRIP 0x200000U /* stripoffsets/stripbytecount dirty*/
uint16_t tif_dirnumber; /* number of already seen directories */ #define TIFF_PERSAMPLE 0x400000U /* get/set per sample tags as arrays */
TIFFDirectory tif_dir; /* internal rep of current directory */ #define TIFF_BUFFERMMAP \
TIFFDirectory tif_customdir; /* custom IFDs are separated from the main ones */ 0x800000U /* read buffer (tif_rawdata) points into mmap() memory */
union { #define TIFF_DEFERSTRILELOAD \
TIFFHeaderCommon common; 0x1000000U /* defer strip/tile offset/bytecount array loading. */
TIFFHeaderClassic classic; #define TIFF_LAZYSTRILELOAD \
TIFFHeaderBig big; 0x2000000U /* lazy/ondemand loading of strip/tile offset/bytecount values. \
} tif_header; Only used if TIFF_DEFERSTRILELOAD is set and in read-only \
uint16_t tif_header_size; /* file's header block and its length */ mode */
uint32_t tif_row; /* current scanline */ #define TIFF_CHOPPEDUPARRAYS \
uint16_t tif_curdir; /* current directory (index) */ 0x4000000U /* set when allocChoppedUpStripArrays() has modified strip \
uint32_t tif_curstrip; /* current strip for read/write */ array */
uint64_t tif_curoff; /* current offset for read/write */ uint64_t tif_diroff; /* file offset of current directory */
uint64_t tif_lastvalidoff; /* last valid offset allowed for rewrite in place. Used only by TIFFAppendToStrip() */ uint64_t tif_nextdiroff; /* file offset of following directory */
uint64_t tif_dataoff; /* current offset for writing dir */ uint64_t tif_lastdiroff; /* file offset of last directory written so far */
/* SubIFD support */ uint64_t *tif_dirlistoff; /* list of offsets to already seen directories to
uint16_t tif_nsubifd; /* remaining subifds to write */ prevent IFD looping */
uint64_t tif_subifdoff; /* offset for patching SubIFD link */ TIFFHashSet *tif_map_dir_offset_to_number;
/* tiling support */ TIFFHashSet *tif_map_dir_number_to_offset;
uint32_t tif_col; /* current column (offset by row too) */ tdir_t tif_dirnumber; /* number of already seen directories */
uint32_t tif_curtile; /* current tile for read/write */ TIFFDirectory tif_dir; /* internal rep of current directory */
tmsize_t tif_tilesize; /* # of bytes in a tile */ TIFFDirectory
/* compression scheme hooks */ tif_customdir; /* custom IFDs are separated from the main ones */
int tif_decodestatus; union
TIFFBoolMethod tif_fixuptags; /* called in TIFFReadDirectory */ {
TIFFBoolMethod tif_setupdecode; /* called once before predecode */ TIFFHeaderCommon common;
TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */ TIFFHeaderClassic classic;
TIFFBoolMethod tif_setupencode; /* called once before preencode */ TIFFHeaderBig big;
int tif_encodestatus; } tif_header;
TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */ uint16_t tif_header_size; /* file's header block and its length */
TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */ uint32_t tif_row; /* current scanline */
TIFFCodeMethod tif_decoderow; /* scanline decoding routine */ tdir_t tif_curdir; /* current directory (index) */
TIFFCodeMethod tif_encoderow; /* scanline encoding routine */ uint32_t tif_curstrip; /* current strip for read/write */
TIFFCodeMethod tif_decodestrip; /* strip decoding routine */ uint64_t tif_curoff; /* current offset for read/write */
TIFFCodeMethod tif_encodestrip; /* strip encoding routine */ uint64_t tif_lastvalidoff; /* last valid offset allowed for rewrite in
TIFFCodeMethod tif_decodetile; /* tile decoding routine */ place. Used only by TIFFAppendToStrip() */
TIFFCodeMethod tif_encodetile; /* tile encoding routine */ uint64_t tif_dataoff; /* current offset for writing dir */
TIFFVoidMethod tif_close; /* cleanup-on-close routine */ /* SubIFD support */
TIFFSeekMethod tif_seek; /* position within a strip routine */ uint16_t tif_nsubifd; /* remaining subifds to write */
TIFFVoidMethod tif_cleanup; /* cleanup state routine */ uint64_t tif_subifdoff; /* offset for patching SubIFD link */
TIFFStripMethod tif_defstripsize; /* calculate/constrain strip size */ /* tiling support */
TIFFTileMethod tif_deftilesize; /* calculate/constrain tile size */ uint32_t tif_col; /* current column (offset by row too) */
uint8_t* tif_data; /* compression scheme private data */ uint32_t tif_curtile; /* current tile for read/write */
/* input/output buffering */ tmsize_t tif_tilesize; /* # of bytes in a tile */
tmsize_t tif_scanlinesize; /* # of bytes in a scanline */ /* compression scheme hooks */
tmsize_t tif_scanlineskew; /* scanline skew for reading strips */ int tif_decodestatus;
uint8_t* tif_rawdata; /* raw data buffer */ TIFFBoolMethod tif_fixuptags; /* called in TIFFReadDirectory */
tmsize_t tif_rawdatasize; /* # of bytes in raw data buffer */ TIFFBoolMethod tif_setupdecode; /* called once before predecode */
tmsize_t tif_rawdataoff; /* rawdata offset within strip */ TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */
tmsize_t tif_rawdataloaded;/* amount of data in rawdata */ TIFFBoolMethod tif_setupencode; /* called once before preencode */
uint8_t* tif_rawcp; /* current spot in raw buffer */ int tif_encodestatus;
tmsize_t tif_rawcc; /* bytes unread from raw buffer */ TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */
/* memory-mapped file support */ TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */
uint8_t* tif_base; /* base of mapped file */ TIFFCodeMethod tif_decoderow; /* scanline decoding routine */
tmsize_t tif_size; /* size of mapped file region (bytes, thus tmsize_t) */ TIFFCodeMethod tif_encoderow; /* scanline encoding routine */
TIFFMapFileProc tif_mapproc; /* map file method */ TIFFCodeMethod tif_decodestrip; /* strip decoding routine */
TIFFUnmapFileProc tif_unmapproc; /* unmap file method */ TIFFCodeMethod tif_encodestrip; /* strip encoding routine */
/* input/output callback methods */ TIFFCodeMethod tif_decodetile; /* tile decoding routine */
thandle_t tif_clientdata; /* callback parameter */ TIFFCodeMethod tif_encodetile; /* tile encoding routine */
TIFFReadWriteProc tif_readproc; /* read method */ TIFFVoidMethod tif_close; /* cleanup-on-close routine */
TIFFReadWriteProc tif_writeproc; /* write method */ TIFFSeekMethod tif_seek; /* position within a strip routine */
TIFFSeekProc tif_seekproc; /* lseek method */ TIFFVoidMethod tif_cleanup; /* cleanup state routine */
TIFFCloseProc tif_closeproc; /* close method */ TIFFStripMethod tif_defstripsize; /* calculate/constrain strip size */
TIFFSizeProc tif_sizeproc; /* filesize method */ TIFFTileMethod tif_deftilesize; /* calculate/constrain tile size */
/* post-decoding support */ uint8_t *tif_data; /* compression scheme private data */
TIFFPostMethod tif_postdecode; /* post decoding routine */ /* input/output buffering */
/* tag support */ tmsize_t tif_scanlinesize; /* # of bytes in a scanline */
TIFFField** tif_fields; /* sorted table of registered tags */ tmsize_t tif_scanlineskew; /* scanline skew for reading strips */
size_t tif_nfields; /* # entries in registered tag table */ uint8_t *tif_rawdata; /* raw data buffer */
const TIFFField* tif_foundfield; /* cached pointer to already found tag */ tmsize_t tif_rawdatasize; /* # of bytes in raw data buffer */
TIFFTagMethods tif_tagmethods; /* tag get/set/print routines */ tmsize_t tif_rawdataoff; /* rawdata offset within strip */
TIFFClientInfoLink* tif_clientinfo; /* extra client information. */ tmsize_t tif_rawdataloaded; /* amount of data in rawdata */
/* Backward compatibility stuff. We need these two fields for uint8_t *tif_rawcp; /* current spot in raw buffer */
* setting up an old tag extension scheme. */ tmsize_t tif_rawcc; /* bytes unread from raw buffer */
TIFFFieldArray* tif_fieldscompat; /* memory-mapped file support */
size_t tif_nfieldscompat; uint8_t *tif_base; /* base of mapped file */
tmsize_t tif_size; /* size of mapped file region (bytes, thus tmsize_t) */
TIFFMapFileProc tif_mapproc; /* map file method */
TIFFUnmapFileProc tif_unmapproc; /* unmap file method */
/* input/output callback methods */
thandle_t tif_clientdata; /* callback parameter */
TIFFReadWriteProc tif_readproc; /* read method */
TIFFReadWriteProc tif_writeproc; /* write method */
TIFFSeekProc tif_seekproc; /* lseek method */
TIFFCloseProc tif_closeproc; /* close method */
TIFFSizeProc tif_sizeproc; /* filesize method */
/* post-decoding support */
TIFFPostMethod tif_postdecode; /* post decoding routine */
/* tag support */
TIFFField **tif_fields; /* sorted table of registered tags */
size_t tif_nfields; /* # entries in registered tag table */
const TIFFField *tif_foundfield; /* cached pointer to already found tag */
TIFFTagMethods tif_tagmethods; /* tag get/set/print routines */
TIFFClientInfoLink *tif_clientinfo; /* extra client information. */
/* Backward compatibility stuff. We need these two fields for
* setting up an old tag extension scheme. */
TIFFFieldArray *tif_fieldscompat;
size_t tif_nfieldscompat;
/* Error handler support */
TIFFErrorHandlerExtR tif_errorhandler;
void *tif_errorhandler_user_data;
TIFFErrorHandlerExtR tif_warnhandler;
void *tif_warnhandler_user_data;
tmsize_t tif_max_single_mem_alloc; /* in bytes. 0 for unlimited */
}; };
#define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */ struct TIFFOpenOptions
{
TIFFErrorHandlerExtR errorhandler; /* may be NULL */
void *errorhandler_user_data; /* may be NULL */
TIFFErrorHandlerExtR warnhandler; /* may be NULL */
void *warnhandler_user_data; /* may be NULL */
tmsize_t max_single_mem_alloc; /* in bytes. 0 for unlimited */
};
#define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */
#define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0) #define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0)
#define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0) #define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0)
#define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0) #define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0)
#define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0) #define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0)
#define TIFFReadFile(tif, buf, size) \ #define TIFFReadFile(tif, buf, size) \
((*(tif)->tif_readproc)((tif)->tif_clientdata,(buf),(size))) ((*(tif)->tif_readproc)((tif)->tif_clientdata, (buf), (size)))
#define TIFFWriteFile(tif, buf, size) \ #define TIFFWriteFile(tif, buf, size) \
((*(tif)->tif_writeproc)((tif)->tif_clientdata,(buf),(size))) ((*(tif)->tif_writeproc)((tif)->tif_clientdata, (buf), (size)))
#define TIFFSeekFile(tif, off, whence) \ #define TIFFSeekFile(tif, off, whence) \
((*(tif)->tif_seekproc)((tif)->tif_clientdata,(off),(whence))) ((*(tif)->tif_seekproc)((tif)->tif_clientdata, (off), (whence)))
#define TIFFCloseFile(tif) \ #define TIFFCloseFile(tif) ((*(tif)->tif_closeproc)((tif)->tif_clientdata))
((*(tif)->tif_closeproc)((tif)->tif_clientdata)) #define TIFFGetFileSize(tif) ((*(tif)->tif_sizeproc)((tif)->tif_clientdata))
#define TIFFGetFileSize(tif) \ #define TIFFMapFileContents(tif, paddr, psize) \
((*(tif)->tif_sizeproc)((tif)->tif_clientdata)) ((*(tif)->tif_mapproc)((tif)->tif_clientdata, (paddr), (psize)))
#define TIFFMapFileContents(tif, paddr, psize) \ #define TIFFUnmapFileContents(tif, addr, size) \
((*(tif)->tif_mapproc)((tif)->tif_clientdata,(paddr),(psize))) ((*(tif)->tif_unmapproc)((tif)->tif_clientdata, (addr), (size)))
#define TIFFUnmapFileContents(tif, addr, size) \
((*(tif)->tif_unmapproc)((tif)->tif_clientdata,(addr),(size)))
/* /*
* Default Read/Seek/Write definitions. * Default Read/Seek/Write definitions.
*/ */
#ifndef ReadOK #ifndef ReadOK
#define ReadOK(tif, buf, size) \ #define ReadOK(tif, buf, size) (TIFFReadFile((tif), (buf), (size)) == (size))
(TIFFReadFile((tif),(buf),(size))==(size))
#endif #endif
#ifndef SeekOK #ifndef SeekOK
#define SeekOK(tif, off) _TIFFSeekOK(tif, off) #define SeekOK(tif, off) _TIFFSeekOK(tif, off)
#endif #endif
#ifndef WriteOK #ifndef WriteOK
#define WriteOK(tif, buf, size) \ #define WriteOK(tif, buf, size) (TIFFWriteFile((tif), (buf), (size)) == (size))
(TIFFWriteFile((tif),(buf),(size))==(size))
#endif #endif
/* NB: the uint32_t casts are to silence certain ANSI-C compilers */ /* NB: the uint32_t casts are to silence certain ANSI-C compilers */
#define TIFFhowmany_32(x, y) (((uint32_t)x < (0xffffffff - (uint32_t)(y-1))) ? \ #define TIFFhowmany_32(x, y) \
((((uint32_t)(x))+(((uint32_t)(y))-1))/((uint32_t)(y))) : \ (((uint32_t)x < (0xffffffff - (uint32_t)(y - 1))) \
0U) ? ((((uint32_t)(x)) + (((uint32_t)(y)) - 1)) / ((uint32_t)(y))) \
: 0U)
/* Variant of TIFFhowmany_32() that doesn't return 0 if x close to MAXUINT. */ /* Variant of TIFFhowmany_32() that doesn't return 0 if x close to MAXUINT. */
/* Caution: TIFFhowmany_32_maxuint_compat(x,y)*y might overflow */ /* Caution: TIFFhowmany_32_maxuint_compat(x,y)*y might overflow */
#define TIFFhowmany_32_maxuint_compat(x, y) \ #define TIFFhowmany_32_maxuint_compat(x, y) \
(((uint32_t)(x) / (uint32_t)(y)) + ((((uint32_t)(x) % (uint32_t)(y)) != 0) ? 1 : 0)) (((uint32_t)(x) / (uint32_t)(y)) + \
#define TIFFhowmany8_32(x) (((x)&0x07)?((uint32_t)(x)>>3)+1:(uint32_t)(x)>>3) ((((uint32_t)(x) % (uint32_t)(y)) != 0) ? 1 : 0))
#define TIFFroundup_32(x, y) (TIFFhowmany_32(x,y)*(y)) #define TIFFhowmany8_32(x) \
#define TIFFhowmany_64(x, y) ((((uint64_t)(x))+(((uint64_t)(y))-1))/((uint64_t)(y))) (((x)&0x07) ? ((uint32_t)(x) >> 3) + 1 : (uint32_t)(x) >> 3)
#define TIFFhowmany8_64(x) (((x)&0x07)?((uint64_t)(x)>>3)+1:(uint64_t)(x)>>3) #define TIFFroundup_32(x, y) (TIFFhowmany_32(x, y) * (y))
#define TIFFroundup_64(x, y) (TIFFhowmany_64(x,y)*(y)) #define TIFFhowmany_64(x, y) \
((((uint64_t)(x)) + (((uint64_t)(y)) - 1)) / ((uint64_t)(y)))
#define TIFFhowmany8_64(x) \
(((x)&0x07) ? ((uint64_t)(x) >> 3) + 1 : (uint64_t)(x) >> 3)
#define TIFFroundup_64(x, y) (TIFFhowmany_64(x, y) * (y))
/* Safe multiply which returns zero if there is an *unsigned* integer overflow. This macro is not safe for *signed* integer types */ /* Safe multiply which returns zero if there is an *unsigned* integer overflow.
#define TIFFSafeMultiply(t,v,m) ((((t)(m) != (t)0) && (((t)(((v)*(m))/(m))) == (t)(v))) ? (t)((v)*(m)) : (t)0) * This macro is not safe for *signed* integer types */
#define TIFFSafeMultiply(t, v, m) \
((((t)(m) != (t)0) && (((t)(((v) * (m)) / (m))) == (t)(v))) \
? (t)((v) * (m)) \
: (t)0)
#define TIFFmax(A,B) ((A)>(B)?(A):(B)) #define TIFFmax(A, B) ((A) > (B) ? (A) : (B))
#define TIFFmin(A,B) ((A)<(B)?(A):(B)) #define TIFFmin(A, B) ((A) < (B) ? (A) : (B))
#define TIFFArrayCount(a) (sizeof (a) / sizeof ((a)[0])) #define TIFFArrayCount(a) (sizeof(a) / sizeof((a)[0]))
/* /*
Support for large files. Support for large files.
@ -275,28 +328,31 @@ struct tiff {
must be available on the target computer in order for the program to run. must be available on the target computer in order for the program to run.
*/ */
#if defined(HAVE_FSEEKO) #if defined(HAVE_FSEEKO)
# define fseek(stream,offset,whence) fseeko(stream,offset,whence) #define fseek(stream, offset, whence) fseeko(stream, offset, whence)
# define ftell(stream,offset,whence) ftello(stream,offset,whence) #define ftell(stream, offset, whence) ftello(stream, offset, whence)
#endif #endif
#endif #endif
#if defined(__WIN32__) && \ #if defined(__WIN32__) && !(defined(_MSC_VER) && _MSC_VER < 1400) && \
!(defined(_MSC_VER) && _MSC_VER < 1400) && \ !(defined(__MSVCRT_VERSION__) && __MSVCRT_VERSION__ < 0x800)
!(defined(__MSVCRT_VERSION__) && __MSVCRT_VERSION__ < 0x800)
typedef unsigned int TIFFIOSize_t; typedef unsigned int TIFFIOSize_t;
#define _TIFF_lseek_f(fildes,offset,whence) _lseeki64(fildes,/* __int64 */ offset,whence) #define _TIFF_lseek_f(fildes, offset, whence) \
_lseeki64(fildes, /* __int64 */ offset, whence)
/* #define _TIFF_tell_f(fildes) /\* __int64 *\/ _telli64(fildes) */ /* #define _TIFF_tell_f(fildes) /\* __int64 *\/ _telli64(fildes) */
#define _TIFF_fseek_f(stream,offset,whence) _fseeki64(stream,/* __int64 */ offset,whence) #define _TIFF_fseek_f(stream, offset, whence) \
#define _TIFF_fstat_f(fildes,stat_buff) _fstati64(fildes,/* struct _stati64 */ stat_buff) _fseeki64(stream, /* __int64 */ offset, whence)
#define _TIFF_fstat_f(fildes, stat_buff) \
_fstati64(fildes, /* struct _stati64 */ stat_buff)
/* #define _TIFF_ftell_f(stream) /\* __int64 *\/ _ftelli64(stream) */ /* #define _TIFF_ftell_f(stream) /\* __int64 *\/ _ftelli64(stream) */
/* #define _TIFF_stat_f(path,stat_buff) _stati64(path,/\* struct _stati64 *\/ stat_buff) */ /* #define _TIFF_stat_f(path,stat_buff) _stati64(path,/\* struct _stati64 *\/
* stat_buff) */
#define _TIFF_stat_s struct _stati64 #define _TIFF_stat_s struct _stati64
#define _TIFF_off_t __int64 #define _TIFF_off_t __int64
#else #else
typedef size_t TIFFIOSize_t; typedef size_t TIFFIOSize_t;
#define _TIFF_lseek_f(fildes,offset,whence) lseek(fildes,offset,whence) #define _TIFF_lseek_f(fildes, offset, whence) lseek(fildes, offset, whence)
/* #define _TIFF_tell_f(fildes) (_TIFF_lseek_f(fildes,0,SEEK_CUR)) */ /* #define _TIFF_tell_f(fildes) (_TIFF_lseek_f(fildes,0,SEEK_CUR)) */
#define _TIFF_fseek_f(stream,offset,whence) fseek(stream,offset,whence) #define _TIFF_fseek_f(stream, offset, whence) fseek(stream, offset, whence)
#define _TIFF_fstat_f(fildes,stat_buff) fstat(fildes,stat_buff) #define _TIFF_fstat_f(fildes, stat_buff) fstat(fildes, stat_buff)
/* #define _TIFF_ftell_f(stream) ftell(stream) */ /* #define _TIFF_ftell_f(stream) ftell(stream) */
/* #define _TIFF_stat_f(path,stat_buff) stat(path,stat_buff) */ /* #define _TIFF_stat_f(path,stat_buff) stat(path,stat_buff) */
#define _TIFF_stat_s struct stat #define _TIFF_stat_s struct stat
@ -305,7 +361,8 @@ typedef size_t TIFFIOSize_t;
#if defined(__has_attribute) && defined(__clang__) #if defined(__has_attribute) && defined(__clang__)
#if __has_attribute(no_sanitize) #if __has_attribute(no_sanitize)
#define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW __attribute__((no_sanitize("unsigned-integer-overflow"))) #define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW \
__attribute__((no_sanitize("unsigned-integer-overflow")))
#else #else
#define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW #define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW
#endif #endif
@ -313,133 +370,153 @@ typedef size_t TIFFIOSize_t;
#define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW #define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW
#endif #endif
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C"
{
#endif #endif
extern int _TIFFgetMode(const char* mode, const char* module); extern int _TIFFgetMode(TIFFOpenOptions *opts, thandle_t clientdata,
extern int _TIFFNoRowEncode(TIFF* tif, uint8_t* pp, tmsize_t cc, uint16_t s); const char *mode, const char *module);
extern int _TIFFNoStripEncode(TIFF* tif, uint8_t* pp, tmsize_t cc, uint16_t s); extern int _TIFFNoRowEncode(TIFF *tif, uint8_t *pp, tmsize_t cc,
extern int _TIFFNoTileEncode(TIFF*, uint8_t* pp, tmsize_t cc, uint16_t s); uint16_t s);
extern int _TIFFNoRowDecode(TIFF* tif, uint8_t* pp, tmsize_t cc, uint16_t s); extern int _TIFFNoStripEncode(TIFF *tif, uint8_t *pp, tmsize_t cc,
extern int _TIFFNoStripDecode(TIFF* tif, uint8_t* pp, tmsize_t cc, uint16_t s); uint16_t s);
extern int _TIFFNoTileDecode(TIFF*, uint8_t* pp, tmsize_t cc, uint16_t s); extern int _TIFFNoTileEncode(TIFF *, uint8_t *pp, tmsize_t cc, uint16_t s);
extern void _TIFFNoPostDecode(TIFF* tif, uint8_t* buf, tmsize_t cc); extern int _TIFFNoRowDecode(TIFF *tif, uint8_t *pp, tmsize_t cc,
extern int _TIFFNoPreCode(TIFF* tif, uint16_t s); uint16_t s);
extern int _TIFFNoSeek(TIFF* tif, uint32_t off); extern int _TIFFNoStripDecode(TIFF *tif, uint8_t *pp, tmsize_t cc,
extern void _TIFFSwab16BitData(TIFF* tif, uint8_t* buf, tmsize_t cc); uint16_t s);
extern void _TIFFSwab24BitData(TIFF* tif, uint8_t* buf, tmsize_t cc); extern int _TIFFNoTileDecode(TIFF *, uint8_t *pp, tmsize_t cc, uint16_t s);
extern void _TIFFSwab32BitData(TIFF* tif, uint8_t* buf, tmsize_t cc); extern void _TIFFNoPostDecode(TIFF *tif, uint8_t *buf, tmsize_t cc);
extern void _TIFFSwab64BitData(TIFF* tif, uint8_t* buf, tmsize_t cc); extern int _TIFFNoPreCode(TIFF *tif, uint16_t s);
extern int TIFFFlushData1(TIFF* tif); extern int _TIFFNoSeek(TIFF *tif, uint32_t off);
extern int TIFFDefaultDirectory(TIFF* tif); extern void _TIFFSwab16BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
extern void _TIFFSetDefaultCompressionState(TIFF* tif); extern void _TIFFSwab24BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
extern int _TIFFRewriteField(TIFF *, uint16_t, TIFFDataType, tmsize_t, void *); extern void _TIFFSwab32BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
extern int TIFFSetCompressionScheme(TIFF* tif, int scheme); extern void _TIFFSwab64BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
extern int TIFFSetDefaultCompressionState(TIFF* tif); extern int TIFFFlushData1(TIFF *tif);
extern uint32_t _TIFFDefaultStripSize(TIFF* tif, uint32_t s); extern int TIFFDefaultDirectory(TIFF *tif);
extern void _TIFFDefaultTileSize(TIFF* tif, uint32_t* tw, uint32_t* th); extern void _TIFFSetDefaultCompressionState(TIFF *tif);
extern int _TIFFRewriteField(TIFF *, uint16_t, TIFFDataType, tmsize_t,
void *);
extern int TIFFSetCompressionScheme(TIFF *tif, int scheme);
extern int TIFFSetDefaultCompressionState(TIFF *tif);
extern uint32_t _TIFFDefaultStripSize(TIFF *tif, uint32_t s);
extern void _TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th);
extern void _TIFFsetByteArray(void**, const void*, uint32_t); extern void _TIFFsetByteArray(void **, const void *, uint32_t);
extern void _TIFFsetShortArray(uint16_t**, const uint16_t*, uint32_t); extern void _TIFFsetByteArrayExt(TIFF *, void **, const void *, uint32_t);
extern void _TIFFsetLongArray(uint32_t**, const uint32_t*, uint32_t); extern void _TIFFsetShortArray(uint16_t **, const uint16_t *, uint32_t);
extern void _TIFFsetFloatArray(float**, const float*, uint32_t); extern void _TIFFsetShortArrayExt(TIFF *, uint16_t **, const uint16_t *,
extern void _TIFFsetDoubleArray(double**, const double*, uint32_t); uint32_t);
extern void _TIFFsetLongArray(uint32_t **, const uint32_t *, uint32_t);
extern void _TIFFsetLongArrayExt(TIFF *, uint32_t **, const uint32_t *,
uint32_t);
extern void _TIFFsetFloatArray(float **, const float *, uint32_t);
extern void _TIFFsetFloatArrayExt(TIFF *, float **, const float *,
uint32_t);
extern void _TIFFsetDoubleArray(double **, const double *, uint32_t);
extern void _TIFFsetDoubleArrayExt(TIFF *, double **, const double *,
uint32_t);
extern void _TIFFprintAscii(FILE*, const char*); extern void _TIFFprintAscii(FILE *, const char *);
extern void _TIFFprintAsciiTag(FILE*, const char*, const char*); extern void _TIFFprintAsciiTag(FILE *, const char *, const char *);
extern TIFFErrorHandler _TIFFwarningHandler; extern TIFFErrorHandler _TIFFwarningHandler;
extern TIFFErrorHandler _TIFFerrorHandler; extern TIFFErrorHandler _TIFFerrorHandler;
extern TIFFErrorHandlerExt _TIFFwarningHandlerExt; extern TIFFErrorHandlerExt _TIFFwarningHandlerExt;
extern TIFFErrorHandlerExt _TIFFerrorHandlerExt; extern TIFFErrorHandlerExt _TIFFerrorHandlerExt;
void _TIFFErrorEarly(TIFFOpenOptions *opts, thandle_t clientdata,
const char *module, const char *fmt, ...)
TIFF_ATTRIBUTE((__format__(__printf__, 4, 5)));
extern uint32_t _TIFFMultiply32(TIFF*, uint32_t, uint32_t, const char*); extern uint32_t _TIFFMultiply32(TIFF *, uint32_t, uint32_t, const char *);
extern uint64_t _TIFFMultiply64(TIFF*, uint64_t, uint64_t, const char*); extern uint64_t _TIFFMultiply64(TIFF *, uint64_t, uint64_t, const char *);
extern tmsize_t _TIFFMultiplySSize(TIFF*, tmsize_t, tmsize_t, const char*); extern tmsize_t _TIFFMultiplySSize(TIFF *, tmsize_t, tmsize_t,
extern tmsize_t _TIFFCastUInt64ToSSize(TIFF*, uint64_t, const char*); const char *);
extern void* _TIFFCheckMalloc(TIFF*, tmsize_t, tmsize_t, const char*); extern tmsize_t _TIFFCastUInt64ToSSize(TIFF *, uint64_t, const char *);
extern void* _TIFFCheckRealloc(TIFF*, void*, tmsize_t, tmsize_t, const char*); extern void *_TIFFCheckMalloc(TIFF *, tmsize_t, tmsize_t, const char *);
extern void *_TIFFCheckRealloc(TIFF *, void *, tmsize_t, tmsize_t,
const char *);
extern double _TIFFUInt64ToDouble(uint64_t); extern double _TIFFUInt64ToDouble(uint64_t);
extern float _TIFFUInt64ToFloat(uint64_t); extern float _TIFFUInt64ToFloat(uint64_t);
extern float _TIFFClampDoubleToFloat(double); extern float _TIFFClampDoubleToFloat(double);
extern uint32_t _TIFFClampDoubleToUInt32(double);
extern tmsize_t extern tmsize_t _TIFFReadEncodedStripAndAllocBuffer(TIFF *tif,
_TIFFReadEncodedStripAndAllocBuffer(TIFF* tif, uint32_t strip, uint32_t strip,
void **buf, tmsize_t bufsizetoalloc, void **buf,
tmsize_t size_to_read); tmsize_t bufsizetoalloc,
extern tmsize_t tmsize_t size_to_read);
_TIFFReadEncodedTileAndAllocBuffer(TIFF* tif, uint32_t tile, extern tmsize_t _TIFFReadEncodedTileAndAllocBuffer(TIFF *tif, uint32_t tile,
void **buf, tmsize_t bufsizetoalloc, void **buf,
tmsize_t size_to_read); tmsize_t bufsizetoalloc,
extern tmsize_t tmsize_t size_to_read);
_TIFFReadTileAndAllocBuffer(TIFF* tif, extern tmsize_t _TIFFReadTileAndAllocBuffer(TIFF *tif, void **buf,
void **buf, tmsize_t bufsizetoalloc, tmsize_t bufsizetoalloc,
uint32_t x, uint32_t y, uint32_t z, uint16_t s); uint32_t x, uint32_t y,
extern int _TIFFSeekOK(TIFF* tif, toff_t off); uint32_t z, uint16_t s);
extern int _TIFFSeekOK(TIFF *tif, toff_t off);
extern int TIFFInitDumpMode(TIFF*, int); extern int TIFFInitDumpMode(TIFF *, int);
#ifdef PACKBITS_SUPPORT #ifdef PACKBITS_SUPPORT
extern int TIFFInitPackBits(TIFF*, int); extern int TIFFInitPackBits(TIFF *, int);
#endif #endif
#ifdef CCITT_SUPPORT #ifdef CCITT_SUPPORT
extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int); extern int TIFFInitCCITTRLE(TIFF *, int), TIFFInitCCITTRLEW(TIFF *, int);
extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int); extern int TIFFInitCCITTFax3(TIFF *, int), TIFFInitCCITTFax4(TIFF *, int);
#endif #endif
#ifdef THUNDER_SUPPORT #ifdef THUNDER_SUPPORT
extern int TIFFInitThunderScan(TIFF*, int); extern int TIFFInitThunderScan(TIFF *, int);
#endif #endif
#ifdef NEXT_SUPPORT #ifdef NEXT_SUPPORT
extern int TIFFInitNeXT(TIFF*, int); extern int TIFFInitNeXT(TIFF *, int);
#endif #endif
#ifdef LZW_SUPPORT #ifdef LZW_SUPPORT
extern int TIFFInitLZW(TIFF*, int); extern int TIFFInitLZW(TIFF *, int);
#endif #endif
#ifdef OJPEG_SUPPORT #ifdef OJPEG_SUPPORT
extern int TIFFInitOJPEG(TIFF*, int); extern int TIFFInitOJPEG(TIFF *, int);
#endif #endif
#ifdef JPEG_SUPPORT #ifdef JPEG_SUPPORT
extern int TIFFInitJPEG(TIFF*, int); extern int TIFFInitJPEG(TIFF *, int);
extern int TIFFJPEGIsFullStripRequired(TIFF*); extern int TIFFJPEGIsFullStripRequired(TIFF *);
#endif #endif
#ifdef JBIG_SUPPORT #ifdef JBIG_SUPPORT
extern int TIFFInitJBIG(TIFF*, int); extern int TIFFInitJBIG(TIFF *, int);
#endif #endif
#ifdef ZIP_SUPPORT #ifdef ZIP_SUPPORT
extern int TIFFInitZIP(TIFF*, int); extern int TIFFInitZIP(TIFF *, int);
#endif #endif
#ifdef PIXARLOG_SUPPORT #ifdef PIXARLOG_SUPPORT
extern int TIFFInitPixarLog(TIFF*, int); extern int TIFFInitPixarLog(TIFF *, int);
#endif #endif
#ifdef LOGLUV_SUPPORT #ifdef LOGLUV_SUPPORT
extern int TIFFInitSGILog(TIFF*, int); extern int TIFFInitSGILog(TIFF *, int);
#endif #endif
#ifdef LERC_SUPPORT #ifdef LERC_SUPPORT
extern int TIFFInitLERC(TIFF* tif, int); extern int TIFFInitLERC(TIFF *tif, int);
#endif #endif
#ifdef LZMA_SUPPORT #ifdef LZMA_SUPPORT
extern int TIFFInitLZMA(TIFF*, int); extern int TIFFInitLZMA(TIFF *, int);
#endif #endif
#ifdef ZSTD_SUPPORT #ifdef ZSTD_SUPPORT
extern int TIFFInitZSTD(TIFF*, int); extern int TIFFInitZSTD(TIFF *, int);
#endif #endif
#ifdef WEBP_SUPPORT #ifdef WEBP_SUPPORT
extern int TIFFInitWebP(TIFF*, int); extern int TIFFInitWebP(TIFF *, int);
#endif #endif
extern const TIFFCodec _TIFFBuiltinCODECS[]; extern const TIFFCodec _TIFFBuiltinCODECS[];
extern void TIFFCIELab16ToXYZ(TIFFCIELabToRGB *, uint32_t l, int32_t a,
int32_t b, float *, float *, float *);
extern void *_TIFFmallocExt(TIFF *tif, tmsize_t s);
extern void *_TIFFcallocExt(TIFF *tif, tmsize_t nmemb, tmsize_t siz);
extern void *_TIFFreallocExt(TIFF *tif, void *p, tmsize_t s);
extern void _TIFFfreeExt(TIFF *tif, void *p);
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif #endif
#endif /* _TIFFIOP_ */ #endif /* _TIFFIOP_ */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

25
libs/tiff/libtiff/tiffvers.h
View file

@ -1,4 +1,9 @@
#define TIFFLIB_VERSION_STR "LIBTIFF, Version 4.4.0\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc." /* clang-format off */
/* clang-format disabled because FindTIFF.cmake is very sensitive to the
* formatting of below line being a single line.
*/
#define TIFFLIB_VERSION_STR "LIBTIFF, Version 4.5.0\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
/* /*
* This define can be used in code that requires * This define can be used in code that requires
* compilation-related definitions specific to a * compilation-related definitions specific to a
@ -6,4 +11,20 @@
* version checking should be done based on the * version checking should be done based on the
* string returned by TIFFGetVersion. * string returned by TIFFGetVersion.
*/ */
#define TIFFLIB_VERSION 20220520 #define TIFFLIB_VERSION 20221213
/* The following defines have been added in 4.5.0 */
#define TIFFLIB_MAJOR_VERSION 4
#define TIFFLIB_MINOR_VERSION 5
#define TIFFLIB_MICRO_VERSION 0
/* Macro added in 4.5.0. Returns TRUE if the current libtiff version is
* greater or equal to major.minor.micro
*/
#define TIFFLIB_AT_LEAST(major, minor, micro) \
(TIFFLIB_MAJOR_VERSION > (major) || \
(TIFFLIB_MAJOR_VERSION == (major) && TIFFLIB_MINOR_VERSION > (minor)) || \
(TIFFLIB_MAJOR_VERSION == (major) && TIFFLIB_MINOR_VERSION == (minor) && \
TIFFLIB_MICRO_VERSION >= (micro)))
/* clang-format on */

269
libs/tiff/libtiff/uvcode.h
View file

@ -1,180 +1,93 @@
/* Version 1.0 generated April 7, 1997 by Greg Ward Larson, SGI */ /* Version 1.0 generated April 7, 1997 by Greg Ward Larson, SGI */
#define UV_SQSIZ (float)0.003500 #define UV_SQSIZ (float)0.003500
#define UV_NDIVS 16289 #define UV_NDIVS 16289
#define UV_VSTART (float)0.016940 #define UV_VSTART (float)0.016940
#define UV_NVS 163 #define UV_NVS 163
static const struct { static const struct
float ustart; {
short nus, ncum; float ustart;
} uv_row[UV_NVS] = { short nus, ncum;
{ (float)0.247663, 4, 0 }, } uv_row[UV_NVS] = {
{ (float)0.243779, 6, 4 }, {(float)0.247663, 4, 0}, {(float)0.243779, 6, 4},
{ (float)0.241684, 7, 10 }, {(float)0.241684, 7, 10}, {(float)0.237874, 9, 17},
{ (float)0.237874, 9, 17 }, {(float)0.235906, 10, 26}, {(float)0.232153, 12, 36},
{ (float)0.235906, 10, 26 }, {(float)0.228352, 14, 48}, {(float)0.226259, 15, 62},
{ (float)0.232153, 12, 36 }, {(float)0.222371, 17, 77}, {(float)0.220410, 18, 94},
{ (float)0.228352, 14, 48 }, {(float)0.214710, 21, 112}, {(float)0.212714, 22, 133},
{ (float)0.226259, 15, 62 }, {(float)0.210721, 23, 155}, {(float)0.204976, 26, 178},
{ (float)0.222371, 17, 77 }, {(float)0.202986, 27, 204}, {(float)0.199245, 29, 231},
{ (float)0.220410, 18, 94 }, {(float)0.195525, 31, 260}, {(float)0.193560, 32, 291},
{ (float)0.214710, 21, 112 }, {(float)0.189878, 34, 323}, {(float)0.186216, 36, 357},
{ (float)0.212714, 22, 133 }, {(float)0.186216, 36, 393}, {(float)0.182592, 38, 429},
{ (float)0.210721, 23, 155 }, {(float)0.179003, 40, 467}, {(float)0.175466, 42, 507},
{ (float)0.204976, 26, 178 }, {(float)0.172001, 44, 549}, {(float)0.172001, 44, 593},
{ (float)0.202986, 27, 204 }, {(float)0.168612, 46, 637}, {(float)0.168612, 46, 683},
{ (float)0.199245, 29, 231 }, {(float)0.163575, 49, 729}, {(float)0.158642, 52, 778},
{ (float)0.195525, 31, 260 }, {(float)0.158642, 52, 830}, {(float)0.158642, 52, 882},
{ (float)0.193560, 32, 291 }, {(float)0.153815, 55, 934}, {(float)0.153815, 55, 989},
{ (float)0.189878, 34, 323 }, {(float)0.149097, 58, 1044}, {(float)0.149097, 58, 1102},
{ (float)0.186216, 36, 357 }, {(float)0.142746, 62, 1160}, {(float)0.142746, 62, 1222},
{ (float)0.186216, 36, 393 }, {(float)0.142746, 62, 1284}, {(float)0.138270, 65, 1346},
{ (float)0.182592, 38, 429 }, {(float)0.138270, 65, 1411}, {(float)0.138270, 65, 1476},
{ (float)0.179003, 40, 467 }, {(float)0.132166, 69, 1541}, {(float)0.132166, 69, 1610},
{ (float)0.175466, 42, 507 }, {(float)0.126204, 73, 1679}, {(float)0.126204, 73, 1752},
{ (float)0.172001, 44, 549 }, {(float)0.126204, 73, 1825}, {(float)0.120381, 77, 1898},
{ (float)0.172001, 44, 593 }, {(float)0.120381, 77, 1975}, {(float)0.120381, 77, 2052},
{ (float)0.168612, 46, 637 }, {(float)0.120381, 77, 2129}, {(float)0.112962, 82, 2206},
{ (float)0.168612, 46, 683 }, {(float)0.112962, 82, 2288}, {(float)0.112962, 82, 2370},
{ (float)0.163575, 49, 729 }, {(float)0.107450, 86, 2452}, {(float)0.107450, 86, 2538},
{ (float)0.158642, 52, 778 }, {(float)0.107450, 86, 2624}, {(float)0.107450, 86, 2710},
{ (float)0.158642, 52, 830 }, {(float)0.100343, 91, 2796}, {(float)0.100343, 91, 2887},
{ (float)0.158642, 52, 882 }, {(float)0.100343, 91, 2978}, {(float)0.095126, 95, 3069},
{ (float)0.153815, 55, 934 }, {(float)0.095126, 95, 3164}, {(float)0.095126, 95, 3259},
{ (float)0.153815, 55, 989 }, {(float)0.095126, 95, 3354}, {(float)0.088276, 100, 3449},
{ (float)0.149097, 58, 1044 }, {(float)0.088276, 100, 3549}, {(float)0.088276, 100, 3649},
{ (float)0.149097, 58, 1102 }, {(float)0.088276, 100, 3749}, {(float)0.081523, 105, 3849},
{ (float)0.142746, 62, 1160 }, {(float)0.081523, 105, 3954}, {(float)0.081523, 105, 4059},
{ (float)0.142746, 62, 1222 }, {(float)0.081523, 105, 4164}, {(float)0.074861, 110, 4269},
{ (float)0.142746, 62, 1284 }, {(float)0.074861, 110, 4379}, {(float)0.074861, 110, 4489},
{ (float)0.138270, 65, 1346 }, {(float)0.074861, 110, 4599}, {(float)0.068290, 115, 4709},
{ (float)0.138270, 65, 1411 }, {(float)0.068290, 115, 4824}, {(float)0.068290, 115, 4939},
{ (float)0.138270, 65, 1476 }, {(float)0.068290, 115, 5054}, {(float)0.063573, 119, 5169},
{ (float)0.132166, 69, 1541 }, {(float)0.063573, 119, 5288}, {(float)0.063573, 119, 5407},
{ (float)0.132166, 69, 1610 }, {(float)0.063573, 119, 5526}, {(float)0.057219, 124, 5645},
{ (float)0.126204, 73, 1679 }, {(float)0.057219, 124, 5769}, {(float)0.057219, 124, 5893},
{ (float)0.126204, 73, 1752 }, {(float)0.057219, 124, 6017}, {(float)0.050985, 129, 6141},
{ (float)0.126204, 73, 1825 }, {(float)0.050985, 129, 6270}, {(float)0.050985, 129, 6399},
{ (float)0.120381, 77, 1898 }, {(float)0.050985, 129, 6528}, {(float)0.050985, 129, 6657},
{ (float)0.120381, 77, 1975 }, {(float)0.044859, 134, 6786}, {(float)0.044859, 134, 6920},
{ (float)0.120381, 77, 2052 }, {(float)0.044859, 134, 7054}, {(float)0.044859, 134, 7188},
{ (float)0.120381, 77, 2129 }, {(float)0.040571, 138, 7322}, {(float)0.040571, 138, 7460},
{ (float)0.112962, 82, 2206 }, {(float)0.040571, 138, 7598}, {(float)0.040571, 138, 7736},
{ (float)0.112962, 82, 2288 }, {(float)0.036339, 142, 7874}, {(float)0.036339, 142, 8016},
{ (float)0.112962, 82, 2370 }, {(float)0.036339, 142, 8158}, {(float)0.036339, 142, 8300},
{ (float)0.107450, 86, 2452 }, {(float)0.032139, 146, 8442}, {(float)0.032139, 146, 8588},
{ (float)0.107450, 86, 2538 }, {(float)0.032139, 146, 8734}, {(float)0.032139, 146, 8880},
{ (float)0.107450, 86, 2624 }, {(float)0.027947, 150, 9026}, {(float)0.027947, 150, 9176},
{ (float)0.107450, 86, 2710 }, {(float)0.027947, 150, 9326}, {(float)0.023739, 154, 9476},
{ (float)0.100343, 91, 2796 }, {(float)0.023739, 154, 9630}, {(float)0.023739, 154, 9784},
{ (float)0.100343, 91, 2887 }, {(float)0.023739, 154, 9938}, {(float)0.019504, 158, 10092},
{ (float)0.100343, 91, 2978 }, {(float)0.019504, 158, 10250}, {(float)0.019504, 158, 10408},
{ (float)0.095126, 95, 3069 }, {(float)0.016976, 161, 10566}, {(float)0.016976, 161, 10727},
{ (float)0.095126, 95, 3164 }, {(float)0.016976, 161, 10888}, {(float)0.016976, 161, 11049},
{ (float)0.095126, 95, 3259 }, {(float)0.012639, 165, 11210}, {(float)0.012639, 165, 11375},
{ (float)0.095126, 95, 3354 }, {(float)0.012639, 165, 11540}, {(float)0.009991, 168, 11705},
{ (float)0.088276, 100, 3449 }, {(float)0.009991, 168, 11873}, {(float)0.009991, 168, 12041},
{ (float)0.088276, 100, 3549 }, {(float)0.009016, 170, 12209}, {(float)0.009016, 170, 12379},
{ (float)0.088276, 100, 3649 }, {(float)0.009016, 170, 12549}, {(float)0.006217, 173, 12719},
{ (float)0.088276, 100, 3749 }, {(float)0.006217, 173, 12892}, {(float)0.005097, 175, 13065},
{ (float)0.081523, 105, 3849 }, {(float)0.005097, 175, 13240}, {(float)0.005097, 175, 13415},
{ (float)0.081523, 105, 3954 }, {(float)0.003909, 177, 13590}, {(float)0.003909, 177, 13767},
{ (float)0.081523, 105, 4059 }, {(float)0.002340, 177, 13944}, {(float)0.002389, 170, 14121},
{ (float)0.081523, 105, 4164 }, {(float)0.001068, 164, 14291}, {(float)0.001653, 157, 14455},
{ (float)0.074861, 110, 4269 }, {(float)0.000717, 150, 14612}, {(float)0.001614, 143, 14762},
{ (float)0.074861, 110, 4379 }, {(float)0.000270, 136, 14905}, {(float)0.000484, 129, 15041},
{ (float)0.074861, 110, 4489 }, {(float)0.001103, 123, 15170}, {(float)0.001242, 115, 15293},
{ (float)0.074861, 110, 4599 }, {(float)0.001188, 109, 15408}, {(float)0.001011, 103, 15517},
{ (float)0.068290, 115, 4709 }, {(float)0.000709, 97, 15620}, {(float)0.000301, 89, 15717},
{ (float)0.068290, 115, 4824 }, {(float)0.002416, 82, 15806}, {(float)0.003251, 76, 15888},
{ (float)0.068290, 115, 4939 }, {(float)0.003246, 69, 15964}, {(float)0.004141, 62, 16033},
{ (float)0.068290, 115, 5054 }, {(float)0.005963, 55, 16095}, {(float)0.008839, 47, 16150},
{ (float)0.063573, 119, 5169 }, {(float)0.010490, 40, 16197}, {(float)0.016994, 31, 16237},
{ (float)0.063573, 119, 5288 }, {(float)0.023659, 21, 16268},
{ (float)0.063573, 119, 5407 },
{ (float)0.063573, 119, 5526 },
{ (float)0.057219, 124, 5645 },
{ (float)0.057219, 124, 5769 },
{ (float)0.057219, 124, 5893 },
{ (float)0.057219, 124, 6017 },
{ (float)0.050985, 129, 6141 },
{ (float)0.050985, 129, 6270 },
{ (float)0.050985, 129, 6399 },
{ (float)0.050985, 129, 6528 },
{ (float)0.050985, 129, 6657 },
{ (float)0.044859, 134, 6786 },
{ (float)0.044859, 134, 6920 },
{ (float)0.044859, 134, 7054 },
{ (float)0.044859, 134, 7188 },
{ (float)0.040571, 138, 7322 },
{ (float)0.040571, 138, 7460 },
{ (float)0.040571, 138, 7598 },
{ (float)0.040571, 138, 7736 },
{ (float)0.036339, 142, 7874 },
{ (float)0.036339, 142, 8016 },
{ (float)0.036339, 142, 8158 },
{ (float)0.036339, 142, 8300 },
{ (float)0.032139, 146, 8442 },
{ (float)0.032139, 146, 8588 },
{ (float)0.032139, 146, 8734 },
{ (float)0.032139, 146, 8880 },
{ (float)0.027947, 150, 9026 },
{ (float)0.027947, 150, 9176 },
{ (float)0.027947, 150, 9326 },
{ (float)0.023739, 154, 9476 },
{ (float)0.023739, 154, 9630 },
{ (float)0.023739, 154, 9784 },
{ (float)0.023739, 154, 9938 },
{ (float)0.019504, 158, 10092 },
{ (float)0.019504, 158, 10250 },
{ (float)0.019504, 158, 10408 },
{ (float)0.016976, 161, 10566 },
{ (float)0.016976, 161, 10727 },
{ (float)0.016976, 161, 10888 },
{ (float)0.016976, 161, 11049 },
{ (float)0.012639, 165, 11210 },
{ (float)0.012639, 165, 11375 },
{ (float)0.012639, 165, 11540 },
{ (float)0.009991, 168, 11705 },
{ (float)0.009991, 168, 11873 },
{ (float)0.009991, 168, 12041 },
{ (float)0.009016, 170, 12209 },
{ (float)0.009016, 170, 12379 },
{ (float)0.009016, 170, 12549 },
{ (float)0.006217, 173, 12719 },
{ (float)0.006217, 173, 12892 },
{ (float)0.005097, 175, 13065 },
{ (float)0.005097, 175, 13240 },
{ (float)0.005097, 175, 13415 },
{ (float)0.003909, 177, 13590 },
{ (float)0.003909, 177, 13767 },
{ (float)0.002340, 177, 13944 },
{ (float)0.002389, 170, 14121 },
{ (float)0.001068, 164, 14291 },
{ (float)0.001653, 157, 14455 },
{ (float)0.000717, 150, 14612 },
{ (float)0.001614, 143, 14762 },
{ (float)0.000270, 136, 14905 },
{ (float)0.000484, 129, 15041 },
{ (float)0.001103, 123, 15170 },
{ (float)0.001242, 115, 15293 },
{ (float)0.001188, 109, 15408 },
{ (float)0.001011, 103, 15517 },
{ (float)0.000709, 97, 15620 },
{ (float)0.000301, 89, 15717 },
{ (float)0.002416, 82, 15806 },
{ (float)0.003251, 76, 15888 },
{ (float)0.003246, 69, 15964 },
{ (float)0.004141, 62, 16033 },
{ (float)0.005963, 55, 16095 },
{ (float)0.008839, 47, 16150 },
{ (float)0.010490, 40, 16197 },
{ (float)0.016994, 31, 16237 },
{ (float)0.023659, 21, 16268 },
}; };
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/