mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-08-06 06:26:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

libtiff upgrade to version 4.6.0 (#25096)

Browse Source 
* libtiff upgrade to version 4.6.0

* fix tiffvers.h cmake generation

* temp: force build 3rd party deps from source

* remove libport.h and spintf.c

* cmake fixes

* don't use tiff_dummy_namespace on windows

* introduce numeric_types namespace alias

* include cstdint

* uint16_t is not a numeric_types type

* fix uint16 and uint32 type defs

* use standard c++ types

* remove unused files

* remove more unused files

* revert build 3rd party code from source

---------

Co-authored-by: Misha Klatis <misha.klatis@autodesk.com>
This commit is contained in:
Michael Klatis 2024-03-21 18:08:16 -07:00 committed by GitHub
parent 3afe8ddaf8
commit 52f3f5a3f6
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
64 changed files with 45226 additions and 34700 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
3rdparty/libtiff/CMakeLists.txt vendored
View File

@ -124,17 +124,17 @@ elseif(SIZEOF_UNSIGNED_LONG_LONG EQUAL 8)
endif() endif()
if(SIZEOF_UNSIGNED_INT EQUAL SIZEOF_SIZE_T) if(SIZEOF_UNSIGNED_INT EQUAL SIZEOF_SIZE_T)
set(TIFF_SIZE_T "unsigned int") set(TIFF_SIZE_T "uint32_t")
set(TIFF_SIZE_FORMAT "%u") set(TIFF_SIZE_FORMAT "%u")
set(TIFF_SSIZE_T "signed int") set(TIFF_SSIZE_T "int32_t")
set(TIFF_SSIZE_FORMAT "%d") set(TIFF_SSIZE_FORMAT "%d")
elseif(SIZEOF_UNSIGNED_LONG EQUAL SIZEOF_SIZE_T) elseif(SIZEOF_UNSIGNED_LONG EQUAL SIZEOF_SIZE_T)
set(TIFF_SIZE_T "unsigned long") set(TIFF_SIZE_T "uint64_t")
set(TIFF_SIZE_FORMAT "%lu") set(TIFF_SIZE_FORMAT "%lu")
set(TIFF_SSIZE_T "signed long") set(TIFF_SSIZE_T "int64_t")
set(TIFF_SSIZE_FORMAT "%ld") set(TIFF_SSIZE_FORMAT "%ld")
elseif(SIZEOF_UNSIGNED_LONG_LONG EQUAL SIZEOF_SIZE_T) elseif(SIZEOF_UNSIGNED_LONG_LONG EQUAL SIZEOF_SIZE_T)
set(TIFF_SIZE_T "unsigned long") set(TIFF_SIZE_T "uint64_t")
if(MINGW) if(MINGW)
set(TIFF_SIZE_FORMAT "%I64u") set(TIFF_SIZE_FORMAT "%I64u")
set(TIFF_SSIZE_FORMAT "%I64d") set(TIFF_SSIZE_FORMAT "%I64d")
@ -198,20 +198,6 @@ check_function_exists(strtol HAVE_STRTOUL)
check_function_exists(strtoull HAVE_STRTOULL) check_function_exists(strtoull HAVE_STRTOULL)
check_function_exists(lfind HAVE_LFIND) check_function_exists(lfind HAVE_LFIND)
# May be inlined, so check it compiles:
check_c_source_compiles("
#include <stdio.h>
int main(void) {
char buf[10];
snprintf(buf, 10, \"Test %d\", 1);
return 0;
}"
HAVE_SNPRINTF)
if(NOT HAVE_SNPRINTF)
add_definitions(-DNEED_LIBPORT)
endif()
# CPU bit order # CPU bit order
set(fillorder FILLORDER_MSB2LSB) set(fillorder FILLORDER_MSB2LSB)
if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "i.*86.*" OR if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "i.*86.*" OR
@ -371,7 +357,12 @@ if(LIBLZMA_LIBRARIES)
list(APPEND TIFF_LIBRARY_DEPS ${LIBLZMA_LIBRARIES}) list(APPEND TIFF_LIBRARY_DEPS ${LIBLZMA_LIBRARIES})
endif() endif()
set(LIBTIFF_MAJOR_VERSION "4")
set(LIBTIFF_MINOR_VERSION "6")
set(LIBTIFF_MICRO_VERSION "0")
set(LIBTIFF_VERSION "${LIBTIFF_MAJOR_VERSION}.${LIBTIFF_MINOR_VERSION}.${LIBTIFF_MICRO_VERSION}")
set(TIFF_MAX_DIR_COUNT "1048576")
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tif_config.h.cmake.in" configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tif_config.h.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/tif_config.h" "${CMAKE_CURRENT_BINARY_DIR}/tif_config.h"
@ -379,6 +370,9 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tif_config.h.cmake.in"
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tiffconf.h.cmake.in" configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tiffconf.h.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/tiffconf.h" "${CMAKE_CURRENT_BINARY_DIR}/tiffconf.h"
@ONLY) @ONLY)
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tiffvers.h.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/tiffvers.h"
@ONLY)
ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}" ${ZLIB_INCLUDE_DIRS}) ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}" ${ZLIB_INCLUDE_DIRS})
@ -399,6 +393,7 @@ set(lib_srcs
tif_fax3sm.c tif_fax3sm.c
tif_flush.c tif_flush.c
tif_getimage.c tif_getimage.c
tif_hash_set.c
tif_jbig.c tif_jbig.c
tif_jpeg_12.c tif_jpeg_12.c
tif_jpeg.c tif_jpeg.c
@ -427,21 +422,18 @@ set(lib_srcs
t4.h t4.h
tif_dir.h tif_dir.h
tif_fax3.h tif_fax3.h
tif_hash_set.h
tif_predict.h
tiff.h tiff.h
tiffio.h tiffio.h
tiffiop.h tiffiop.h
tiffvers.h tiffvers.h
tif_predict.h
uvcode.h uvcode.h
tiffio.hxx tiffio.hxx
"${CMAKE_CURRENT_BINARY_DIR}/tif_config.h" "${CMAKE_CURRENT_BINARY_DIR}/tif_config.h"
"${CMAKE_CURRENT_BINARY_DIR}/tiffconf.h" "${CMAKE_CURRENT_BINARY_DIR}/tiffconf.h"
) )
if(WIN32 AND NOT HAVE_SNPRINTF)
list(APPEND lib_srcs snprintf.c libport.h)
endif()
if(WIN32 AND NOT WINRT) if(WIN32 AND NOT WINRT)
list(APPEND lib_srcs tif_win32.c) list(APPEND lib_srcs tif_win32.c)
else() else()

4823
3rdparty/libtiff/ChangeLog vendored
View File

File diff suppressed because it is too large Load Diff

69
3rdparty/libtiff/README.md vendored Normal file
View File

@ -0,0 +1,69 @@
TIFF Software Distribution
--------------------------
This file is just a placeholder; the entire documentation is now located
as reStructuredText in the doc directory. To view the documentation
as HTML, visit https://libtiff.gitlab.io/libtiff/ or
http://www.simplesystems.org/libtiff/ or within the release package
in the doc/html-prebuilt directory. The manual pages are
located at doc/man-prebuilt.
The release package can be downloaded at
http://download.osgeo.org/libtiff/
If you can't hack either of these options then basically what you
want to do is:
% ./configure
% make
% su
# make install
More information, email contacts, and mailing list information can be
found online at http://www.simplesystems.org/libtiff/
Source code repository
----------------------
[GitLab](https://gitlab.com/libtiff/libtiff)
Bug database
------------
[GitLab issues](https://gitlab.com/libtiff/libtiff/issues)
Previously, the project used
[Bugzilla](http://bugzilla.maptools.org/buglist.cgi?product=libtiff). This
is no longer in use, and all remaining issues have been migrated to GitLab.
Use and Copyright
-----------------
Silicon Graphics has seen fit to allow us to give this work away. It
is free. There is no support or guarantee of any sort as to its
operations, correctness, or whatever. If you do anything useful with
all or parts of it you need to honor the copyright notices. I would
also be interested in knowing about it and, hopefully, be acknowledged.
The legal way of saying that is:
Copyright (c) 1988-1997 Sam Leffler
Copyright (c) 1991-1997 Silicon Graphics, Inc.
Permission to use, copy, modify, distribute, and sell this software and
its documentation for any purpose is hereby granted without fee, provided
that (i) the above copyright notices and this permission notice appear in
all copies of the software and related documentation, and (ii) the names of
Sam Leffler and Silicon Graphics may not be used in any advertising or
publicity relating to the software without the specific, prior written
permission of Sam Leffler and Silicon Graphics.
THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
OF THIS SOFTWARE.

71
3rdparty/libtiff/libport.h vendored
View File

@ -1,71 +0,0 @@
/*
* Copyright (c) 2009 Frank Warmerdam
*
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
* permission of Sam Leffler and Silicon Graphics.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THIS SOFTWARE.
*/
#ifndef _LIBPORT_
#define _LIBPORT_
#if defined(HAVE_CONFIG_H)
# include <tif_config.h>
#endif
int getopt(int argc, char * const argv[], const char *optstring);
extern char *optarg;
extern int opterr;
extern int optind;
extern int optopt;
int strcasecmp(const char *s1, const char *s2);
#ifndef HAVE_GETOPT
# define HAVE_GETOPT 1
#endif
#if !defined(HAVE_STRTOL)
long strtol(const char *nptr, char **endptr, int base);
#endif
#if !defined(HAVE_STRTOLL)
long long strtoll(const char *nptr, char **endptr, int base);
#endif
#if !defined(HAVE_STRTOUL)
unsigned long strtoul(const char *nptr, char **endptr, int base);
#endif
#if !defined(HAVE_STRTOULL)
unsigned long long strtoull(const char *nptr, char **endptr, int base);
#endif
#if 0
void *
lfind(const void *key, const void *base, size_t *nmemb, size_t size,
int(*compar)(const void *, const void *));
#endif
#if !defined(HAVE_SNPRINTF)
#undef vsnprintf
#define vsnprintf _TIFF_vsnprintf_f
#undef snprintf
#define snprintf _TIFF_snprintf_f
int snprintf(char* str, size_t size, const char* format, ...);
#endif
#endif /* ndef _LIBPORT_ */

42
3rdparty/libtiff/snprintf.c vendored
View File

@ -1,42 +0,0 @@
/**
* Workaround for lack of snprintf(3) in Visual Studio. See
* http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010/8712996#8712996
* It's a trivial wrapper around the builtin _vsnprintf_s and
* _vscprintf functions.
*/
#ifdef _MSC_VER
#include <stdio.h>
#include <stdarg.h>
#include "libport.h"
int _TIFF_vsnprintf_f(char* str, size_t size, const char* format, va_list ap)
{
int count = -1;
if (size != 0)
#if _MSC_VER <= 1310
count = _vsnprintf(str, size, format, ap);
#else
count = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
#endif
if (count == -1)
count = _vscprintf(format, ap);
return count;
}
int _TIFF_snprintf_f(char* str, size_t size, const char* format, ...)
{
int count;
va_list ap;
va_start(ap, format);
count = vsnprintf(str, size, format, ap);
va_end(ap);
return count;
}
#endif // _MSC_VER

464
3rdparty/libtiff/t4.h vendored
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:
*/

649
3rdparty/libtiff/tif_aux.c vendored
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 uint32_t _TIFFMultiply32(TIFF *tif, uint32_t first, uint32_t second,
_TIFFMultiply32(TIFF* tif, uint32 first, uint32 second, const char* where) const char *where)
{ {
if (second && first > TIFF_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
_TIFFMultiply64(TIFF* tif, uint64 first, uint64 second, const char* where)
{
if (second && first > TIFF_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 val, const char* module) tmsize_t _TIFFCastUInt64ToSSize(TIFF *tif, uint64_t val, const char *module)
{ {
if( val > (uint64)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,
"(%ld elements of %ld bytes each)", "Failed to allocate memory for %s "
what,(long) nmemb, (long) 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 **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); nbytes = n * sizeof(uint16_t);
tf[0] = (uint16 *)_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)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 *)_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 *)_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 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 *) = td->td_subfiletype;
return (1);
case TIFFTAG_BITSPERSAMPLE:
*va_arg(ap, uint16 *) = td->td_bitspersample;
return (1);
case TIFFTAG_THRESHHOLDING:
*va_arg(ap, uint16 *) = td->td_threshholding;
return (1);
case TIFFTAG_FILLORDER:
*va_arg(ap, uint16 *) = td->td_fillorder;
return (1);
case TIFFTAG_ORIENTATION:
*va_arg(ap, uint16 *) = td->td_orientation;
return (1);
case TIFFTAG_SAMPLESPERPIXEL:
*va_arg(ap, uint16 *) = td->td_samplesperpixel;
return (1);
case TIFFTAG_ROWSPERSTRIP:
*va_arg(ap, uint32 *) = td->td_rowsperstrip;
return (1);
case TIFFTAG_MINSAMPLEVALUE:
*va_arg(ap, uint16 *) = td->td_minsamplevalue;
return (1);
case TIFFTAG_MAXSAMPLEVALUE:
*va_arg(ap, uint16 *) = td->td_maxsamplevalue;
return (1);
case TIFFTAG_PLANARCONFIG:
*va_arg(ap, uint16 *) = td->td_planarconfig;
return (1);
case TIFFTAG_RESOLUTIONUNIT:
*va_arg(ap, uint16 *) = 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*) = 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*) = (uint16) 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 *) = 0;
*va_arg(ap, uint16 *) = (1<<td->td_bitspersample)-1;
return (1);
case TIFFTAG_INKSET:
*va_arg(ap, uint16 *) = INKSET_CMYK;
return 1;
case TIFFTAG_NUMBEROFINKS:
*va_arg(ap, uint16 *) = 4;
return (1);
case TIFFTAG_EXTRASAMPLES:
*va_arg(ap, uint16 *) = td->td_extrasamples;
*va_arg(ap, const uint16 **) = td->td_sampleinfo;
return (1);
case TIFFTAG_MATTEING:
*va_arg(ap, uint16 *) =
(td->td_extrasamples == 1 &&
td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
return (1);
case TIFFTAG_TILEDEPTH:
*va_arg(ap, uint32 *) = td->td_tiledepth;
return (1);
case TIFFTAG_DATATYPE:
*va_arg(ap, uint16 *) = td->td_sampleformat-1;
return (1);
case TIFFTAG_SAMPLEFORMAT:
*va_arg(ap, uint16 *) = td->td_sampleformat;
return(1);
case TIFFTAG_IMAGEDEPTH:
*va_arg(ap, uint32 *) = 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 *) = td->td_ycbcrsubsampling[0];
*va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[1];
return (1);
case TIFFTAG_YCBCRPOSITIONING:
*va_arg(ap, uint16 *) = 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 **) = td->td_transferfunction[0];
if (td->td_samplesperpixel - td->td_extrasamples > 1) {
*va_arg(ap, const uint16 **) = td->td_transferfunction[1];
*va_arg(ap, const uint16 **) = 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 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 low, high; {
int32_t low, high;
}; };
typedef union { typedef union
struct _Int64Parts part; {
int64 value; struct _Int64Parts part;
int64_t value;
} _Int64; } _Int64;
float float _TIFFUInt64ToFloat(uint64_t ui64)
_TIFFUInt64ToFloat(uint64 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 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)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:
*/

172
3rdparty/libtiff/tif_close.c vendored
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,70 +37,98 @@
* 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) _TIFFCleanupIFDOffsetAndNumberMaps(tif);
_TIFFfree(tif->tif_dirlist);
/* /*
* 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 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_bit == FIELD_CUSTOM && TIFFField *fld = tif->tif_fields[i];
strncmp("Tag ", fld->field_name, 4) == 0) { if (fld->field_name != NULL)
_TIFFfree(fld->field_name); {
_TIFFfree(fld); if (fld->field_bit == FIELD_CUSTOM &&
} /* caution: tif_fields[i] must not be the beginning of a
} * fields-array. Otherwise the following tags are also freed
* with the first free().
_TIFFfree(tif->tif_fields); */
} TIFFFieldIsAnonymous(fld))
{
if (tif->tif_nfieldscompat > 0) { _TIFFfreeExt(tif, fld->field_name);
uint32 i; _TIFFfreeExt(tif, fld);
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);
}
/************************************************************************/
/* _TIFFCleanupIFDOffsetAndNumberMaps() */
/************************************************************************/
void _TIFFCleanupIFDOffsetAndNumberMaps(TIFF *tif)
{
if (tif->tif_map_dir_offset_to_number)
{
TIFFHashSetDestroy(tif->tif_map_dir_offset_to_number);
tif->tif_map_dir_offset_to_number = NULL;
}
if (tif->tif_map_dir_number_to_offset)
{
TIFFHashSetDestroy(tif->tif_map_dir_number_to_offset);
tif->tif_map_dir_number_to_offset = NULL;
}
} }
/************************************************************************/ /************************************************************************/
@ -113,26 +141,18 @@ 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; if (tif != NULL)
thandle_t fd = tif->tif_clientdata; {
TIFFCloseProc closeproc = tif->tif_closeproc;
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:
*/

142
3rdparty/libtiff/tif_codec.c vendored
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
@ -67,6 +67,9 @@ static int NotConfigured(TIFF*, int);
#ifndef LOGLUV_SUPPORT #ifndef LOGLUV_SUPPORT
#define TIFFInitSGILog NotConfigured #define TIFFInitSGILog NotConfigured
#endif #endif
#ifndef LERC_SUPPORT
#define TIFFInitLERC NotConfigured
#endif
#ifndef LZMA_SUPPORT #ifndef LZMA_SUPPORT
#define TIFFInitLZMA NotConfigured #define TIFFInitLZMA NotConfigured
#endif #endif
@ -80,58 +83,53 @@ static int NotConfigured(TIFF*, int);
/* /*
* Compression schemes statically built into the library. * Compression schemes statically built into the library.
*/ */
#ifdef VMS
const TIFFCodec _TIFFBuiltinCODECS[] = { const TIFFCodec _TIFFBuiltinCODECS[] = {
#else {"None", COMPRESSION_NONE, TIFFInitDumpMode},
TIFFCodec _TIFFBuiltinCODECS[] = { {"LZW", COMPRESSION_LZW, TIFFInitLZW},
#endif {"PackBits", COMPRESSION_PACKBITS, TIFFInitPackBits},
{ "None", COMPRESSION_NONE, TIFFInitDumpMode }, {"ThunderScan", COMPRESSION_THUNDERSCAN, TIFFInitThunderScan},
{ "LZW", COMPRESSION_LZW, TIFFInitLZW }, {"NeXT", COMPRESSION_NEXT, TIFFInitNeXT},
{ "PackBits", COMPRESSION_PACKBITS, TIFFInitPackBits }, {"JPEG", COMPRESSION_JPEG, TIFFInitJPEG},
{ "ThunderScan", COMPRESSION_THUNDERSCAN,TIFFInitThunderScan }, {"Old-style JPEG", COMPRESSION_OJPEG, TIFFInitOJPEG},
{ "NeXT", COMPRESSION_NEXT, TIFFInitNeXT }, {"CCITT RLE", COMPRESSION_CCITTRLE, TIFFInitCCITTRLE},
{ "JPEG", COMPRESSION_JPEG, TIFFInitJPEG }, {"CCITT RLE/W", COMPRESSION_CCITTRLEW, TIFFInitCCITTRLEW},
{ "Old-style JPEG", COMPRESSION_OJPEG, TIFFInitOJPEG }, {"CCITT Group 3", COMPRESSION_CCITTFAX3, TIFFInitCCITTFax3},
{ "CCITT RLE", COMPRESSION_CCITTRLE, TIFFInitCCITTRLE }, {"CCITT Group 4", COMPRESSION_CCITTFAX4, TIFFInitCCITTFax4},
{ "CCITT RLE/W", COMPRESSION_CCITTRLEW, TIFFInitCCITTRLEW }, {"ISO JBIG", COMPRESSION_JBIG, TIFFInitJBIG},
{ "CCITT Group 3", COMPRESSION_CCITTFAX3, TIFFInitCCITTFax3 }, {"Deflate", COMPRESSION_DEFLATE, TIFFInitZIP},
{ "CCITT Group 4", COMPRESSION_CCITTFAX4, TIFFInitCCITTFax4 }, {"AdobeDeflate", COMPRESSION_ADOBE_DEFLATE, TIFFInitZIP},
{ "ISO JBIG", COMPRESSION_JBIG, TIFFInitJBIG }, {"PixarLog", COMPRESSION_PIXARLOG, TIFFInitPixarLog},
{ "Deflate", COMPRESSION_DEFLATE, TIFFInitZIP }, {"SGILog", COMPRESSION_SGILOG, TIFFInitSGILog},
{ "AdobeDeflate", COMPRESSION_ADOBE_DEFLATE , TIFFInitZIP }, {"SGILog24", COMPRESSION_SGILOG24, TIFFInitSGILog},
{ "PixarLog", COMPRESSION_PIXARLOG, TIFFInitPixarLog }, {"LZMA", COMPRESSION_LZMA, TIFFInitLZMA},
{ "SGILog", COMPRESSION_SGILOG, TIFFInitSGILog }, {"ZSTD", COMPRESSION_ZSTD, TIFFInitZSTD},
{ "SGILog24", COMPRESSION_SGILOG24, TIFFInitSGILog }, {"WEBP", COMPRESSION_WEBP, TIFFInitWebP},
{ "LZMA", COMPRESSION_LZMA, TIFFInitLZMA }, {"LERC", COMPRESSION_LERC, TIFFInitLERC},
{ "ZSTD", COMPRESSION_ZSTD, TIFFInitZSTD }, {NULL, 0, NULL}};
{ "WEBP", COMPRESSION_WEBP, TIFFInitWebP },
{ 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, "%d",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 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:
*/

383
3rdparty/libtiff/tif_color.c vendored
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.
*/ */
@ -40,173 +40,191 @@
/* /*
* Convert color value from the CIE L*a*b* 1976 space to CIE XYZ. * Convert color value from the CIE L*a*b* 1976 space to CIE XYZ.
*/ */
void void TIFFCIELabToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a, int32_t b,
TIFFCIELabToXYZ(TIFFCIELabToRGB *cielab, uint32 l, int32 a, int32 b, float *X, float *Y, float *Z)
float *X, float *Y, float *Z)
{ {
float L = (float)l * 100.0F / 255.0F; TIFFCIELab16ToXYZ(cielab, l * 257, a * 256, b * 256, X, Y, Z);
float cby, tmp;
if( L < 8.856F ) {
*Y = (L * cielab->Y0) / 903.292F;
cby = 7.787F * (*Y / cielab->Y0) + 16.0F / 116.0F;
} else {
cby = (L + 16.0F) / 116.0F;
*Y = cielab->Y0 * cby * cby * cby;
}
tmp = (float)a / 500.0F + cby;
if( tmp < 0.2069F )
*X = cielab->X0 * (tmp - 0.13793F) / 7.787F;
else
*X = cielab->X0 * tmp * tmp * tmp;
tmp = cby - (float)b / 200.0F;
if( tmp < 0.2069F )
*Z = cielab->Z0 * (tmp - 0.13793F) / 7.787F;
else
*Z = cielab->Z0 * tmp * tmp * tmp;
} }
#define RINT(R) ((uint32)((R)>0?((R)+0.5):((R)-0.5))) /*
* For CIELab encoded in 16 bits, L is an unsigned integer range [0,65535].
* The a* and b* components are signed integers range [-32768,32767]. The 16
* bit chrominance values are encoded as 256 times the 1976 CIE a* and b*
* values
*/
void TIFFCIELab16ToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a,
int32_t b, float *X, float *Y, float *Z)
{
float L = (float)l * 100.0F / 65535.0F;
float cby, tmp;
if (L < 8.856F)
{
*Y = (L * cielab->Y0) / 903.292F;
cby = 7.787F * (*Y / cielab->Y0) + 16.0F / 116.0F;
}
else
{
cby = (L + 16.0F) / 116.0F;
*Y = cielab->Y0 * cby * cby * cby;
}
tmp = (float)a / 256.0F / 500.0F + cby;
if (tmp < 0.2069F)
*X = cielab->X0 * (tmp - 0.13793F) / 7.787F;
else
*X = cielab->X0 * tmp * tmp * tmp;
tmp = cby - (float)b / 256.0F / 200.0F;
if (tmp < 0.2069F)
*Z = cielab->Z0 * (tmp - 0.13793F) / 7.787F;
else
*Z = cielab->Z0 * tmp * tmp * tmp;
}
#define RINT(R) ((uint32_t)((R) > 0 ? ((R) + 0.5) : ((R)-0.5)))
/* /*
* Convert color value from the XYZ space to RGB. * Convert color value from the XYZ space to RGB.
*/ */
void void TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z,
TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z, uint32_t *r, uint32_t *g, uint32_t *b)
uint32 *r, uint32 *g, uint32 *b)
{ {
int i; int i;
float Yr, Yg, Yb; float Yr, Yg, Yb;
float *matrix = &cielab->display.d_mat[0][0]; float *matrix = &cielab->display.d_mat[0][0];
/* Multiply through the matrix to get luminosity values. */ /* Multiply through the matrix to get luminosity values. */
Yr = matrix[0] * X + matrix[1] * Y + matrix[2] * Z; Yr = matrix[0] * X + matrix[1] * Y + matrix[2] * Z;
Yg = matrix[3] * X + matrix[4] * Y + matrix[5] * Z; Yg = matrix[3] * X + matrix[4] * Y + matrix[5] * Z;
Yb = matrix[6] * X + matrix[7] * Y + matrix[8] * Z; Yb = matrix[6] * X + matrix[7] * Y + matrix[8] * Z;
/* Clip input */ /* Clip input */
Yr = TIFFmax(Yr, cielab->display.d_Y0R); Yr = TIFFmax(Yr, cielab->display.d_Y0R);
Yg = TIFFmax(Yg, cielab->display.d_Y0G); Yg = TIFFmax(Yg, cielab->display.d_Y0G);
Yb = TIFFmax(Yb, cielab->display.d_Y0B); Yb = TIFFmax(Yb, cielab->display.d_Y0B);
/* Avoid overflow in case of wrong input values */ /* Avoid overflow in case of wrong input values */
Yr = TIFFmin(Yr, cielab->display.d_YCR); Yr = TIFFmin(Yr, cielab->display.d_YCR);
Yg = TIFFmin(Yg, cielab->display.d_YCG); Yg = TIFFmin(Yg, cielab->display.d_YCG);
Yb = TIFFmin(Yb, cielab->display.d_YCB); Yb = TIFFmin(Yb, cielab->display.d_YCB);
/* Turn luminosity to colour value. */ /* Turn luminosity to colour value. */
i = (int)((Yr - cielab->display.d_Y0R) / cielab->rstep); i = (int)((Yr - cielab->display.d_Y0R) / cielab->rstep);
i = TIFFmin(cielab->range, i); i = TIFFmin(cielab->range, i);
*r = RINT(cielab->Yr2r[i]); *r = RINT(cielab->Yr2r[i]);
i = (int)((Yg - cielab->display.d_Y0G) / cielab->gstep); i = (int)((Yg - cielab->display.d_Y0G) / cielab->gstep);
i = TIFFmin(cielab->range, i); i = TIFFmin(cielab->range, i);
*g = RINT(cielab->Yg2g[i]); *g = RINT(cielab->Yg2g[i]);
i = (int)((Yb - cielab->display.d_Y0B) / cielab->bstep); i = (int)((Yb - cielab->display.d_Y0B) / cielab->bstep);
i = TIFFmin(cielab->range, i); i = TIFFmin(cielab->range, i);
*b = RINT(cielab->Yb2b[i]); *b = RINT(cielab->Yb2b[i]);
/* Clip output. */ /* Clip output. */
*r = TIFFmin(*r, cielab->display.d_Vrwr); *r = TIFFmin(*r, cielab->display.d_Vrwr);
*g = TIFFmin(*g, cielab->display.d_Vrwg); *g = TIFFmin(*g, cielab->display.d_Vrwg);
*b = TIFFmin(*b, cielab->display.d_Vrwb); *b = TIFFmin(*b, cielab->display.d_Vrwb);
} }
#undef RINT #undef RINT
/* /*
* Allocate conversion state structures and make look_up tables for * Allocate conversion state structures and make look_up tables for
* the Yr,Yb,Yg <=> r,g,b conversions. * the Yr,Yb,Yg <=> r,g,b conversions.
*/ */
int int TIFFCIELabToRGBInit(TIFFCIELabToRGB *cielab, const TIFFDisplay *display,
TIFFCIELabToRGBInit(TIFFCIELabToRGB* cielab, float *refWhite)
const TIFFDisplay *display, float *refWhite)
{ {
int i; int i;
double dfGamma; double dfGamma;
cielab->range = CIELABTORGB_TABLE_RANGE; cielab->range = CIELABTORGB_TABLE_RANGE;
_TIFFmemcpy(&cielab->display, display, sizeof(TIFFDisplay)); _TIFFmemcpy(&cielab->display, display, sizeof(TIFFDisplay));
/* Red */ /* Red */
dfGamma = 1.0 / cielab->display.d_gammaR ; dfGamma = 1.0 / cielab->display.d_gammaR;
cielab->rstep = cielab->rstep =
(cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range; (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
for(i = 0; i <= cielab->range; i++) { for (i = 0; i <= cielab->range; i++)
cielab->Yr2r[i] = cielab->display.d_Vrwr {
* ((float)pow((double)i / cielab->range, dfGamma)); cielab->Yr2r[i] = cielab->display.d_Vrwr *
} ((float)pow((double)i / cielab->range, dfGamma));
}
/* Green */ /* Green */
dfGamma = 1.0 / cielab->display.d_gammaG ; dfGamma = 1.0 / cielab->display.d_gammaG;
cielab->gstep = cielab->gstep =
(cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range; (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
for(i = 0; i <= cielab->range; i++) { for (i = 0; i <= cielab->range; i++)
cielab->Yg2g[i] = cielab->display.d_Vrwg {
* ((float)pow((double)i / cielab->range, dfGamma)); cielab->Yg2g[i] = cielab->display.d_Vrwg *
} ((float)pow((double)i / cielab->range, dfGamma));
}
/* Blue */ /* Blue */
dfGamma = 1.0 / cielab->display.d_gammaB ; dfGamma = 1.0 / cielab->display.d_gammaB;
cielab->bstep = cielab->bstep =
(cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range; (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
for(i = 0; i <= cielab->range; i++) { for (i = 0; i <= cielab->range; i++)
cielab->Yb2b[i] = cielab->display.d_Vrwb {
* ((float)pow((double)i / cielab->range, dfGamma)); cielab->Yb2b[i] = cielab->display.d_Vrwb *
} ((float)pow((double)i / cielab->range, dfGamma));
}
/* Init reference white point */ /* Init reference white point */
cielab->X0 = refWhite[0]; cielab->X0 = refWhite[0];
cielab->Y0 = refWhite[1]; cielab->Y0 = refWhite[1];
cielab->Z0 = refWhite[2]; cielab->Z0 = refWhite[2];
return 0; return 0;
} }
/* /*
* Convert color value from the YCbCr space to RGB. * Convert color value from the YCbCr space to RGB.
* The colorspace conversion algorithm comes from the IJG v5a code; * The colorspace conversion algorithm comes from the IJG v5a code;
* see below for more information on how it works. * see below for more information on how it works.
*/ */
#define SHIFT 16 #define SHIFT 16
#define FIX(x) ((int32)((x) * (1L<<SHIFT) + 0.5)) #define FIX(x) ((int32_t)((x) * (1L << SHIFT) + 0.5))
#define ONE_HALF ((int32)(1<<(SHIFT-1))) #define ONE_HALF ((int32_t)(1 << (SHIFT - 1)))
#define Code2V(c, RB, RW, CR) ((((c)-(int32)(RB))*(float)(CR))/(float)(((RW)-(RB)!=0) ? ((RW)-(RB)) : 1)) #define Code2V(c, RB, RW, CR) \
#define CLAMP(f,min,max) ((f)<(min)?(min):(f)>(max)?(max):(f)) ((((c) - (int32_t)(RB)) * (float)(CR)) / \
#define HICLAMP(f,max) ((f)>(max)?(max):(f)) (float)(((RW) - (RB) != 0) ? ((RW) - (RB)) : 1))
/* !((f)>=(min)) written that way to deal with NaN */
#define CLAMP(f, min, max) \
((!((f) >= (min))) ? (min) : (f) > (max) ? (max) : (f))
#define HICLAMP(f, max) ((f) > (max) ? (max) : (f))
void void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32_t Y, int32_t Cb, int32_t Cr,
TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32 Y, int32 Cb, int32 Cr, uint32_t *r, uint32_t *g, uint32_t *b)
uint32 *r, uint32 *g, uint32 *b)
{ {
int32 i; int32_t i;
/* XXX: Only 8-bit YCbCr input supported for now */ /* XXX: Only 8-bit YCbCr input supported for now */
Y = HICLAMP(Y, 255); Y = HICLAMP(Y, 255);
Cb = CLAMP(Cb, 0, 255); Cb = CLAMP(Cb, 0, 255);
Cr = CLAMP(Cr, 0, 255); Cr = CLAMP(Cr, 0, 255);
i = ycbcr->Y_tab[Y] + ycbcr->Cr_r_tab[Cr]; i = ycbcr->Y_tab[Y] + ycbcr->Cr_r_tab[Cr];
*r = CLAMP(i, 0, 255); *r = CLAMP(i, 0, 255);
i = ycbcr->Y_tab[Y] i = ycbcr->Y_tab[Y] +
+ (int)((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT); (int)((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT);
*g = CLAMP(i, 0, 255); *g = CLAMP(i, 0, 255);
i = ycbcr->Y_tab[Y] + ycbcr->Cb_b_tab[Cb]; i = ycbcr->Y_tab[Y] + ycbcr->Cb_b_tab[Cb];
*b = CLAMP(i, 0, 255); *b = CLAMP(i, 0, 255);
} }
/* Clamp function for sanitization purposes. Normally clamping should not */ /* Clamp function for sanitization purposes. Normally clamping should not */
/* occur for well behaved chroma and refBlackWhite coefficients */ /* occur for well behaved chroma and refBlackWhite coefficients */
static float CLAMPw(float v, float vmin, float vmax) static float CLAMPw(float v, float vmin, float vmax)
{ {
if( v < vmin ) if (v < vmin)
{ {
/* printf("%f clamped to %f\n", v, vmin); */ /* printf("%f clamped to %f\n", v, vmin); */
return vmin; return vmin;
} }
if( v > vmax ) if (v > vmax)
{ {
/* printf("%f clamped to %f\n", v, vmax); */ /* printf("%f clamped to %f\n", v, vmax); */
return vmax; return vmax;
@ -230,78 +248,75 @@ static float CLAMPw(float v, float vmin, float vmax)
* pre-calculating possible values indexed by Cb and Cr (this code * pre-calculating possible values indexed by Cb and Cr (this code
* assumes conversion is being done for 8-bit samples). * assumes conversion is being done for 8-bit samples).
*/ */
int int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *ycbcr, float *luma, float *refBlackWhite)
TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, float *luma, float *refBlackWhite)
{ {
TIFFRGBValue* clamptab; TIFFRGBValue *clamptab;
int i; int i;
#define LumaRed luma[0]
#define LumaGreen luma[1]
#define LumaBlue luma[2]
clamptab = (TIFFRGBValue*)( #define LumaRed luma[0]
(uint8*) ycbcr+TIFFroundup_32(sizeof (TIFFYCbCrToRGB), sizeof (long))); #define LumaGreen luma[1]
_TIFFmemset(clamptab, 0, 256); /* v < 0 => 0 */ #define LumaBlue luma[2]
clamptab =
(TIFFRGBValue *)((uint8_t *)ycbcr +
TIFFroundup_32(sizeof(TIFFYCbCrToRGB), sizeof(long)));
_TIFFmemset(clamptab, 0, 256); /* v < 0 => 0 */
ycbcr->clamptab = (clamptab += 256); ycbcr->clamptab = (clamptab += 256);
for (i = 0; i < 256; i++) for (i = 0; i < 256; i++)
clamptab[i] = (TIFFRGBValue) i; clamptab[i] = (TIFFRGBValue)i;
_TIFFmemset(clamptab+256, 255, 2*256); /* v > 255 => 255 */ _TIFFmemset(clamptab + 256, 255, 2 * 256); /* v > 255 => 255 */
ycbcr->Cr_r_tab = (int*) (clamptab + 3*256); ycbcr->Cr_r_tab = (int *)(clamptab + 3 * 256);
ycbcr->Cb_b_tab = ycbcr->Cr_r_tab + 256; ycbcr->Cb_b_tab = ycbcr->Cr_r_tab + 256;
ycbcr->Cr_g_tab = (int32*) (ycbcr->Cb_b_tab + 256); ycbcr->Cr_g_tab = (int32_t *)(ycbcr->Cb_b_tab + 256);
ycbcr->Cb_g_tab = ycbcr->Cr_g_tab + 256; ycbcr->Cb_g_tab = ycbcr->Cr_g_tab + 256;
ycbcr->Y_tab = ycbcr->Cb_g_tab + 256; ycbcr->Y_tab = ycbcr->Cb_g_tab + 256;
{ float f1 = 2-2*LumaRed; int32 D1 = FIX(CLAMP(f1,0.0F,2.0F)); {
float f2 = LumaRed*f1/LumaGreen; int32 D2 = -FIX(CLAMP(f2,0.0F,2.0F)); float f1 = 2 - 2 * LumaRed;
float f3 = 2-2*LumaBlue; int32 D3 = FIX(CLAMP(f3,0.0F,2.0F)); int32_t D1 = FIX(CLAMP(f1, 0.0F, 2.0F));
float f4 = LumaBlue*f3/LumaGreen; int32 D4 = -FIX(CLAMP(f4,0.0F,2.0F)); float f2 = LumaRed * f1 / LumaGreen;
int x; int32_t D2 = -FIX(CLAMP(f2, 0.0F, 2.0F));
float f3 = 2 - 2 * LumaBlue;
int32_t D3 = FIX(CLAMP(f3, 0.0F, 2.0F));
float f4 = LumaBlue * f3 / LumaGreen;
int32_t D4 = -FIX(CLAMP(f4, 0.0F, 2.0F));
int x;
#undef LumaBlue #undef LumaBlue
#undef LumaGreen #undef LumaGreen
#undef LumaRed #undef LumaRed
/*
* i is the actual input pixel value in the range 0..255
* Cb and Cr values are in the range -128..127 (actually
* they are in a range defined by the ReferenceBlackWhite
* tag) so there is some range shifting to do here when
* constructing tables indexed by the raw pixel data.
*/
for (i = 0, x = -128; i < 256; i++, x++) {
int32 Cr = (int32)CLAMPw(Code2V(x, refBlackWhite[4] - 128.0F,
refBlackWhite[5] - 128.0F, 127),
-128.0F * 32, 128.0F * 32);
int32 Cb = (int32)CLAMPw(Code2V(x, refBlackWhite[2] - 128.0F,
refBlackWhite[3] - 128.0F, 127),
-128.0F * 32, 128.0F * 32);
ycbcr->Cr_r_tab[i] = (int32)((D1*Cr + ONE_HALF)>>SHIFT); /*
ycbcr->Cb_b_tab[i] = (int32)((D3*Cb + ONE_HALF)>>SHIFT); * i is the actual input pixel value in the range 0..255
ycbcr->Cr_g_tab[i] = D2*Cr; * Cb and Cr values are in the range -128..127 (actually
ycbcr->Cb_g_tab[i] = D4*Cb + ONE_HALF; * they are in a range defined by the ReferenceBlackWhite
ycbcr->Y_tab[i] = * tag) so there is some range shifting to do here when
(int32)CLAMPw(Code2V(x + 128, refBlackWhite[0], refBlackWhite[1], 255), * constructing tables indexed by the raw pixel data.
-128.0F * 32, 128.0F * 32); */
} for (i = 0, x = -128; i < 256; i++, x++)
{
int32_t Cr = (int32_t)CLAMPw(Code2V(x, refBlackWhite[4] - 128.0F,
refBlackWhite[5] - 128.0F, 127),
-128.0F * 32, 128.0F * 32);
int32_t Cb = (int32_t)CLAMPw(Code2V(x, refBlackWhite[2] - 128.0F,
refBlackWhite[3] - 128.0F, 127),
-128.0F * 32, 128.0F * 32);
ycbcr->Cr_r_tab[i] = (int32_t)((D1 * Cr + ONE_HALF) >> SHIFT);
ycbcr->Cb_b_tab[i] = (int32_t)((D3 * Cb + ONE_HALF) >> SHIFT);
ycbcr->Cr_g_tab[i] = D2 * Cr;
ycbcr->Cb_g_tab[i] = D4 * Cb + ONE_HALF;
ycbcr->Y_tab[i] = (int32_t)CLAMPw(
Code2V(x + 128, refBlackWhite[0], refBlackWhite[1], 255),
-128.0F * 32, 128.0F * 32);
}
} }
return 0; return 0;
} }
#undef HICLAMP #undef HICLAMP
#undef CLAMP #undef CLAMP
#undef Code2V #undef Code2V
#undef SHIFT #undef SHIFT
#undef ONE_HALF #undef ONE_HALF
#undef FIX #undef FIX
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

412
3rdparty/libtiff/tif_compress.c vendored
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 %u %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* pp, tmsize_t cc, uint16 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* pp, tmsize_t cc, uint16 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* pp, tmsize_t cc, uint16 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 %u %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* pp, tmsize_t cc, uint16 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* pp, tmsize_t cc, uint16 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* pp, tmsize_t cc, uint16 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 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 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) 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 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 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*) cd + sizeof (codec_t)); {
cd->info->name = (char*) cd->info = (TIFFCodec *)((uint8_t *)cd + sizeof(codec_t));
((uint8*) 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:
*/

182
3rdparty/libtiff/tif_config.h.cmake.in vendored
View File

@ -1,6 +1,14 @@
/* clang-format off */
/* clang-format disabled because CMake scripts are very sensitive to the
* formatting of this file. configure_file variables of type "@VAR@" are
* modified by clang-format and won't be substituted.
*/
/* libtiff/tif_config.h.cmake.in. Not generated, but originated from autoheader. */ /* libtiff/tif_config.h.cmake.in. Not generated, but originated from autoheader. */
/* This file must be kept up-to-date with needed substitutions from libtiff/tif_config.h.in. */ /* This file must be kept up-to-date with needed substitutions from libtiff/tif_config.h.in. */
#include "tiffconf.h"
/* Support CCITT Group 3 & 4 algorithms */ /* Support CCITT Group 3 & 4 algorithms */
#cmakedefine CCITT_SUPPORT 1 #cmakedefine CCITT_SUPPORT 1
@ -20,84 +28,33 @@
/* Define to 1 if you have the <assert.h> header file. */ /* Define to 1 if you have the <assert.h> header file. */
#cmakedefine HAVE_ASSERT_H 1 #cmakedefine HAVE_ASSERT_H 1
/* Define to 1 if you have the <dlfcn.h> header file. */ /* Define to 1 if you have the declaration of `optarg', and to 0 if you don't. */
#cmakedefine HAVE_DLFCN_H 1 #cmakedefine HAVE_DECL_OPTARG 1
/* Define to 1 if you have the <fcntl.h> header file. */ /* Define to 1 if you have the <fcntl.h> header file. */
#cmakedefine HAVE_FCNTL_H 1 #cmakedefine HAVE_FCNTL_H 1
/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */
#cmakedefine HAVE_FSEEKO 1
/* Define to 1 if you have the `getopt' function. */ /* Define to 1 if you have the `getopt' function. */
#cmakedefine HAVE_GETOPT 1 #cmakedefine HAVE_GETOPT 1
/* Define to 1 if you have the <GLUT/glut.h> header file. */
#cmakedefine HAVE_GLUT_GLUT_H 1
/* Define to 1 if you have the <GL/glut.h> header file. */
#cmakedefine HAVE_GL_GLUT_H 1
/* Define to 1 if you have the <GL/glu.h> header file. */
#cmakedefine HAVE_GL_GLU_H 1
/* Define to 1 if you have the <GL/gl.h> header file. */
#cmakedefine HAVE_GL_GL_H 1
/* Define to 1 if you have the <inttypes.h> header file. */
#cmakedefine HAVE_INTTYPES_H 1
/* Define to 1 if you have the <io.h> header file. */ /* Define to 1 if you have the <io.h> header file. */
#cmakedefine HAVE_IO_H 1 #cmakedefine HAVE_IO_H 1
/* Define to 1 if you have the `jbg_newlen' function. */ /* Define to 1 if you have the `jbg_newlen' function. */
#cmakedefine HAVE_JBG_NEWLEN 1 #cmakedefine HAVE_JBG_NEWLEN 1
/* Define to 1 if you have the `lfind' function. */
#cmakedefine HAVE_LFIND 1
/* Define to 1 if you have the `mmap' function. */ /* Define to 1 if you have the `mmap' function. */
#cmakedefine HAVE_MMAP 1 #cmakedefine HAVE_MMAP 1
/* Define to 1 if you have the <OpenGL/glu.h> header file. */
#cmakedefine HAVE_OPENGL_GLU_H 1
/* Define to 1 if you have the <OpenGL/gl.h> header file. */
#cmakedefine HAVE_OPENGL_GL_H 1
/* Define to 1 if you have the <search.h> header file. */
#cmakedefine HAVE_SEARCH_H 1
/* Define to 1 if you have the `setmode' function. */ /* Define to 1 if you have the `setmode' function. */
#cmakedefine HAVE_SETMODE 1 #cmakedefine HAVE_SETMODE 1
/* Define to 1 if you have the `snprintf' function. */
#cmakedefine HAVE_SNPRINTF 1
/* Define to 1 if you have the <stdint.h> header file. */
#cmakedefine HAVE_STDINT_H 1
/* Define to 1 if you have the `strcasecmp' function. */
#cmakedefine HAVE_STRCASECMP 1
/* Define to 1 if you have the <strings.h> header file. */ /* Define to 1 if you have the <strings.h> header file. */
#cmakedefine HAVE_STRINGS_H 1 #cmakedefine HAVE_STRINGS_H 1
/* Define to 1 if you have the <string.h> header file. */
#cmakedefine HAVE_STRING_H 1
/* Define to 1 if you have the `strtol' function. */
#cmakedefine HAVE_STRTOL 1
/* Define to 1 if you have the `strtoll' function. */
#cmakedefine HAVE_STRTOLL 1
/* Define to 1 if you have the `strtoul' function. */
#cmakedefine HAVE_STRTOUL 1
/* Define to 1 if you have the `strtoull' function. */
#cmakedefine HAVE_STRTOULL 1
/* Define to 1 if you have the <sys/time.h> header file. */
#cmakedefine HAVE_SYS_TIME_H 1
/* Define to 1 if you have the <sys/types.h> header file. */ /* Define to 1 if you have the <sys/types.h> header file. */
#cmakedefine HAVE_SYS_TYPES_H 1 #cmakedefine HAVE_SYS_TYPES_H 1
@ -105,20 +62,17 @@
#cmakedefine HAVE_UNISTD_H 1 #cmakedefine HAVE_UNISTD_H 1
/* 8/12 bit libjpeg dual mode enabled */ /* 8/12 bit libjpeg dual mode enabled */
#cmakedefine JPEG_DUAL_MODE_8_12 1 #cmakedefine JPEG_DUAL_MODE_8_12 1 1
/* Support LERC compression */
#cmakedefine LERC_SUPPORT 1
/* 12bit libjpeg primary include file with path */ /* 12bit libjpeg primary include file with path */
#define LIBJPEG_12_PATH @LIBJPEG_12_PATH@ #define LIBJPEG_12_PATH "@LIBJPEG_12_PATH@"
/* Support LZMA2 compression */ /* Support LZMA2 compression */
#cmakedefine LZMA_SUPPORT 1 #cmakedefine LZMA_SUPPORT 1
/* Support ZSTD compression */
#cmakedefine ZSTD_SUPPORT 1
/* Support WEBP compression */
#cmakedefine WEBP_SUPPORT 1
/* Name of package */ /* Name of package */
#define PACKAGE "@PACKAGE_NAME@" #define PACKAGE "@PACKAGE_NAME@"
@ -128,80 +82,30 @@
/* Define to the full name of this package. */ /* Define to the full name of this package. */
#define PACKAGE_NAME "@PACKAGE_NAME@" #define PACKAGE_NAME "@PACKAGE_NAME@"
/* Define to the full name and version of this package. */
#define PACKAGE_STRING "@PACKAGE_STRING@"
/* Define to the one symbol short name of this package. */ /* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "@PACKAGE_TARNAME@" #define PACKAGE_TARNAME "@PACKAGE_TARNAME@"
/* Define to the home page for this package. */ /* Define to the home page for this package. */
#define PACKAGE_URL "@PACKAGE_URL@" #define PACKAGE_URL "@PACKAGE_URL@"
/* Define to the version of this package. */ /* Size of size_t */
#define PACKAGE_VERSION "@PACKAGE_VERSION@" #define SIZEOF_SIZE_T @SIZEOF_SIZE_T@
/* The size of `signed int', as computed by sizeof. */
#define SIZEOF_SIGNED_INT @SIZEOF_SIGNED_INT@
/* The size of `signed long', as computed by sizeof. */
#define SIZEOF_SIGNED_LONG @SIZEOF_SIGNED_LONG@
/* The size of `signed long long', as computed by sizeof. */
#define SIZEOF_SIGNED_LONG_LONG @SIZEOF_SIGNED_LONG_LONG@
/* The size of `unsigned char *', as computed by sizeof. */
#define SIZEOF_UNSIGNED_CHAR_P @SIZEOF_UNSIGNED_CHAR_P@
/* The size of `unsigned int', as computed by sizeof. */
#define SIZEOF_UNSIGNED_INT @SIZEOF_UNSIGNED_INT@
/* The size of `unsigned long', as computed by sizeof. */
#define SIZEOF_UNSIGNED_LONG @SIZEOF_UNSIGNED_LONG@
/* The size of `unsigned long long', as computed by sizeof. */
#define SIZEOF_UNSIGNED_LONG_LONG @SIZEOF_UNSIGNED_LONG_LONG@
/* The size of `unsigned short', as computed by sizeof. */
#define SIZEOF_UNSIGNED_SHORT @SIZEOF_UNSIGNED_SHORT@
/* Default size of the strip in bytes (when strip chopping enabled) */ /* Default size of the strip in bytes (when strip chopping enabled) */
#define STRIP_SIZE_DEFAULT @STRIP_SIZE_DEFAULT@ #cmakedefine STRIP_SIZE_DEFAULT @STRIP_SIZE_DEFAULT@
/* Signed 32-bit type formatter */ /** Maximum number of TIFF IFDs that libtiff can iterate through in a file. */
#define TIFF_INT32_FORMAT "@TIFF_INT32_FORMAT@" #define TIFF_MAX_DIR_COUNT @TIFF_MAX_DIR_COUNT@
/* Signed 64-bit type formatter */
#define TIFF_INT64_FORMAT "@TIFF_INT64_FORMAT@"
/* Pointer difference type formatter */
#define TIFF_PTRDIFF_FORMAT "@TIFF_PTRDIFF_FORMAT@"
/* Unsigned size type formatter */
#define TIFF_SIZE_FORMAT "@TIFF_SIZE_FORMAT@"
/* Signed size type formatter */
#define TIFF_SSIZE_FORMAT "@TIFF_SSIZE_FORMAT@"
/* Unsigned 32-bit type formatter */
#define TIFF_UINT32_FORMAT "@TIFF_UINT32_FORMAT@"
/* Unsigned 64-bit type formatter */
#define TIFF_UINT64_FORMAT "@TIFF_UINT64_FORMAT@"
/* Unsigned 8-bit type */
#define TIFF_UINT8_T @TIFF_UINT8_T@
/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */
#undef TIME_WITH_SYS_TIME
/* Define to 1 if your <sys/time.h> declares `struct tm'. */
#cmakedefine TM_IN_SYS_TIME 1
/* define to use win32 IO system */ /* define to use win32 IO system */
#cmakedefine USE_WIN32_FILEIO 1 #cmakedefine USE_WIN32_FILEIO 1
/* Version number of package */ /* Support WEBP compression */
#define VERSION "@PACKAGE_VERSION@" #cmakedefine WEBP_SUPPORT 1
/* Support ZSTD compression */
#cmakedefine ZSTD_SUPPORT 1
/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
significant byte first (like Motorola and SPARC, unlike Intel). */ significant byte first (like Motorola and SPARC, unlike Intel). */
@ -215,17 +119,21 @@
# endif # endif
#endif #endif
/* Number of bits in a file offset, on hosts where this is settable. */ #if !defined(__MINGW32__)
#define _FILE_OFFSET_BITS @FILE_OFFSET_BITS@ # define TIFF_SIZE_FORMAT "zu"
#endif
/* Define to `__inline__' or `__inline' if that's what the C compiler #if SIZEOF_SIZE_T == 8
calls it, or to nothing if 'inline' is not supported under any name. */ # define TIFF_SSIZE_FORMAT PRId64
#ifndef __cplusplus # if defined(__MINGW32__)
#define inline @INLINE_KEYWORD@ # define TIFF_SIZE_FORMAT PRIu64
# endif
#elif SIZEOF_SIZE_T == 4
# define TIFF_SSIZE_FORMAT PRId32
# if defined(__MINGW32__)
# define TIFF_SIZE_FORMAT PRIu32
# endif
#else
# error "Unsupported size_t size; please submit a bug report"
#endif #endif
/* Define to `long int' if <sys/types.h> does not define. */ /* clang-format on */
#undef off_t
/* Define to `unsigned int' if <sys/types.h> does not define. */
#undef size_t

3667
3rdparty/libtiff/tif_dir.c vendored
View File

File diff suppressed because it is too large Load Diff

467
3rdparty/libtiff/tif_dir.h vendored
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 tdir_tag; /* see below */ {
uint16 tdir_type; /* data type; see below */ uint16_t tdir_tag; /* see below */
uint64 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 toff_short; union
uint32 toff_long; {
uint64 toff_long8; uint16_t toff_short;
} tdir_offset; /* either offset or the data itself if fits */ uint32_t toff_long;
uint8 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 {
/* bit vector of fields that are set */ #define FIELDSET_ITEMS 4
unsigned long td_fieldsset[FIELD_SETLONGS]; /* bit vector of fields that are set */
uint32_t td_fieldsset[FIELDSET_ITEMS];
uint32 td_imagewidth, td_imagelength, td_imagedepth; uint32_t td_imagewidth, td_imagelength, td_imagedepth;
uint32 td_tilewidth, td_tilelength, td_tiledepth; uint32_t td_tilewidth, td_tilelength, td_tiledepth;
uint32 td_subfiletype; uint32_t td_subfiletype;
uint16 td_bitspersample; uint16_t td_bitspersample;
uint16 td_sampleformat; uint16_t td_sampleformat;
uint16 td_compression; uint16_t td_compression;
uint16 td_photometric; uint16_t td_photometric;
uint16 td_threshholding; uint16_t td_threshholding;
uint16 td_fillorder; uint16_t td_fillorder;
uint16 td_orientation; uint16_t td_orientation;
uint16 td_samplesperpixel; uint16_t td_samplesperpixel;
uint32 td_rowsperstrip; uint32_t td_rowsperstrip;
uint16 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 td_resolutionunit; uint16_t td_resolutionunit;
uint16 td_planarconfig; uint16_t td_planarconfig;
float td_xposition, td_yposition; float td_xposition, td_yposition;
uint16 td_pagenumber[2]; uint16_t td_pagenumber[2];
uint16* td_colormap[3]; uint16_t *td_colormap[3];
uint16 td_halftonehints[2]; uint16_t td_halftonehints[2];
uint16 td_extrasamples; uint16_t td_extrasamples;
uint16* 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 td_stripsperimage; uint32_t td_stripsperimage;
uint32 td_nstrips; /* size of offset & bytecount arrays */ uint32_t td_nstrips; /* size of offset & bytecount arrays */
uint64* td_stripoffset_p; /* should be accessed with TIFFGetStrileOffset */ uint64_t
uint64* td_stripbytecount_p; /* should be accessed with TIFFGetStrileByteCount */ *td_stripoffset_p; /* should be accessed with TIFFGetStrileOffset */
uint32 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 td_nsubifd; uint16_t td_nsubifd;
uint64* td_subifd; uint64_t *td_subifd;
/* YCbCr parameters */ /* YCbCr parameters */
uint16 td_ycbcrsubsampling[2]; uint16_t td_ycbcrsubsampling[2];
uint16 td_ycbcrpositioning; uint16_t td_ycbcrpositioning;
/* Colorimetry parameters */ /* Colorimetry parameters */
uint16* 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,141 @@ 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 * FIELDSET_ITEMS - 1)
#define BITn(n) (((unsigned long)1L)<<((n)&0x1f)) #define BITn(n) (((uint32_t)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 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 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 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 reserved; /* reserved for future extension */ 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); extern int _TIFFMergeFields(TIFF *, const TIFFField[], uint32_t);
extern const TIFFField* _TIFFFindOrRegisterField(TIFF *, uint32, TIFFDataType); extern const TIFFField *_TIFFFindOrRegisterField(TIFF *, uint32_t,
extern TIFFField* _TIFFCreateAnonField(TIFF *, uint32, 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);
extern int _TIFFGetOffsetFromDirNumber(TIFF *tif, tdir_t dirn,
uint64_t *diroff);
extern int _TIFFRemoveEntryFromDirectoryListByOffset(TIFF *tif,
uint64_t diroff);
#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:
*/

2280
3rdparty/libtiff/tif_dirinfo.c vendored
View File

File diff suppressed because it is too large Load Diff

12973
3rdparty/libtiff/tif_dirread.c vendored
View File

File diff suppressed because it is too large Load Diff

5916
3rdparty/libtiff/tif_dirwrite.c vendored
View File

File diff suppressed because it is too large Load Diff

159
3rdparty/libtiff/tif_dumpmode.c vendored
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,113 +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* pp, tmsize_t cc, uint16 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* buf, tmsize_t cc, uint16 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)
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module,
"Not enough data for scanline %lu, expected a request for at most %I64d bytes, got a request for %I64d bytes", "Not enough data for scanline %" PRIu32
(unsigned long) tif->tif_row, ", expected a request for at most %" TIFF_SSIZE_FORMAT
(signed __int64) tif->tif_rawcc, " bytes, got a request for %" TIFF_SSIZE_FORMAT " bytes",
(signed __int64) cc); tif->tif_row, tif->tif_rawcc, cc);
#else return (0);
TIFFErrorExt(tif->tif_clientdata, module, }
"Not enough data for scanline %lu, expected a request for at most %lld bytes, got a request for %lld bytes", /*
(unsigned long) tif->tif_row, * Avoid copy if client has setup raw
(signed long long) tif->tif_rawcc, * data buffer to avoid extra copy.
(signed long long) cc); */
#endif if (tif->tif_rawcp != buf)
return (0); _TIFFmemcpy(buf, tif->tif_rawcp, cc);
} tif->tif_rawcp += cc;
/* tif->tif_rawcc -= cc;
* Avoid copy if client has setup raw return (1);
* data buffer to avoid extra copy.
*/
if (tif->tif_rawcp != buf)
_TIFFmemcpy(buf, tif->tif_rawcp, cc);
tif->tif_rawcp += cc;
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 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
3rdparty/libtiff/tif_error.c vendored
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);
}
}

62
3rdparty/libtiff/tif_extension.c vendored
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.
*/ */
@ -26,26 +26,26 @@
* TIFF Library. * TIFF Library.
* *
* Various routines support external extension of the tag set, and other * Various routines support external extension of the tag set, and other
* application extension capabilities. * application extension capabilities.
*/ */
#include "tiffiop.h" #include "tiffiop.h"
int TIFFGetTagListCount( TIFF *tif ) int TIFFGetTagListCount(TIFF *tif)
{ {
TIFFDirectory* td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
return td->td_customValueCount; return td->td_customValueCount;
} }
uint32 TIFFGetTagListEntry( TIFF *tif, int tag_index ) uint32_t TIFFGetTagListEntry(TIFF *tif, int tag_index)
{ {
TIFFDirectory* td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
if( tag_index < 0 || tag_index >= td->td_customValueCount ) if (tag_index < 0 || tag_index >= td->td_customValueCount)
return (uint32)(-1); return (uint32_t)(-1);
else else
return td->td_customValues[tag_index].info->field_tag; return td->td_customValues[tag_index].info->field_tag;
} }
@ -55,27 +55,27 @@ uint32 TIFFGetTagListEntry( TIFF *tif, int tag_index )
** structure to application code without giving access to the private ** structure to application code without giving access to the private
** TIFF structure. ** TIFF structure.
*/ */
TIFFTagMethods *TIFFAccessTagMethods( TIFF *tif ) TIFFTagMethods *TIFFAccessTagMethods(TIFF *tif)
{ {
return &(tif->tif_tagmethods); return &(tif->tif_tagmethods);
} }
void *TIFFGetClientInfo( TIFF *tif, const char *name ) void *TIFFGetClientInfo(TIFF *tif, const char *name)
{ {
TIFFClientInfoLink *psLink = tif->tif_clientinfo; TIFFClientInfoLink *psLink = tif->tif_clientinfo;
while( psLink != NULL && strcmp(psLink->name,name) != 0 ) while (psLink != NULL && strcmp(psLink->name, name) != 0)
psLink = psLink->next; psLink = psLink->next;
if( psLink != NULL ) if (psLink != NULL)
return psLink->data; return psLink->data;
else else
return NULL; return NULL;
} }
void TIFFSetClientInfo( TIFF *tif, void *data, const char *name ) void TIFFSetClientInfo(TIFF *tif, void *data, const char *name)
{ {
TIFFClientInfoLink *psLink = tif->tif_clientinfo; TIFFClientInfoLink *psLink = tif->tif_clientinfo;
@ -84,10 +84,10 @@ void TIFFSetClientInfo( TIFF *tif, void *data, const char *name )
** Do we have an existing link with this name? If so, just ** Do we have an existing link with this name? If so, just
** set it. ** set it.
*/ */
while( psLink != NULL && strcmp(psLink->name,name) != 0 ) while (psLink != NULL && strcmp(psLink->name, name) != 0)
psLink = psLink->next; psLink = psLink->next;
if( psLink != NULL ) if (psLink != NULL)
{ {
psLink->data = data; psLink->data = data;
return; return;
@ -97,20 +97,14 @@ void TIFFSetClientInfo( TIFF *tif, void *data, const char *name )
** Create a new link. ** Create a new link.
*/ */
psLink = (TIFFClientInfoLink *) _TIFFmalloc(sizeof(TIFFClientInfoLink)); psLink =
assert (psLink != NULL); (TIFFClientInfoLink *)_TIFFmallocExt(tif, sizeof(TIFFClientInfoLink));
assert(psLink != NULL);
psLink->next = tif->tif_clientinfo; psLink->next = tif->tif_clientinfo;
psLink->name = (char *) _TIFFmalloc((tmsize_t)(strlen(name)+1)); psLink->name = (char *)_TIFFmallocExt(tif, (tmsize_t)(strlen(name) + 1));
assert (psLink->name != NULL); assert(psLink->name != NULL);
strcpy(psLink->name, name); strcpy(psLink->name, name);
psLink->data = data; psLink->data = data;
tif->tif_clientinfo = psLink; tif->tif_clientinfo = psLink;
} }
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

2743
3rdparty/libtiff/tif_fax3.c vendored
View File

File diff suppressed because it is too large Load Diff

901
3rdparty/libtiff/tif_fax3.h vendored
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.
* *
@ -41,7 +41,7 @@
* The routine must have the type signature given below; * The routine must have the type signature given below;
* for example: * for example:
* *
* fillruns(unsigned char* buf, uint32* runs, uint32* erun, uint32 lastx) * fillruns(unsigned char* buf, uint32_t* runs, uint32_t* erun, uint32_t lastx)
* *
* where buf is place to set the bits, runs is the array of b&w run * where buf is place to set the bits, runs is the array of b&w run
* lengths (white then black), erun is the last run in the array, and * lengths (white then black), erun is the last run in the array, and
@ -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*, uint32*, uint32); 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*, uint32*, uint32); 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 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) 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) 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) 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
3rdparty/libtiff/tif_flush.c vendored
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:
*/

4757
3rdparty/libtiff/tif_getimage.c vendored
View File

File diff suppressed because it is too large Load Diff

603
3rdparty/libtiff/tif_hash_set.c vendored 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_config.h"
#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;
}
/************************************************************************/
/* 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;
}
/************************************************************************/
/* 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
3rdparty/libtiff/tif_hash_set.h vendored 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);
int TIFFHashSetSize(const TIFFHashSet *set);
#ifdef notused
void TIFFHashSetClear(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 */

294
3rdparty/libtiff/tif_jbig.c vendored
View File

@ -35,199 +35,197 @@
#ifdef JBIG_SUPPORT #ifdef JBIG_SUPPORT
#include "jbig.h" #include "jbig.h"
static int JBIGSetupDecode(TIFF* tif) static int JBIGSetupDecode(TIFF *tif)
{ {
if (TIFFNumberOfStrips(tif) != 1) if (TIFFNumberOfStrips(tif) != 1)
{ {
TIFFErrorExt(tif->tif_clientdata, "JBIG", "Multistrip images not supported in decoder"); TIFFErrorExtR(tif, "JBIG",
return 0; "Multistrip images not supported in decoder");
} return 0;
}
return 1; return 1;
} }
static int JBIGDecode(TIFF* tif, uint8* buffer, tmsize_t size, uint16 s) static int JBIGDecode(TIFF *tif, uint8_t *buffer, tmsize_t size, uint16_t s)
{ {
struct jbg_dec_state decoder; struct jbg_dec_state decoder;
int decodeStatus = 0; int decodeStatus = 0;
unsigned char* pImage = NULL; unsigned char *pImage = NULL;
unsigned long decodedSize; unsigned long decodedSize;
(void) s; (void)s;
if (isFillOrder(tif, tif->tif_dir.td_fillorder)) if (isFillOrder(tif, tif->tif_dir.td_fillorder))
{ {
TIFFReverseBits(tif->tif_rawcp, tif->tif_rawcc); TIFFReverseBits(tif->tif_rawcp, tif->tif_rawcc);
} }
jbg_dec_init(&decoder); jbg_dec_init(&decoder);
#if defined(HAVE_JBG_NEWLEN) #if defined(HAVE_JBG_NEWLEN)
jbg_newlen(tif->tif_rawcp, (size_t)tif->tif_rawcc); jbg_newlen(tif->tif_rawcp, (size_t)tif->tif_rawcc);
/* /*
* I do not check the return status of jbg_newlen because even if this * I do not check the return status of jbg_newlen because even if this
* function fails it does not necessarily mean that decoding the image * function fails it does not necessarily mean that decoding the image
* will fail. It is generally only needed for received fax images * will fail. It is generally only needed for received fax images
* that do not contain the actual length of the image in the BIE * that do not contain the actual length of the image in the BIE
* header. I do not log when an error occurs because that will cause * header. I do not log when an error occurs because that will cause
* problems when converting JBIG encoded TIFF's to * problems when converting JBIG encoded TIFF's to
* PostScript. As long as the actual image length is contained in the * PostScript. As long as the actual image length is contained in the
* BIE header jbg_dec_in should succeed. * BIE header jbg_dec_in should succeed.
*/ */
#endif /* HAVE_JBG_NEWLEN */ #endif /* HAVE_JBG_NEWLEN */
decodeStatus = jbg_dec_in(&decoder, (unsigned char*)tif->tif_rawcp, decodeStatus = jbg_dec_in(&decoder, (unsigned char *)tif->tif_rawcp,
(size_t)tif->tif_rawcc, NULL); (size_t)tif->tif_rawcc, NULL);
if (JBG_EOK != decodeStatus) if (JBG_EOK != decodeStatus)
{ {
/* /*
* XXX: JBG_EN constant was defined in pre-2.0 releases of the * XXX: JBG_EN constant was defined in pre-2.0 releases of the
* JBIG-KIT. Since the 2.0 the error reporting functions were * JBIG-KIT. Since the 2.0 the error reporting functions were
* changed. We will handle both cases here. * changed. We will handle both cases here.
*/ */
TIFFErrorExt(tif->tif_clientdata, TIFFErrorExtR(tif, "JBIG", "Error (%d) decoding: %s", decodeStatus,
"JBIG", "Error (%d) decoding: %s",
decodeStatus,
#if defined(JBG_EN) #if defined(JBG_EN)
jbg_strerror(decodeStatus, JBG_EN) jbg_strerror(decodeStatus, JBG_EN)
#else #else
jbg_strerror(decodeStatus) jbg_strerror(decodeStatus)
#endif #endif
); );
jbg_dec_free(&decoder); jbg_dec_free(&decoder);
return 0; return 0;
} }
decodedSize = jbg_dec_getsize(&decoder); decodedSize = jbg_dec_getsize(&decoder);
if( (tmsize_t)decodedSize < size ) if ((tmsize_t)decodedSize < size)
{ {
TIFFWarningExt(tif->tif_clientdata, "JBIG", TIFFWarningExtR(tif, "JBIG",
"Only decoded %lu bytes, whereas %lu requested", "Only decoded %lu bytes, whereas %" TIFF_SSIZE_FORMAT
decodedSize, (unsigned long)size); " requested",
} decodedSize, size);
else if( (tmsize_t)decodedSize > size ) }
{ else if ((tmsize_t)decodedSize > size)
TIFFErrorExt(tif->tif_clientdata, "JBIG", {
"Decoded %lu bytes, whereas %lu were requested", TIFFErrorExtR(tif, "JBIG",
decodedSize, (unsigned long)size); "Decoded %lu bytes, whereas %" TIFF_SSIZE_FORMAT
jbg_dec_free(&decoder); " were requested",
return 0; decodedSize, size);
} jbg_dec_free(&decoder);
pImage = jbg_dec_getimage(&decoder, 0); return 0;
_TIFFmemcpy(buffer, pImage, decodedSize); }
jbg_dec_free(&decoder); pImage = jbg_dec_getimage(&decoder, 0);
_TIFFmemcpy(buffer, pImage, decodedSize);
jbg_dec_free(&decoder);
tif->tif_rawcp += tif->tif_rawcc; tif->tif_rawcp += tif->tif_rawcc;
tif->tif_rawcc = 0; tif->tif_rawcc = 0;
return 1; return 1;
} }
static int JBIGSetupEncode(TIFF* tif) static int JBIGSetupEncode(TIFF *tif)
{ {
if (TIFFNumberOfStrips(tif) != 1) if (TIFFNumberOfStrips(tif) != 1)
{ {
TIFFErrorExt(tif->tif_clientdata, "JBIG", "Multistrip images not supported in encoder"); TIFFErrorExtR(tif, "JBIG",
return 0; "Multistrip images not supported in encoder");
} return 0;
}
return 1; return 1;
} }
static int JBIGCopyEncodedData(TIFF* tif, unsigned char* pp, size_t cc, uint16 s) static int JBIGCopyEncodedData(TIFF *tif, unsigned char *pp, size_t cc,
uint16_t s)
{ {
(void) s; (void)s;
while (cc > 0) while (cc > 0)
{ {
tmsize_t n = (tmsize_t)cc; tmsize_t n = (tmsize_t)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);
_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 -= (size_t)n; cc -= (size_t)n;
if (tif->tif_rawcc >= tif->tif_rawdatasize && if (tif->tif_rawcc >= tif->tif_rawdatasize && !TIFFFlushData1(tif))
!TIFFFlushData1(tif)) {
{ return (-1);
return (-1); }
} }
}
return (1); return (1);
} }
static void JBIGOutputBie(unsigned char* buffer, size_t len, void* userData) static void JBIGOutputBie(unsigned char *buffer, size_t len, void *userData)
{ {
TIFF* tif = (TIFF*)userData; TIFF *tif = (TIFF *)userData;
if (isFillOrder(tif, tif->tif_dir.td_fillorder)) if (isFillOrder(tif, tif->tif_dir.td_fillorder))
{ {
TIFFReverseBits(buffer, (tmsize_t)len); TIFFReverseBits(buffer, (tmsize_t)len);
} }
JBIGCopyEncodedData(tif, buffer, len, 0); JBIGCopyEncodedData(tif, buffer, len, 0);
} }
static int JBIGEncode(TIFF* tif, uint8* buffer, tmsize_t size, uint16 s) static int JBIGEncode(TIFF *tif, uint8_t *buffer, tmsize_t size, uint16_t s)
{ {
TIFFDirectory* dir = &tif->tif_dir; TIFFDirectory *dir = &tif->tif_dir;
struct jbg_enc_state encoder; struct jbg_enc_state encoder;
(void) size, (void) s; (void)size, (void)s;
jbg_enc_init(&encoder, jbg_enc_init(&encoder, dir->td_imagewidth, dir->td_imagelength, 1, &buffer,
dir->td_imagewidth, JBIGOutputBie, tif);
dir->td_imagelength, /*
1, * jbg_enc_out does the "real" encoding. As data is encoded,
&buffer, * JBIGOutputBie is called, which writes the data to the directory.
JBIGOutputBie, */
tif); jbg_enc_out(&encoder);
/* jbg_enc_free(&encoder);
* jbg_enc_out does the "real" encoding. As data is encoded,
* JBIGOutputBie is called, which writes the data to the directory.
*/
jbg_enc_out(&encoder);
jbg_enc_free(&encoder);
return 1; return 1;
} }
int TIFFInitJBIG(TIFF* tif, int scheme) int TIFFInitJBIG(TIFF *tif, int scheme)
{ {
(void)scheme; (void)scheme;
assert(scheme == COMPRESSION_JBIG); assert(scheme == COMPRESSION_JBIG);
/* /*
* These flags are set so the JBIG Codec can control when to reverse * These flags are set so the JBIG Codec can control when to reverse
* bits and when not to and to allow the jbig decoder and bit reverser * bits and when not to and to allow the jbig decoder and bit reverser
* to write to memory when necessary. * to write to memory when necessary.
*/ */
tif->tif_flags |= TIFF_NOBITREV; tif->tif_flags |= TIFF_NOBITREV;
tif->tif_flags &= ~TIFF_MAPPED; tif->tif_flags &= ~TIFF_MAPPED;
/* We may have read from a previous IFD and thus set TIFF_BUFFERMMAP and
* cleared TIFF_MYBUFFER. It is necessary to restore them to their initial
* value to be consistent with the state of a non-memory mapped file.
*/
if (tif->tif_flags & TIFF_BUFFERMMAP)
{
tif->tif_rawdata = NULL;
tif->tif_rawdatasize = 0;
tif->tif_flags &= ~TIFF_BUFFERMMAP;
tif->tif_flags |= TIFF_MYBUFFER;
}
/* Setup the function pointers for encode, decode, and cleanup. */ /* Setup the function pointers for encode, decode, and cleanup. */
tif->tif_setupdecode = JBIGSetupDecode; tif->tif_setupdecode = JBIGSetupDecode;
tif->tif_decodestrip = JBIGDecode; tif->tif_decodestrip = JBIGDecode;
tif->tif_setupencode = JBIGSetupEncode; tif->tif_setupencode = JBIGSetupEncode;
tif->tif_encodestrip = JBIGEncode; tif->tif_encodestrip = JBIGEncode;
return 1; return 1;
} }
#endif /* JBIG_SUPPORT */ #endif /* JBIG_SUPPORT */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

4101
3rdparty/libtiff/tif_jpeg.c vendored
View File

File diff suppressed because it is too large Load Diff

88
3rdparty/libtiff/tif_jpeg_12.c vendored
View File

@ -1,69 +1,63 @@
#include "tiffiop.h" #include "tiffiop.h"
#if defined(HAVE_JPEGTURBO_DUAL_MODE_8_12)
#define JPEG_DUAL_MODE_8_12
#endif
#if defined(JPEG_DUAL_MODE_8_12) #if defined(JPEG_DUAL_MODE_8_12)
# define TIFFInitJPEG TIFFInitJPEG_12 #define FROM_TIF_JPEG_12
# define TIFFJPEGIsFullStripRequired TIFFJPEGIsFullStripRequired_12
int #ifdef TIFFInitJPEG
TIFFInitJPEG_12(TIFF* tif, int scheme); #undef TIFFInitJPEG
#endif
#define TIFFInitJPEG TIFFInitJPEG_12
# include LIBJPEG_12_PATH #ifdef TIFFJPEGIsFullStripRequired
#undef TIFFJPEGIsFullStripRequired
#endif
#define TIFFJPEGIsFullStripRequired TIFFJPEGIsFullStripRequired_12
# include "tif_jpeg.c" int TIFFInitJPEG_12(TIFF *tif, int scheme);
int TIFFReInitJPEG_12( TIFF *tif, int scheme, int is_encode ) #if !defined(HAVE_JPEGTURBO_DUAL_MODE_8_12)
#include LIBJPEG_12_PATH
#endif
#include "tif_jpeg.c"
int TIFFReInitJPEG_12(TIFF *tif, const JPEGOtherSettings *otherSettings,
int scheme, int is_encode)
{ {
JPEGState* sp; JPEGState *sp;
uint8_t *new_tif_data;
(void)scheme;
assert(scheme == COMPRESSION_JPEG); assert(scheme == COMPRESSION_JPEG);
new_tif_data =
(uint8_t *)_TIFFreallocExt(tif, tif->tif_data, sizeof(JPEGState));
if (new_tif_data == NULL)
{
TIFFErrorExtR(tif, "TIFFReInitJPEG_12",
"No space for JPEG state block");
return 0;
}
tif->tif_data = new_tif_data;
_TIFFmemset(tif->tif_data, 0, sizeof(JPEGState));
TIFFInitJPEGCommon(tif);
sp = JState(tif); sp = JState(tif);
sp->tif = tif; /* back link */ sp->otherSettings = *otherSettings;
/* if (is_encode)
* Override parent get/set field methods.
*/
tif->tif_tagmethods.vgetfield = JPEGVGetField; /* hook for codec tags */
tif->tif_tagmethods.vsetfield = JPEGVSetField; /* hook for codec tags */
tif->tif_tagmethods.printdir = JPEGPrintDir; /* hook for codec tags */
/*
* Install codec methods.
*/
tif->tif_fixuptags = JPEGFixupTags;
tif->tif_setupdecode = JPEGSetupDecode;
tif->tif_predecode = JPEGPreDecode;
tif->tif_decoderow = JPEGDecode;
tif->tif_decodestrip = JPEGDecode;
tif->tif_decodetile = JPEGDecode;
tif->tif_setupencode = JPEGSetupEncode;
tif->tif_preencode = JPEGPreEncode;
tif->tif_postencode = JPEGPostEncode;
tif->tif_encoderow = JPEGEncode;
tif->tif_encodestrip = JPEGEncode;
tif->tif_encodetile = JPEGEncode;
tif->tif_cleanup = JPEGCleanup;
tif->tif_defstripsize = JPEGDefaultStripSize;
tif->tif_deftilesize = JPEGDefaultTileSize;
tif->tif_flags |= TIFF_NOBITREV; /* no bit reversal, please */
sp->cinfo_initialized = FALSE;
if( is_encode )
return JPEGSetupEncode(tif); return JPEGSetupEncode(tif);
else else
return JPEGSetupDecode(tif); return JPEGSetupDecode(tif);
} }
#endif /* defined(JPEG_DUAL_MODE_8_12) */ #endif /* defined(JPEG_DUAL_MODE_8_12) */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

1206
3rdparty/libtiff/tif_lerc.c vendored Normal file
View File

File diff suppressed because it is too large Load Diff

2882
3rdparty/libtiff/tif_luv.c vendored
View File

File diff suppressed because it is too large Load Diff

743
3rdparty/libtiff/tif_lzma.c vendored
View File

@ -33,471 +33,488 @@
* The codec is derived from ZLIB codec (tif_zip.c). * The codec is derived from ZLIB codec (tif_zip.c).
*/ */
#include "tif_predict.h"
#include "lzma.h" #include "lzma.h"
#include "tif_predict.h"
#include <stdio.h> #include <stdio.h>
/* /*
* State block for each open TIFF file using LZMA2 compression/decompression. * State block for each open TIFF file using LZMA2 compression/decompression.
*/ */
typedef struct { typedef struct
TIFFPredictorState predict; {
lzma_stream stream; TIFFPredictorState predict;
lzma_filter filters[LZMA_FILTERS_MAX + 1]; lzma_stream stream;
lzma_options_delta opt_delta; /* delta filter options */ lzma_filter filters[LZMA_FILTERS_MAX + 1];
lzma_options_lzma opt_lzma; /* LZMA2 filter options */ lzma_options_delta opt_delta; /* delta filter options */
int preset; /* compression level */ lzma_options_lzma opt_lzma; /* LZMA2 filter options */
lzma_check check; /* type of the integrity check */ int preset; /* compression level */
int state; /* state flags */ lzma_check check; /* type of the integrity check */
int state; /* state flags */
#define LSTATE_INIT_DECODE 0x01 #define LSTATE_INIT_DECODE 0x01
#define LSTATE_INIT_ENCODE 0x02 #define LSTATE_INIT_ENCODE 0x02
TIFFVGetMethod vgetparent; /* super-class method */ TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */ TIFFVSetMethod vsetparent; /* super-class method */
} LZMAState; } LZMAState;
#define LState(tif) ((LZMAState*) (tif)->tif_data) #define LState(tif) ((LZMAState *)(tif)->tif_data)
#define DecoderState(tif) LState(tif) #define DecoderState(tif) LState(tif)
#define EncoderState(tif) LState(tif) #define EncoderState(tif) LState(tif)
static int LZMAEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s); static int LZMAEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s);
static int LZMADecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s); static int LZMADecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s);
static const char * static const char *LZMAStrerror(lzma_ret ret)
LZMAStrerror(lzma_ret ret)
{ {
switch (ret) { switch (ret)
case LZMA_OK: {
return "operation completed successfully"; case LZMA_OK:
case LZMA_STREAM_END: return "operation completed successfully";
return "end of stream was reached"; case LZMA_STREAM_END:
case LZMA_NO_CHECK: return "end of stream was reached";
return "input stream has no integrity check"; case LZMA_NO_CHECK:
case LZMA_UNSUPPORTED_CHECK: return "input stream has no integrity check";
return "cannot calculate the integrity check"; case LZMA_UNSUPPORTED_CHECK:
case LZMA_GET_CHECK: return "cannot calculate the integrity check";
return "integrity check type is now available"; case LZMA_GET_CHECK:
case LZMA_MEM_ERROR: return "integrity check type is now available";
return "cannot allocate memory"; case LZMA_MEM_ERROR:
case LZMA_MEMLIMIT_ERROR: return "cannot allocate memory";
return "memory usage limit was reached"; case LZMA_MEMLIMIT_ERROR:
case LZMA_FORMAT_ERROR: return "memory usage limit was reached";
return "file format not recognized"; case LZMA_FORMAT_ERROR:
case LZMA_OPTIONS_ERROR: return "file format not recognized";
return "invalid or unsupported options"; case LZMA_OPTIONS_ERROR:
case LZMA_DATA_ERROR: return "invalid or unsupported options";
return "data is corrupt"; case LZMA_DATA_ERROR:
case LZMA_BUF_ERROR: return "data is corrupt";
return "no progress is possible (stream is truncated or corrupt)"; case LZMA_BUF_ERROR:
case LZMA_PROG_ERROR: return "no progress is possible (stream is truncated or corrupt)";
return "programming error"; case LZMA_PROG_ERROR:
default: return "programming error";
return "unidentified liblzma error"; default:
} return "unidentified liblzma error";
}
} }
static int static int LZMAFixupTags(TIFF *tif)
LZMAFixupTags(TIFF* tif)
{ {
(void) tif; (void)tif;
return 1; return 1;
} }
static int static int LZMASetupDecode(TIFF *tif)
LZMASetupDecode(TIFF* tif)
{ {
LZMAState* sp = DecoderState(tif); LZMAState *sp = DecoderState(tif);
assert(sp != NULL); assert(sp != NULL);
/* if we were last encoding, terminate this mode */
if (sp->state & LSTATE_INIT_ENCODE) {
lzma_end(&sp->stream);
sp->state = 0;
}
sp->state |= LSTATE_INIT_DECODE; /* if we were last encoding, terminate this mode */
return 1; if (sp->state & LSTATE_INIT_ENCODE)
{
lzma_end(&sp->stream);
sp->state = 0;
}
sp->state |= LSTATE_INIT_DECODE;
return 1;
} }
/* /*
* Setup state for decoding a strip. * Setup state for decoding a strip.
*/ */
static int static int LZMAPreDecode(TIFF *tif, uint16_t s)
LZMAPreDecode(TIFF* tif, uint16 s)
{ {
static const char module[] = "LZMAPreDecode"; static const char module[] = "LZMAPreDecode";
LZMAState* sp = DecoderState(tif); LZMAState *sp = DecoderState(tif);
lzma_ret ret; lzma_ret ret;
(void) s; (void)s;
assert(sp != NULL); assert(sp != NULL);
if( (sp->state & LSTATE_INIT_DECODE) == 0 ) if ((sp->state & LSTATE_INIT_DECODE) == 0)
tif->tif_setupdecode(tif); tif->tif_setupdecode(tif);
sp->stream.next_in = tif->tif_rawdata; sp->stream.next_in = tif->tif_rawdata;
sp->stream.avail_in = (size_t) tif->tif_rawcc; sp->stream.avail_in = (size_t)tif->tif_rawcc;
if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc) { if ((tmsize_t)sp->stream.avail_in != tif->tif_rawcc)
TIFFErrorExt(tif->tif_clientdata, module, {
"Liblzma cannot deal with buffers this size"); TIFFErrorExtR(tif, module,
return 0; "Liblzma cannot deal with buffers this size");
} return 0;
}
/* /*
* Disable memory limit when decoding. UINT64_MAX is a flag to disable * Disable memory limit when decoding. UINT64_MAX is a flag to disable
* the limit, we are passing (uint64_t)-1 which should be the same. * the limit, we are passing (uint64_t)-1 which should be the same.
*/ */
ret = lzma_stream_decoder(&sp->stream, (uint64_t)-1, 0); ret = lzma_stream_decoder(&sp->stream, (uint64_t)-1, 0);
if (ret != LZMA_OK) { if (ret != LZMA_OK)
TIFFErrorExt(tif->tif_clientdata, module, {
"Error initializing the stream decoder, %s", TIFFErrorExtR(tif, module, "Error initializing the stream decoder, %s",
LZMAStrerror(ret)); LZMAStrerror(ret));
return 0; return 0;
} }
return 1; return 1;
} }
static int static int LZMADecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
LZMADecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{ {
static const char module[] = "LZMADecode"; static const char module[] = "LZMADecode";
LZMAState* sp = DecoderState(tif); LZMAState *sp = DecoderState(tif);
(void) s; (void)s;
assert(sp != NULL); assert(sp != NULL);
assert(sp->state == LSTATE_INIT_DECODE); assert(sp->state == LSTATE_INIT_DECODE);
sp->stream.next_in = tif->tif_rawcp; sp->stream.next_in = tif->tif_rawcp;
sp->stream.avail_in = (size_t) tif->tif_rawcc; sp->stream.avail_in = (size_t)tif->tif_rawcc;
sp->stream.next_out = op; sp->stream.next_out = op;
sp->stream.avail_out = (size_t) occ; sp->stream.avail_out = (size_t)occ;
if ((tmsize_t)sp->stream.avail_out != occ) { if ((tmsize_t)sp->stream.avail_out != occ)
TIFFErrorExt(tif->tif_clientdata, module, {
"Liblzma cannot deal with buffers this size"); TIFFErrorExtR(tif, module,
return 0; "Liblzma cannot deal with buffers this size");
} return 0;
}
do { do
/* {
* Save the current stream state to properly recover from the /*
* decoding errors later. * Save the current stream state to properly recover from the
*/ * decoding errors later.
const uint8_t *next_in = sp->stream.next_in; */
size_t avail_in = sp->stream.avail_in; const uint8_t *next_in = sp->stream.next_in;
size_t avail_in = sp->stream.avail_in;
lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN); lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN);
if (ret == LZMA_STREAM_END) if (ret == LZMA_STREAM_END)
break; break;
if (ret == LZMA_MEMLIMIT_ERROR) { if (ret == LZMA_MEMLIMIT_ERROR)
lzma_ret r = lzma_stream_decoder(&sp->stream, {
lzma_memusage(&sp->stream), 0); lzma_ret r =
if (r != LZMA_OK) { lzma_stream_decoder(&sp->stream, lzma_memusage(&sp->stream), 0);
TIFFErrorExt(tif->tif_clientdata, module, if (r != LZMA_OK)
"Error initializing the stream decoder, %s", {
LZMAStrerror(r)); TIFFErrorExtR(tif, module,
break; "Error initializing the stream decoder, %s",
} LZMAStrerror(r));
sp->stream.next_in = next_in; break;
sp->stream.avail_in = avail_in; }
continue; sp->stream.next_in = next_in;
} sp->stream.avail_in = avail_in;
if (ret != LZMA_OK) { continue;
TIFFErrorExt(tif->tif_clientdata, module, }
"Decoding error at scanline %lu, %s", if (ret != LZMA_OK)
(unsigned long) tif->tif_row, LZMAStrerror(ret)); {
break; TIFFErrorExtR(tif, module,
} "Decoding error at scanline %" PRIu32 ", %s",
} while (sp->stream.avail_out > 0); tif->tif_row, LZMAStrerror(ret));
if (sp->stream.avail_out != 0) { break;
TIFFErrorExt(tif->tif_clientdata, module, }
"Not enough data at scanline %lu (short %lu bytes)", } while (sp->stream.avail_out > 0);
(unsigned long) tif->tif_row, (unsigned long) sp->stream.avail_out); if (sp->stream.avail_out != 0)
return 0; {
} TIFFErrorExtR(tif, module,
"Not enough data at scanline %" PRIu32
" (short %" TIFF_SIZE_FORMAT " bytes)",
tif->tif_row, sp->stream.avail_out);
return 0;
}
tif->tif_rawcp = (uint8 *)sp->stream.next_in; /* cast away const */ tif->tif_rawcp = (uint8_t *)sp->stream.next_in; /* cast away const */
tif->tif_rawcc = sp->stream.avail_in; tif->tif_rawcc = sp->stream.avail_in;
return 1; return 1;
} }
static int static int LZMASetupEncode(TIFF *tif)
LZMASetupEncode(TIFF* tif)
{ {
LZMAState* sp = EncoderState(tif); LZMAState *sp = EncoderState(tif);
assert(sp != NULL); assert(sp != NULL);
if (sp->state & LSTATE_INIT_DECODE) { if (sp->state & LSTATE_INIT_DECODE)
lzma_end(&sp->stream); {
sp->state = 0; lzma_end(&sp->stream);
} sp->state = 0;
}
sp->state |= LSTATE_INIT_ENCODE; sp->state |= LSTATE_INIT_ENCODE;
return 1; return 1;
} }
/* /*
* Reset encoding state at the start of a strip. * Reset encoding state at the start of a strip.
*/ */
static int static int LZMAPreEncode(TIFF *tif, uint16_t s)
LZMAPreEncode(TIFF* tif, uint16 s)
{ {
static const char module[] = "LZMAPreEncode"; static const char module[] = "LZMAPreEncode";
LZMAState *sp = EncoderState(tif); LZMAState *sp = EncoderState(tif);
lzma_ret ret; lzma_ret ret;
(void) s; (void)s;
assert(sp != NULL); assert(sp != NULL);
if( sp->state != LSTATE_INIT_ENCODE ) if (sp->state != LSTATE_INIT_ENCODE)
tif->tif_setupencode(tif); tif->tif_setupencode(tif);
sp->stream.next_out = tif->tif_rawdata; sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = (size_t)tif->tif_rawdatasize; sp->stream.avail_out = (size_t)tif->tif_rawdatasize;
if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) { if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
TIFFErrorExt(tif->tif_clientdata, module, {
"Liblzma cannot deal with buffers this size"); TIFFErrorExtR(tif, module,
return 0; "Liblzma cannot deal with buffers this size");
} return 0;
ret = lzma_stream_encoder(&sp->stream, sp->filters, sp->check); }
if (ret != LZMA_OK) { ret = lzma_stream_encoder(&sp->stream, sp->filters, sp->check);
TIFFErrorExt(tif->tif_clientdata, module, if (ret != LZMA_OK)
"Error in lzma_stream_encoder(): %s", LZMAStrerror(ret)); {
return 0; TIFFErrorExtR(tif, module, "Error in lzma_stream_encoder(): %s",
} LZMAStrerror(ret));
return 1; return 0;
}
return 1;
} }
/* /*
* Encode a chunk of pixels. * Encode a chunk of pixels.
*/ */
static int static int LZMAEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
LZMAEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{ {
static const char module[] = "LZMAEncode"; static const char module[] = "LZMAEncode";
LZMAState *sp = EncoderState(tif); LZMAState *sp = EncoderState(tif);
assert(sp != NULL); assert(sp != NULL);
assert(sp->state == LSTATE_INIT_ENCODE); assert(sp->state == LSTATE_INIT_ENCODE);
(void) s; (void)s;
sp->stream.next_in = bp; sp->stream.next_in = bp;
sp->stream.avail_in = (size_t) cc; sp->stream.avail_in = (size_t)cc;
if ((tmsize_t)sp->stream.avail_in != cc) { if ((tmsize_t)sp->stream.avail_in != cc)
TIFFErrorExt(tif->tif_clientdata, module, {
"Liblzma cannot deal with buffers this size"); TIFFErrorExtR(tif, module,
return 0; "Liblzma cannot deal with buffers this size");
} return 0;
do { }
lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN); do
if (ret != LZMA_OK) { {
TIFFErrorExt(tif->tif_clientdata, module, lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN);
"Encoding error at scanline %lu, %s", if (ret != LZMA_OK)
(unsigned long) tif->tif_row, LZMAStrerror(ret)); {
return 0; TIFFErrorExtR(tif, module,
} "Encoding error at scanline %" PRIu32 ", %s",
if (sp->stream.avail_out == 0) { tif->tif_row, LZMAStrerror(ret));
tif->tif_rawcc = tif->tif_rawdatasize; return 0;
if (!TIFFFlushData1(tif)) }
return 0; if (sp->stream.avail_out == 0)
sp->stream.next_out = tif->tif_rawdata; {
sp->stream.avail_out = (size_t)tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in LZMAPreEncode */ tif->tif_rawcc = tif->tif_rawdatasize;
} if (!TIFFFlushData1(tif))
} while (sp->stream.avail_in > 0); return 0;
return 1; sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out =
(size_t)
tif->tif_rawdatasize; /* this is a safe typecast, as check
is made already in LZMAPreEncode */
}
} while (sp->stream.avail_in > 0);
return 1;
} }
/* /*
* Finish off an encoded strip by flushing the last * Finish off an encoded strip by flushing the last
* string and tacking on an End Of Information code. * string and tacking on an End Of Information code.
*/ */
static int static int LZMAPostEncode(TIFF *tif)
LZMAPostEncode(TIFF* tif)
{ {
static const char module[] = "LZMAPostEncode"; static const char module[] = "LZMAPostEncode";
LZMAState *sp = EncoderState(tif); LZMAState *sp = EncoderState(tif);
lzma_ret ret; lzma_ret ret;
sp->stream.avail_in = 0; sp->stream.avail_in = 0;
do { do
ret = lzma_code(&sp->stream, LZMA_FINISH); {
switch (ret) { ret = lzma_code(&sp->stream, LZMA_FINISH);
case LZMA_STREAM_END: switch (ret)
case LZMA_OK: {
if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) { case LZMA_STREAM_END:
tif->tif_rawcc = case LZMA_OK:
tif->tif_rawdatasize - sp->stream.avail_out; if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
if (!TIFFFlushData1(tif)) {
return 0; tif->tif_rawcc =
sp->stream.next_out = tif->tif_rawdata; tif->tif_rawdatasize - sp->stream.avail_out;
sp->stream.avail_out = (size_t)tif->tif_rawdatasize; /* this is a safe typecast, as check is made already in ZIPPreEncode */ if (!TIFFFlushData1(tif))
} return 0;
break; sp->stream.next_out = tif->tif_rawdata;
default: sp->stream.avail_out =
TIFFErrorExt(tif->tif_clientdata, module, "Liblzma error: %s", (size_t)
LZMAStrerror(ret)); tif->tif_rawdatasize; /* this is a safe typecast, as
return 0; check is made already in
} ZIPPreEncode */
} while (ret != LZMA_STREAM_END); }
return 1; break;
default:
TIFFErrorExtR(tif, module, "Liblzma error: %s",
LZMAStrerror(ret));
return 0;
}
} while (ret != LZMA_STREAM_END);
return 1;
} }
static void static void LZMACleanup(TIFF *tif)
LZMACleanup(TIFF* tif)
{ {
LZMAState* sp = LState(tif); LZMAState *sp = LState(tif);
assert(sp != 0); assert(sp != 0);
(void)TIFFPredictorCleanup(tif); (void)TIFFPredictorCleanup(tif);
tif->tif_tagmethods.vgetfield = sp->vgetparent; tif->tif_tagmethods.vgetfield = sp->vgetparent;
tif->tif_tagmethods.vsetfield = sp->vsetparent; tif->tif_tagmethods.vsetfield = sp->vsetparent;
if (sp->state) { if (sp->state)
lzma_end(&sp->stream); {
sp->state = 0; lzma_end(&sp->stream);
} sp->state = 0;
_TIFFfree(sp); }
tif->tif_data = NULL; _TIFFfreeExt(tif, sp);
tif->tif_data = NULL;
_TIFFSetDefaultCompressionState(tif); _TIFFSetDefaultCompressionState(tif);
} }
static int static int LZMAVSetField(TIFF *tif, uint32_t tag, va_list ap)
LZMAVSetField(TIFF* tif, uint32 tag, va_list ap)
{ {
static const char module[] = "LZMAVSetField"; static const char module[] = "LZMAVSetField";
LZMAState* sp = LState(tif); LZMAState *sp = LState(tif);
switch (tag) { switch (tag)
case TIFFTAG_LZMAPRESET: {
sp->preset = (int) va_arg(ap, int); case TIFFTAG_LZMAPRESET:
lzma_lzma_preset(&sp->opt_lzma, sp->preset); sp->preset = (int)va_arg(ap, int);
if (sp->state & LSTATE_INIT_ENCODE) { lzma_lzma_preset(&sp->opt_lzma, sp->preset);
lzma_ret ret = lzma_stream_encoder(&sp->stream, if (sp->state & LSTATE_INIT_ENCODE)
sp->filters, {
sp->check); lzma_ret ret =
if (ret != LZMA_OK) { lzma_stream_encoder(&sp->stream, sp->filters, sp->check);
TIFFErrorExt(tif->tif_clientdata, module, if (ret != LZMA_OK)
"Liblzma error: %s", {
LZMAStrerror(ret)); TIFFErrorExtR(tif, module, "Liblzma error: %s",
} LZMAStrerror(ret));
} }
return 1; }
default: return 1;
return (*sp->vsetparent)(tif, tag, ap); default:
} return (*sp->vsetparent)(tif, tag, ap);
/*NOTREACHED*/ }
/*NOTREACHED*/
} }
static int static int LZMAVGetField(TIFF *tif, uint32_t tag, va_list ap)
LZMAVGetField(TIFF* tif, uint32 tag, va_list ap)
{ {
LZMAState* sp = LState(tif); LZMAState *sp = LState(tif);
switch (tag) { switch (tag)
case TIFFTAG_LZMAPRESET: {
*va_arg(ap, int*) = sp->preset; case TIFFTAG_LZMAPRESET:
break; *va_arg(ap, int *) = sp->preset;
default: break;
return (*sp->vgetparent)(tif, tag, ap); default:
} return (*sp->vgetparent)(tif, tag, ap);
return 1; }
return 1;
} }
static const TIFFField lzmaFields[] = { static const TIFFField lzmaFields[] = {
{ TIFFTAG_LZMAPRESET, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, {TIFFTAG_LZMAPRESET, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
FIELD_PSEUDO, TRUE, FALSE, "LZMA2 Compression Preset", NULL }, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE,
"LZMA2 Compression Preset", NULL},
}; };
int int TIFFInitLZMA(TIFF *tif, int scheme)
TIFFInitLZMA(TIFF* tif, int scheme)
{ {
static const char module[] = "TIFFInitLZMA"; static const char module[] = "TIFFInitLZMA";
LZMAState* sp; LZMAState *sp;
lzma_stream tmp_stream = LZMA_STREAM_INIT; lzma_stream tmp_stream = LZMA_STREAM_INIT;
(void)scheme; (void)scheme;
assert( scheme == COMPRESSION_LZMA ); assert(scheme == COMPRESSION_LZMA);
/* /*
* Merge codec-specific tag information. * Merge codec-specific tag information.
*/ */
if (!_TIFFMergeFields(tif, lzmaFields, TIFFArrayCount(lzmaFields))) { if (!_TIFFMergeFields(tif, lzmaFields, TIFFArrayCount(lzmaFields)))
TIFFErrorExt(tif->tif_clientdata, module, {
"Merging LZMA2 codec-specific tags failed"); TIFFErrorExtR(tif, module, "Merging LZMA2 codec-specific tags failed");
return 0; return 0;
} }
/* /*
* Allocate state block so tag methods have storage to record values. * Allocate state block so tag methods have storage to record values.
*/ */
tif->tif_data = (uint8*) _TIFFmalloc(sizeof(LZMAState)); tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(LZMAState));
if (tif->tif_data == NULL) if (tif->tif_data == NULL)
goto bad; goto bad;
sp = LState(tif); sp = LState(tif);
memcpy(&sp->stream, &tmp_stream, sizeof(lzma_stream)); memcpy(&sp->stream, &tmp_stream, sizeof(lzma_stream));
/* /*
* Override parent get/set field methods. * Override parent get/set field methods.
*/ */
sp->vgetparent = tif->tif_tagmethods.vgetfield; sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield = LZMAVGetField; /* hook for codec tags */ tif->tif_tagmethods.vgetfield = LZMAVGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_tagmethods.vsetfield; sp->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vsetfield = LZMAVSetField; /* hook for codec tags */ tif->tif_tagmethods.vsetfield = LZMAVSetField; /* hook for codec tags */
/* Default values for codec-specific fields */ /* Default values for codec-specific fields */
sp->preset = LZMA_PRESET_DEFAULT; /* default comp. level */ sp->preset = LZMA_PRESET_DEFAULT; /* default comp. level */
sp->check = LZMA_CHECK_NONE; sp->check = LZMA_CHECK_NONE;
sp->state = 0; sp->state = 0;
/* Data filters. So far we are using delta and LZMA2 filters only. */ /* Data filters. So far we are using delta and LZMA2 filters only. */
sp->opt_delta.type = LZMA_DELTA_TYPE_BYTE; sp->opt_delta.type = LZMA_DELTA_TYPE_BYTE;
/* /*
* The sample size in bytes seems to be reasonable distance for delta * The sample size in bytes seems to be reasonable distance for delta
* filter. * filter.
*/ */
sp->opt_delta.dist = (tif->tif_dir.td_bitspersample % 8) ? sp->opt_delta.dist = (tif->tif_dir.td_bitspersample % 8)
1 : tif->tif_dir.td_bitspersample / 8; ? 1
sp->filters[0].id = LZMA_FILTER_DELTA; : tif->tif_dir.td_bitspersample / 8;
sp->filters[0].options = &sp->opt_delta; sp->filters[0].id = LZMA_FILTER_DELTA;
sp->filters[0].options = &sp->opt_delta;
lzma_lzma_preset(&sp->opt_lzma, sp->preset); lzma_lzma_preset(&sp->opt_lzma, sp->preset);
sp->filters[1].id = LZMA_FILTER_LZMA2; sp->filters[1].id = LZMA_FILTER_LZMA2;
sp->filters[1].options = &sp->opt_lzma; sp->filters[1].options = &sp->opt_lzma;
sp->filters[2].id = LZMA_VLI_UNKNOWN; sp->filters[2].id = LZMA_VLI_UNKNOWN;
sp->filters[2].options = NULL; sp->filters[2].options = NULL;
/* /*
* Install codec methods. * Install codec methods.
*/ */
tif->tif_fixuptags = LZMAFixupTags; tif->tif_fixuptags = LZMAFixupTags;
tif->tif_setupdecode = LZMASetupDecode; tif->tif_setupdecode = LZMASetupDecode;
tif->tif_predecode = LZMAPreDecode; tif->tif_predecode = LZMAPreDecode;
tif->tif_decoderow = LZMADecode; tif->tif_decoderow = LZMADecode;
tif->tif_decodestrip = LZMADecode; tif->tif_decodestrip = LZMADecode;
tif->tif_decodetile = LZMADecode; tif->tif_decodetile = LZMADecode;
tif->tif_setupencode = LZMASetupEncode; tif->tif_setupencode = LZMASetupEncode;
tif->tif_preencode = LZMAPreEncode; tif->tif_preencode = LZMAPreEncode;
tif->tif_postencode = LZMAPostEncode; tif->tif_postencode = LZMAPostEncode;
tif->tif_encoderow = LZMAEncode; tif->tif_encoderow = LZMAEncode;
tif->tif_encodestrip = LZMAEncode; tif->tif_encodestrip = LZMAEncode;
tif->tif_encodetile = LZMAEncode; tif->tif_encodetile = LZMAEncode;
tif->tif_cleanup = LZMACleanup; tif->tif_cleanup = LZMACleanup;
/* /*
* Setup predictor setup. * Setup predictor setup.
*/ */
(void) TIFFPredictorInit(tif); (void)TIFFPredictorInit(tif);
return 1; return 1;
bad: bad:
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "No space for LZMA2 state block");
"No space for LZMA2 state block"); return 0;
return 0;
} }
#endif /* LZMA_SUPPORT */ #endif /* LZMA_SUPPORT */
/* vim: set ts=8 sts=8 sw=8 noet: */

2234
3rdparty/libtiff/tif_lzw.c vendored
View File

File diff suppressed because it is too large Load Diff

301
3rdparty/libtiff/tif_next.c vendored
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* buf, tmsize_t occ, uint16 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* 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 npixels = 0, grey; break;
tmsize_t op_offset = 0; }
uint32 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)((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 %ld", break;
(long) 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*) bp;
tif->tif_rawcc = cc;
return (1);
bad: bad:
TIFFErrorExt(tif->tif_clientdata, module, "Not enough data for scanline %ld", TIFFErrorExtR(tif, module, "Not enough data for scanline %" PRIu32,
(long) tif->tif_row); tif->tif_row);
return (0); return (0);
} }
static int static int NeXTPreDecode(TIFF *tif, uint16_t s)
NeXTPreDecode(TIFF* tif, uint16 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 = %d", 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:
*/

4884
3rdparty/libtiff/tif_ojpeg.c vendored
View File

File diff suppressed because it is too large Load Diff

1230
3rdparty/libtiff/tif_open.c vendored
View File

File diff suppressed because it is too large Load Diff

516
3rdparty/libtiff/tif_packbits.c vendored
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 s)
{ {
(void) s; (void)s;
tif->tif_data = (uint8*)_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* buf, tmsize_t cc, uint16 s)
{ {
unsigned char* bp = (unsigned char*) buf; unsigned char *bp = (unsigned char *)buf;
uint8* op; uint8_t *op;
uint8* ep; uint8_t *ep;
uint8* 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) -127; switch (state)
*op++ = (uint8) b; {
n -= 128; case BASE: /* initial state, set run/literal */
goto again; if (n > 1)
} {
*op++ = (uint8)(-(n-1)); state = RUN;
*op++ = (uint8) b; if (n > 128)
} else { {
lastliteral = op; *op++ = (uint8_t)-127;
*op++ = 0; *op++ = (uint8_t)b;
*op++ = (uint8) 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) -127; lastliteral = op;
*op++ = (uint8) b; *op++ = 0;
n -= 128; *op++ = (uint8_t)b;
goto again; state = LITERAL;
} }
*op++ = (uint8)(-(n-1)); /* encode run */ break;
*op++ = (uint8) b; case LITERAL: /* last object was literal string */
} else { /* extend literal */ if (n > 1)
if (++(*lastliteral) == 127) {
state = BASE; state = LITERAL_RUN;
*op++ = (uint8) 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) -127; }
*op++ = (uint8) b; *op++ = (uint8_t)(-(n - 1)); /* encode run */
n -= 128; *op++ = (uint8_t)b;
goto again; }
} else
*op++ = (uint8)(-(n-1)); { /* extend literal */
*op++ = (uint8) b; if (++(*lastliteral) == 127)
} else { state = BASE;
lastliteral = op; *op++ = (uint8_t)b;
*op++ = 0; }
*op++ = (uint8) 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) -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,119 +212,112 @@ PackBitsEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 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* bp, tmsize_t cc, uint16 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* op, tmsize_t occ, uint16 s)
{ {
static const char module[] = "PackBitsDecode"; static const char module[] = "PackBitsDecode";
char *bp; int8_t *bp;
tmsize_t cc; tmsize_t cc;
long n; long n;
int b; int b;
(void) s; (void)s;
bp = (char*) 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++;
/* cc--;
* Watch out for compilers that if (n < 0)
* don't sign extend chars... { /* replicate next byte -n+1 times */
*/ if (n == -128) /* nop */
if (n >= 128) continue;
n -= 256; n = -n + 1;
if (n < 0) { /* replicate next byte -n+1 times */ if (occ < (tmsize_t)n)
if (n == -128) /* nop */ {
continue; TIFFWarningExtR(tif, module,
n = -n + 1; "Discarding %" TIFF_SSIZE_FORMAT
if( occ < (tmsize_t)n ) " bytes to avoid buffer overrun",
{ (tmsize_t)n - occ);
TIFFWarningExt(tif->tif_clientdata, module, n = (long)occ;
"Discarding %lu bytes to avoid buffer overrun", }
(unsigned long) ((tmsize_t)n - occ)); if (cc == 0)
n = (long)occ; {
} TIFFWarningExtR(
if( cc == 0 ) tif, module,
{ "Terminating PackBitsDecode due to lack of data.");
TIFFWarningExt(tif->tif_clientdata, module, break;
"Terminating PackBitsDecode due to lack of data."); }
break; occ -= n;
} b = *bp++;
occ -= n; cc--;
b = *bp++; while (n-- > 0)
cc--; *op++ = (uint8_t)b;
while (n-- > 0) }
*op++ = (uint8) b; else
} else { /* copy next n+1 bytes literally */ { /* copy next n+1 bytes literally */
if (occ < (tmsize_t)(n + 1)) if (occ < (tmsize_t)(n + 1))
{ {
TIFFWarningExt(tif->tif_clientdata, module, TIFFWarningExtR(tif, module,
"Discarding %lu bytes to avoid buffer overrun", "Discarding %" TIFF_SSIZE_FORMAT
(unsigned long) ((tmsize_t)n - occ + 1)); " bytes to avoid buffer overrun",
n = (long)occ - 1; (tmsize_t)n - occ + 1);
} n = (long)occ - 1;
if (cc < (tmsize_t) (n+1)) }
{ if (cc < (tmsize_t)(n + 1))
TIFFWarningExt(tif->tif_clientdata, module, {
"Terminating PackBitsDecode due to lack of data."); TIFFWarningExtR(
break; tif, module,
} "Terminating PackBitsDecode due to lack of data.");
_TIFFmemcpy(op, bp, ++n); break;
op += n; occ -= n; }
bp += n; cc -= n; _TIFFmemcpy(op, bp, ++n);
} op += n;
} occ -= n;
tif->tif_rawcp = (uint8*) bp; bp += n;
tif->tif_rawcc = cc; cc -= n;
if (occ > 0) { }
TIFFErrorExt(tif->tif_clientdata, module, }
"Not enough data for scanline %lu", tif->tif_rawcp = (uint8_t *)bp;
(unsigned long) tif->tif_row); tif->tif_rawcc = cc;
return (0); if (occ > 0)
} {
return (1); 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:
*/

2510
3rdparty/libtiff/tif_pixarlog.c vendored
View File

File diff suppressed because it is too large Load Diff

1485
3rdparty/libtiff/tif_predict.c vendored
View File

File diff suppressed because it is too large Load Diff

55
3rdparty/libtiff/tif_predict.h vendored
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* 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:
*/

1319
3rdparty/libtiff/tif_print.c vendored
View File

File diff suppressed because it is too large Load Diff

2535
3rdparty/libtiff/tif_read.c vendored
View File

File diff suppressed because it is too large Load Diff

578
3rdparty/libtiff/tif_stream.cxx vendored
View File

@ -2,23 +2,23 @@
* Copyright (c) 1988-1996 Sam Leffler * Copyright (c) 1988-1996 Sam Leffler
* Copyright (c) 1991-1996 Silicon Graphics, Inc. * Copyright (c) 1991-1996 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.
*/ */
@ -28,9 +28,7 @@
#include "tiffiop.h" #include "tiffiop.h"
#include <iostream> #include <iostream>
#ifndef __VMS
using namespace std; using namespace std;
#endif
/* /*
ISO C++ uses a 'std::streamsize' type to define counts. This makes ISO C++ uses a 'std::streamsize' type to define counts. This makes
@ -76,359 +74,331 @@ using namespace std;
struct tiffis_data; struct tiffis_data;
struct tiffos_data; struct tiffos_data;
extern "C" { extern "C"
static tmsize_t _tiffosReadProc(thandle_t, void*, tmsize_t);
static tmsize_t _tiffisReadProc(thandle_t fd, void* buf, tmsize_t size);
static tmsize_t _tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size);
static tmsize_t _tiffisWriteProc(thandle_t, void*, tmsize_t);
static uint64 _tiffosSeekProc(thandle_t fd, uint64 off, int whence);
static uint64 _tiffisSeekProc(thandle_t fd, uint64 off, int whence);
static uint64 _tiffosSizeProc(thandle_t fd);
static uint64 _tiffisSizeProc(thandle_t fd);
static int _tiffosCloseProc(thandle_t fd);
static int _tiffisCloseProc(thandle_t fd);
static int _tiffDummyMapProc(thandle_t , void** base, toff_t* size );
static void _tiffDummyUnmapProc(thandle_t , void* base, toff_t size );
static TIFF* _tiffStreamOpen(const char* name, const char* mode, void *fd);
struct tiffis_data
{ {
istream *stream;
static tmsize_t _tiffosReadProc(thandle_t, void *, tmsize_t);
static tmsize_t _tiffisReadProc(thandle_t fd, void *buf, tmsize_t size);
static tmsize_t _tiffosWriteProc(thandle_t fd, void *buf, tmsize_t size);
static tmsize_t _tiffisWriteProc(thandle_t, void *, tmsize_t);
static uint64_t _tiffosSeekProc(thandle_t fd, uint64_t off, int whence);
static uint64_t _tiffisSeekProc(thandle_t fd, uint64_t off, int whence);
static uint64_t _tiffosSizeProc(thandle_t fd);
static uint64_t _tiffisSizeProc(thandle_t fd);
static int _tiffosCloseProc(thandle_t fd);
static int _tiffisCloseProc(thandle_t fd);
static int _tiffDummyMapProc(thandle_t, void **base, toff_t *size);
static void _tiffDummyUnmapProc(thandle_t, void *base, toff_t size);
static TIFF *_tiffStreamOpen(const char *name, const char *mode, void *fd);
struct tiffis_data
{
istream *stream;
ios::pos_type start_pos; ios::pos_type start_pos;
}; };
struct tiffos_data struct tiffos_data
{ {
ostream *stream; ostream *stream;
ios::pos_type start_pos; ios::pos_type start_pos;
}; };
static tmsize_t static tmsize_t _tiffosReadProc(thandle_t, void *, tmsize_t) { return 0; }
_tiffosReadProc(thandle_t, void*, tmsize_t)
{
return 0;
}
static tmsize_t static tmsize_t _tiffisReadProc(thandle_t fd, void *buf, tmsize_t size)
_tiffisReadProc(thandle_t fd, void* buf, tmsize_t size) {
{ tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
// Verify that type does not overflow. // Verify that type does not overflow.
streamsize request_size = size; streamsize request_size = size;
if (static_cast<tmsize_t>(request_size) != size) if (static_cast<tmsize_t>(request_size) != size)
return static_cast<tmsize_t>(-1); return static_cast<tmsize_t>(-1);
data->stream->read((char *) buf, request_size); data->stream->read((char *)buf, request_size);
return static_cast<tmsize_t>(data->stream->gcount()); return static_cast<tmsize_t>(data->stream->gcount());
} }
static tmsize_t static tmsize_t _tiffosWriteProc(thandle_t fd, void *buf, tmsize_t size)
_tiffosWriteProc(thandle_t fd, void* buf, tmsize_t size) {
{ tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);
tiffos_data *data = reinterpret_cast<tiffos_data *>(fd); ostream *os = data->stream;
ostream *os = data->stream; ios::pos_type pos = os->tellp();
ios::pos_type pos = os->tellp();
// Verify that type does not overflow. // Verify that type does not overflow.
streamsize request_size = size; streamsize request_size = size;
if (static_cast<tmsize_t>(request_size) != size) if (static_cast<tmsize_t>(request_size) != size)
return static_cast<tmsize_t>(-1); return static_cast<tmsize_t>(-1);
os->write(reinterpret_cast<const char *>(buf), request_size); os->write(reinterpret_cast<const char *>(buf), request_size);
return static_cast<tmsize_t>(os->tellp() - pos); return static_cast<tmsize_t>(os->tellp() - pos);
} }
static tmsize_t static tmsize_t _tiffisWriteProc(thandle_t, void *, tmsize_t) { return 0; }
_tiffisWriteProc(thandle_t, void*, tmsize_t)
{
return 0;
}
static uint64 static uint64_t _tiffosSeekProc(thandle_t fd, uint64_t off, int whence)
_tiffosSeekProc(thandle_t fd, uint64 off, int whence) {
{ tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);
tiffos_data *data = reinterpret_cast<tiffos_data *>(fd); ostream *os = data->stream;
ostream *os = data->stream;
// if the stream has already failed, don't do anything // if the stream has already failed, don't do anything
if( os->fail() ) if (os->fail())
return static_cast<uint64>(-1); return static_cast<uint64_t>(-1);
switch(whence) { switch (whence)
case SEEK_SET: {
{ case SEEK_SET:
// Compute 64-bit offset {
uint64 new_offset = static_cast<uint64>(data->start_pos) + off; // Compute 64-bit offset
uint64_t new_offset =
static_cast<uint64_t>(data->start_pos) + off;
// Verify that value does not overflow // Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(new_offset); ios::off_type offset = static_cast<ios::off_type>(new_offset);
if (static_cast<uint64>(offset) != new_offset) if (static_cast<uint64_t>(offset) != new_offset)
return static_cast<uint64>(-1); return static_cast<uint64_t>(-1);
os->seekp(offset, ios::beg);
break;
}
case SEEK_CUR:
{
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(off);
if (static_cast<uint64>(offset) != off)
return static_cast<uint64>(-1);
os->seekp(offset, ios::cur); os->seekp(offset, ios::beg);
break; break;
} }
case SEEK_END: case SEEK_CUR:
{ {
// Verify that value does not overflow // Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(off); ios::off_type offset = static_cast<ios::off_type>(off);
if (static_cast<uint64>(offset) != off) if (static_cast<uint64_t>(offset) != off)
return static_cast<uint64>(-1); return static_cast<uint64_t>(-1);
os->seekp(offset, ios::end); os->seekp(offset, ios::cur);
break; break;
} }
} case SEEK_END:
{
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(off);
if (static_cast<uint64_t>(offset) != off)
return static_cast<uint64_t>(-1);
// Attempt to workaround problems with seeking past the end of the os->seekp(offset, ios::end);
// stream. ofstream doesn't have a problem with this but break;
// ostrstream/ostringstream does. In that situation, add intermediate }
// '\0' characters. }
if( os->fail() ) {
#ifdef __VMS
int old_state;
#else
ios::iostate old_state;
#endif
ios::pos_type origin;
old_state = os->rdstate(); // Attempt to workaround problems with seeking past the end of the
// reset the fail bit or else tellp() won't work below // stream. ofstream doesn't have a problem with this but
os->clear(os->rdstate() & ~ios::failbit); // ostrstream/ostringstream does. In that situation, add intermediate
switch( whence ) { // '\0' characters.
case SEEK_SET: if (os->fail())
default: {
origin = data->start_pos; ios::iostate old_state;
break; ios::pos_type origin;
case SEEK_CUR:
origin = os->tellp();
break;
case SEEK_END:
os->seekp(0, ios::end);
origin = os->tellp();
break;
}
// restore original stream state
os->clear(old_state);
// only do something if desired seek position is valid old_state = os->rdstate();
if( (static_cast<uint64>(origin) + off) > static_cast<uint64>(data->start_pos) ) { // reset the fail bit or else tellp() won't work below
uint64 num_fill; os->clear(os->rdstate() & ~ios::failbit);
switch (whence)
{
case SEEK_SET:
default:
origin = data->start_pos;
break;
case SEEK_CUR:
origin = os->tellp();
break;
case SEEK_END:
os->seekp(0, ios::end);
origin = os->tellp();
break;
}
// restore original stream state
os->clear(old_state);
// clear the fail bit // only do something if desired seek position is valid
os->clear(os->rdstate() & ~ios::failbit); if ((static_cast<uint64_t>(origin) + off) >
static_cast<uint64_t>(data->start_pos))
{
uint64_t num_fill;
// extend the stream to the expected size // clear the fail bit
os->seekp(0, ios::end); os->clear(os->rdstate() & ~ios::failbit);
num_fill = (static_cast<uint64>(origin)) + off - os->tellp();
for( uint64 i = 0; i < num_fill; i++ )
os->put('\0');
// retry the seek // extend the stream to the expected size
os->seekp(static_cast<ios::off_type>(static_cast<uint64>(origin) + off), ios::beg); os->seekp(0, ios::end);
} num_fill = (static_cast<uint64_t>(origin)) + off - os->tellp();
} for (uint64_t i = 0; i < num_fill; i++)
os->put('\0');
return static_cast<uint64>(os->tellp()); // retry the seek
} os->seekp(static_cast<ios::off_type>(
static_cast<uint64_t>(origin) + off),
ios::beg);
}
}
static uint64 return static_cast<uint64_t>(os->tellp());
_tiffisSeekProc(thandle_t fd, uint64 off, int whence) }
{
tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
switch(whence) { static uint64_t _tiffisSeekProc(thandle_t fd, uint64_t off, int whence)
case SEEK_SET: {
{ tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
// Compute 64-bit offset
uint64 new_offset = static_cast<uint64>(data->start_pos) + off;
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(new_offset);
if (static_cast<uint64>(offset) != new_offset)
return static_cast<uint64>(-1);
data->stream->seekg(offset, ios::beg); switch (whence)
break; {
} case SEEK_SET:
case SEEK_CUR: {
{ // Compute 64-bit offset
// Verify that value does not overflow uint64_t new_offset =
ios::off_type offset = static_cast<ios::off_type>(off); static_cast<uint64_t>(data->start_pos) + off;
if (static_cast<uint64>(offset) != off)
return static_cast<uint64>(-1);
data->stream->seekg(offset, ios::cur); // Verify that value does not overflow
break; ios::off_type offset = static_cast<ios::off_type>(new_offset);
} if (static_cast<uint64_t>(offset) != new_offset)
case SEEK_END: return static_cast<uint64_t>(-1);
{
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(off);
if (static_cast<uint64>(offset) != off)
return static_cast<uint64>(-1);
data->stream->seekg(offset, ios::end); data->stream->seekg(offset, ios::beg);
break; break;
} }
} case SEEK_CUR:
{
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(off);
if (static_cast<uint64_t>(offset) != off)
return static_cast<uint64_t>(-1);
return (uint64) (data->stream->tellg() - data->start_pos); data->stream->seekg(offset, ios::cur);
} break;
}
case SEEK_END:
{
// Verify that value does not overflow
ios::off_type offset = static_cast<ios::off_type>(off);
if (static_cast<uint64_t>(offset) != off)
return static_cast<uint64_t>(-1);
static uint64 data->stream->seekg(offset, ios::end);
_tiffosSizeProc(thandle_t fd) break;
{ }
tiffos_data *data = reinterpret_cast<tiffos_data *>(fd); }
ostream *os = data->stream;
ios::pos_type pos = os->tellp();
ios::pos_type len;
os->seekp(0, ios::end); return (uint64_t)(data->stream->tellg() - data->start_pos);
len = os->tellp(); }
os->seekp(pos);
return (uint64) len; static uint64_t _tiffosSizeProc(thandle_t fd)
} {
tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);
ostream *os = data->stream;
ios::pos_type pos = os->tellp();
ios::pos_type len;
static uint64 os->seekp(0, ios::end);
_tiffisSizeProc(thandle_t fd) len = os->tellp();
{ os->seekp(pos);
tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
ios::pos_type pos = data->stream->tellg();
ios::pos_type len;
data->stream->seekg(0, ios::end); return (uint64_t)len;
len = data->stream->tellg(); }
data->stream->seekg(pos);
return (uint64) len; static uint64_t _tiffisSizeProc(thandle_t fd)
} {
tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
ios::pos_type pos = data->stream->tellg();
ios::pos_type len;
static int data->stream->seekg(0, ios::end);
_tiffosCloseProc(thandle_t fd) len = data->stream->tellg();
{ data->stream->seekg(pos);
// Our stream was not allocated by us, so it shouldn't be closed by us.
delete reinterpret_cast<tiffos_data *>(fd);
return 0;
}
static int return (uint64_t)len;
_tiffisCloseProc(thandle_t fd) }
{
// Our stream was not allocated by us, so it shouldn't be closed by us.
delete reinterpret_cast<tiffis_data *>(fd);
return 0;
}
static int static int _tiffosCloseProc(thandle_t fd)
_tiffDummyMapProc(thandle_t , void** base, toff_t* size ) {
{ // Our stream was not allocated by us, so it shouldn't be closed by us.
(void) base; delete reinterpret_cast<tiffos_data *>(fd);
(void) size; return 0;
return (0); }
}
static void static int _tiffisCloseProc(thandle_t fd)
_tiffDummyUnmapProc(thandle_t , void* base, toff_t size ) {
{ // Our stream was not allocated by us, so it shouldn't be closed by us.
(void) base; delete reinterpret_cast<tiffis_data *>(fd);
(void) size; return 0;
} }
/* static int _tiffDummyMapProc(thandle_t, void **base, toff_t *size)
* Open a TIFF file descriptor for read/writing. {
*/ (void)base;
static TIFF* (void)size;
_tiffStreamOpen(const char* name, const char* mode, void *fd) return (0);
{ }
TIFF* tif;
if( strchr(mode, 'w') ) { static void _tiffDummyUnmapProc(thandle_t, void *base, toff_t size)
tiffos_data *data = new tiffos_data; {
data->stream = reinterpret_cast<ostream *>(fd); (void)base;
data->start_pos = data->stream->tellp(); (void)size;
}
// Open for writing. /*
tif = TIFFClientOpen(name, mode, * Open a TIFF file descriptor for read/writing.
reinterpret_cast<thandle_t>(data), */
_tiffosReadProc, static TIFF *_tiffStreamOpen(const char *name, const char *mode, void *fd)
_tiffosWriteProc, {
_tiffosSeekProc, TIFF *tif;
_tiffosCloseProc,
_tiffosSizeProc,
_tiffDummyMapProc,
_tiffDummyUnmapProc);
if (!tif) {
delete data;
}
} else {
tiffis_data *data = new tiffis_data;
data->stream = reinterpret_cast<istream *>(fd);
data->start_pos = data->stream->tellg();
// Open for reading.
tif = TIFFClientOpen(name, mode,
reinterpret_cast<thandle_t>(data),
_tiffisReadProc,
_tiffisWriteProc,
_tiffisSeekProc,
_tiffisCloseProc,
_tiffisSizeProc,
_tiffDummyMapProc,
_tiffDummyUnmapProc);
if (!tif) {
delete data;
}
}
return (tif); if (strchr(mode, 'w'))
} {
tiffos_data *data = new tiffos_data;
data->stream = reinterpret_cast<ostream *>(fd);
data->start_pos = data->stream->tellp();
// Open for writing.
tif = TIFFClientOpen(
name, mode, reinterpret_cast<thandle_t>(data), _tiffosReadProc,
_tiffosWriteProc, _tiffosSeekProc, _tiffosCloseProc,
_tiffosSizeProc, _tiffDummyMapProc, _tiffDummyUnmapProc);
if (!tif)
{
delete data;
}
}
else
{
tiffis_data *data = new tiffis_data;
data->stream = reinterpret_cast<istream *>(fd);
data->start_pos = data->stream->tellg();
// Open for reading.
tif = TIFFClientOpen(
name, mode, reinterpret_cast<thandle_t>(data), _tiffisReadProc,
_tiffisWriteProc, _tiffisSeekProc, _tiffisCloseProc,
_tiffisSizeProc, _tiffDummyMapProc, _tiffDummyUnmapProc);
if (!tif)
{
delete data;
}
}
return (tif);
}
} /* extern "C" */ } /* extern "C" */
TIFF* TIFF *TIFFStreamOpen(const char *name, ostream *os)
TIFFStreamOpen(const char* name, ostream *os)
{ {
// If os is either a ostrstream or ostringstream, and has no data // If os is either a ostrstream or ostringstream, and has no data
// written to it yet, then tellp() will return -1 which will break us. // written to it yet, then tellp() will return -1 which will break us.
// We workaround this by writing out a dummy character and // We workaround this by writing out a dummy character and
// then seek back to the beginning. // then seek back to the beginning.
if( !os->fail() && static_cast<int>(os->tellp()) < 0 ) { if (!os->fail() && static_cast<int>(os->tellp()) < 0)
*os << '\0'; {
os->seekp(0); *os << '\0';
} os->seekp(0);
}
// NB: We don't support mapped files with streams so add 'm' // NB: We don't support mapped files with streams so add 'm'
return _tiffStreamOpen(name, "wm", os); return _tiffStreamOpen(name, "wm", os);
} }
TIFF* TIFF *TIFFStreamOpen(const char *name, istream *is)
TIFFStreamOpen(const char* name, istream *is)
{ {
// NB: We don't support mapped files with streams so add 'm' // NB: We don't support mapped files with streams so add 'm'
return _tiffStreamOpen(name, "rm", is); return _tiffStreamOpen(name, "rm", is);
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

491
3rdparty/libtiff/tif_strip.c vendored
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,153 +32,145 @@
/* /*
* Compute which strip a (row,sample) value is in. * Compute which strip a (row,sample) value is in.
*/ */
uint32 uint32_t TIFFComputeStrip(TIFF *tif, uint32_t row, uint16_t sample)
TIFFComputeStrip(TIFF* tif, uint32 row, uint16 sample)
{ {
static const char module[] = "TIFFComputeStrip"; static const char module[] = "TIFFComputeStrip";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint32 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)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 uint32_t TIFFNumberOfStrips(TIFF *tif)
TIFFNumberOfStrips(TIFF* tif)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint32 nstrips; uint32_t nstrips;
nstrips = (td->td_rowsperstrip == (uint32) -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)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 uint64_t TIFFVStripSize64(TIFF *tif, uint32_t nrows)
TIFFVStripSize64(TIFF* tif, uint32 nrows)
{ {
static const char module[] = "TIFFVStripSize64"; static const char module[] = "TIFFVStripSize64";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
if (nrows==(uint32)(-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 ycbcrsubsampling[2]; uint16_t samplingblock_samples;
uint16 samplingblock_samples; uint32_t samplingblocks_hor;
uint32 samplingblocks_hor; uint32_t samplingblocks_ver;
uint32 samplingblocks_ver; uint64_t samplingrow_samples;
uint64 samplingrow_samples; uint64_t samplingrow_size;
uint64 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 nrows)
{ {
static const char module[] = "TIFFVStripSize"; static const char module[] = "TIFFVStripSize";
uint64 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 uint64_t TIFFRawStripSize64(TIFF *tif, uint32_t strip)
TIFFRawStripSize64(TIFF* tif, uint32 strip)
{ {
static const char module[] = "TIFFRawStripSize64"; static const char module[] = "TIFFRawStripSize64";
uint64 bytecount = TIFFGetStrileByteCount(tif, strip); uint64_t bytecount = TIFFGetStrileByteCount(tif, strip);
if (bytecount == 0) if (bytecount == 0)
{ {
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) TIFFErrorExtR(tif, module,
TIFFErrorExt(tif->tif_clientdata, module, "%" PRIu64 ": Invalid strip byte count, strip %lu",
"%I64u: Invalid strip byte count, strip %lu", (uint64_t)bytecount, (unsigned long)strip);
(unsigned __int64) bytecount, bytecount = (uint64_t)-1;
(unsigned long) strip); }
#else
TIFFErrorExt(tif->tif_clientdata, module,
"%llu: Invalid strip byte count, strip %lu",
(unsigned long long) bytecount,
(unsigned long) strip);
#endif
bytecount = (uint64) -1;
}
return bytecount; return bytecount;
} }
tmsize_t tmsize_t TIFFRawStripSize(TIFF *tif, uint32_t strip)
TIFFRawStripSize(TIFF* tif, uint32 strip)
{ {
static const char module[] = "TIFFRawStripSize"; static const char module[] = "TIFFRawStripSize";
uint64 m; uint64_t m;
tmsize_t n; tmsize_t n;
m=TIFFRawStripSize64(tif,strip); m = TIFFRawStripSize64(tif, strip);
if (m==(uint64)(-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)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);
} }
/* /*
@ -189,22 +181,20 @@ TIFFRawStripSize(TIFF* tif, uint32 strip)
* truncated to reflect the actual space required * truncated to reflect the actual space required
* to hold the strip. * to hold the strip.
*/ */
uint64 uint64_t TIFFStripSize64(TIFF *tif)
TIFFStripSize64(TIFF* tif)
{ {
TIFFDirectory* td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint32 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 m; uint64_t m;
m=TIFFStripSize64(tif); m = TIFFStripSize64(tif);
return _TIFFCastUInt64ToSSize(tif, m, module); return _TIFFCastUInt64ToSSize(tif, m, module);
} }
/* /*
@ -213,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 uint32_t TIFFDefaultStripSize(TIFF *tif, uint32_t request)
TIFFDefaultStripSize(TIFF* tif, uint32 request)
{ {
return (*tif->tif_defstripsize)(tif, request); return (*tif->tif_defstripsize)(tif, request);
} }
uint32 uint32_t _TIFFDefaultStripSize(TIFF *tif, uint32_t s)
_TIFFDefaultStripSize(TIFF* tif, uint32 s)
{ {
if ((int32) 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 scanlinesize; */
uint64 rows; uint64_t scanlinesize;
scanlinesize=TIFFScanlineSize64(tif); uint64_t rows;
if (scanlinesize==0) scanlinesize = TIFFScanlineSize64(tif);
scanlinesize=1; if (scanlinesize == 0)
rows=(uint64)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)rows; rows = 0xFFFFFFFF;
} s = (uint32_t)rows;
return (s); }
return (s);
} }
/* /*
@ -253,70 +242,79 @@ _TIFFDefaultStripSize(TIFF* tif, uint32 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 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 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 ycbcrsubsampling[2];
uint16 samplingblock_samples;
uint32 samplingblocks_hor;
uint64 samplingrow_samples;
uint64 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 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 m; uint64_t m;
m=TIFFScanlineSize64(tif); m = TIFFScanlineSize64(tif);
return _TIFFCastUInt64ToSSize(tif, m, module); return _TIFFCastUInt64ToSSize(tif, m, module);
} }
/* /*
@ -325,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 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 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 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
3rdparty/libtiff/tif_swab.c vendored
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* wp)
{ {
register unsigned char* cp = (unsigned char*) wp; register unsigned char *cp = (unsigned char *)wp;
unsigned char t; unsigned char t;
assert(sizeof(uint16)==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* lp)
{ {
register unsigned char* cp = (unsigned char*) lp; register unsigned char *cp = (unsigned char *)lp;
unsigned char t; unsigned char t;
assert(sizeof(uint32)==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* lp)
{ {
register unsigned char* cp = (unsigned char*) lp; register unsigned char *cp = (unsigned char *)lp;
unsigned char t; unsigned char t;
assert(sizeof(uint64)==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* wp, tmsize_t n)
{ {
register unsigned char* cp; register unsigned char *cp;
register unsigned char t; register unsigned char t;
assert(sizeof(uint16)==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* 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* lp, tmsize_t n)
{ {
register unsigned char *cp; register unsigned char *cp;
register unsigned char t; register unsigned char t;
assert(sizeof(uint32)==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* lp, tmsize_t n)
{ {
register unsigned char *cp; register unsigned char *cp;
register unsigned char t; register unsigned char t;
assert(sizeof(uint64)==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* 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:
*/

294
3rdparty/libtiff/tif_thunder.c vendored
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,166 +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) (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* 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) 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*) bp;
tif->tif_rawcc = cc;
if (npixels != maxpixels) {
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
TIFFErrorExt(tif->tif_clientdata, module,
"%s data at scanline %lu (%I64u != %I64u)",
npixels < maxpixels ? "Not enough" : "Too much",
(unsigned long) tif->tif_row,
(unsigned __int64) npixels,
(unsigned __int64) maxpixels);
#else
TIFFErrorExt(tif->tif_clientdata, module,
"%s data at scanline %lu (%llu != %llu)",
npixels < maxpixels ? "Not enough" : "Too much",
(unsigned long) tif->tif_row,
(unsigned long long) npixels,
(unsigned long long) maxpixels);
#endif
return (0);
}
return (1);
} }
static int int TIFFInitThunderScan(TIFF *tif, int scheme)
ThunderDecodeRow(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
{ {
static const char module[] = "ThunderDecodeRow"; (void)scheme;
uint8* 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
3rdparty/libtiff/tif_tile.c vendored
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 uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z,
TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s) uint16_t s)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint32 dx = td->td_tilewidth; uint32_t dx = td->td_tilewidth;
uint32 dy = td->td_tilelength; uint32_t dy = td->td_tilelength;
uint32 dz = td->td_tiledepth; uint32_t dz = td->td_tiledepth;
uint32 tile = 1; uint32_t tile = 1;
if (td->td_imagedepth == 1) if (td->td_imagedepth == 1)
z = 0; z = 0;
if (dx == (uint32) -1) if (dx == (uint32_t)-1)
dx = td->td_imagewidth; dx = td->td_imagewidth;
if (dy == (uint32) -1) if (dy == (uint32_t)-1)
dy = td->td_imagelength; dy = td->td_imagelength;
if (dz == (uint32) -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 xpt = TIFFhowmany_32(td->td_imagewidth, dx); {
uint32 ypt = TIFFhowmany_32(td->td_imagelength, dy); uint32_t xpt = TIFFhowmany_32(td->td_imagewidth, dx);
uint32 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 x, uint32 y, uint32 z, uint16 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 uint32_t TIFFNumberOfTiles(TIFF *tif)
TIFFNumberOfTiles(TIFF* tif)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint32 dx = td->td_tilewidth; uint32_t dx = td->td_tilewidth;
uint32 dy = td->td_tilelength; uint32_t dy = td->td_tilelength;
uint32 dz = td->td_tiledepth; uint32_t dz = td->td_tiledepth;
uint32 ntiles; uint32_t ntiles;
if (dx == (uint32) -1) if (dx == (uint32_t)-1)
dx = td->td_imagewidth; dx = td->td_imagewidth;
if (dy == (uint32) -1) if (dy == (uint32_t)-1)
dy = td->td_imagelength; dy = td->td_imagelength;
if (dz == (uint32) -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 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 rowsize; uint64_t rowsize;
uint64 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 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 uint64_t TIFFVTileSize64(TIFF *tif, uint32_t nrows)
TIFFVTileSize64(TIFF* tif, uint32 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 ycbcrsubsampling[2]; uint16_t samplingblock_samples;
uint16 samplingblock_samples; uint32_t samplingblocks_hor;
uint32 samplingblocks_hor; uint32_t samplingblocks_ver;
uint32 samplingblocks_ver; uint64_t samplingrow_samples;
uint64 samplingrow_samples; uint64_t samplingrow_size;
uint64 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 nrows)
{ {
static const char module[] = "TIFFVTileSize"; static const char module[] = "TIFFVTileSize";
uint64 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 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 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* tw, uint32* 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* tw, uint32* th)
{ {
(void) tif; (void)tif;
if (*(int32*) tw < 1) if (*(int32_t *)tw < 1)
*tw = 256; *tw = 256;
if (*(int32*) 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:
*/

462
3rdparty/libtiff/tif_unix.c vendored
View File

@ -30,7 +30,7 @@
#include "tif_config.h" #include "tif_config.h"
#ifdef HAVE_SYS_TYPES_H #ifdef HAVE_SYS_TYPES_H
# include <sys/types.h> #include <sys/types.h>
#endif #endif
#include <errno.h> #include <errno.h>
@ -40,215 +40,222 @@
#include <sys/stat.h> #include <sys/stat.h>
#ifdef HAVE_UNISTD_H #ifdef HAVE_UNISTD_H
# include <unistd.h> #include <unistd.h>
#endif #endif
#ifdef HAVE_FCNTL_H #ifdef HAVE_FCNTL_H
# include <fcntl.h> #include <fcntl.h>
#endif #endif
#ifdef HAVE_IO_H #ifdef HAVE_IO_H
# include <io.h> #include <io.h>
#endif #endif
#include "tiffiop.h" #include "tiffiop.h"
#define TIFF_IO_MAX 2147483647U #define TIFF_IO_MAX 2147483647U
typedef union fd_as_handle_union typedef union fd_as_handle_union
{ {
int fd; int fd;
thandle_t h; thandle_t h;
} fd_as_handle_union_t; } fd_as_handle_union_t;
static tmsize_t static tmsize_t _tiffReadProc(thandle_t fd, void *buf, tmsize_t size)
_tiffReadProc(thandle_t fd, void* buf, tmsize_t size)
{ {
fd_as_handle_union_t fdh; fd_as_handle_union_t fdh;
const size_t bytes_total = (size_t) size; const size_t bytes_total = (size_t)size;
size_t bytes_read; size_t bytes_read;
tmsize_t count = -1; tmsize_t count = -1;
if ((tmsize_t) bytes_total != size) if ((tmsize_t)bytes_total != size)
{ {
errno=EINVAL; errno = EINVAL;
return (tmsize_t) -1; return (tmsize_t)-1;
} }
fdh.h = fd; fdh.h = fd;
for (bytes_read=0; bytes_read < bytes_total; bytes_read+=count) for (bytes_read = 0; bytes_read < bytes_total; bytes_read += count)
{ {
char *buf_offset = (char *) buf+bytes_read; char *buf_offset = (char *)buf + bytes_read;
size_t io_size = bytes_total-bytes_read; size_t io_size = bytes_total - bytes_read;
if (io_size > TIFF_IO_MAX) if (io_size > TIFF_IO_MAX)
io_size = TIFF_IO_MAX; io_size = TIFF_IO_MAX;
count=read(fdh.fd, buf_offset, (TIFFIOSize_t) io_size); count = read(fdh.fd, buf_offset, (TIFFIOSize_t)io_size);
if (count <= 0) if (count <= 0)
break; break;
} }
if (count < 0) if (count < 0)
return (tmsize_t)-1; return (tmsize_t)-1;
return (tmsize_t) bytes_read; return (tmsize_t)bytes_read;
} }
static tmsize_t static tmsize_t _tiffWriteProc(thandle_t fd, void *buf, tmsize_t size)
_tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)
{ {
fd_as_handle_union_t fdh; fd_as_handle_union_t fdh;
const size_t bytes_total = (size_t) size; const size_t bytes_total = (size_t)size;
size_t bytes_written; size_t bytes_written;
tmsize_t count = -1; tmsize_t count = -1;
if ((tmsize_t) bytes_total != size) if ((tmsize_t)bytes_total != size)
{ {
errno=EINVAL; errno = EINVAL;
return (tmsize_t) -1; return (tmsize_t)-1;
} }
fdh.h = fd; fdh.h = fd;
for (bytes_written=0; bytes_written < bytes_total; bytes_written+=count) for (bytes_written = 0; bytes_written < bytes_total; bytes_written += count)
{ {
const char *buf_offset = (char *) buf+bytes_written; const char *buf_offset = (char *)buf + bytes_written;
size_t io_size = bytes_total-bytes_written; size_t io_size = bytes_total - bytes_written;
if (io_size > TIFF_IO_MAX) if (io_size > TIFF_IO_MAX)
io_size = TIFF_IO_MAX; io_size = TIFF_IO_MAX;
count=write(fdh.fd, buf_offset, (TIFFIOSize_t) io_size); count = write(fdh.fd, buf_offset, (TIFFIOSize_t)io_size);
if (count <= 0) if (count <= 0)
break; break;
} }
if (count < 0) if (count < 0)
return (tmsize_t)-1; return (tmsize_t)-1;
return (tmsize_t) bytes_written; return (tmsize_t)bytes_written;
/* return ((tmsize_t) write(fdh.fd, buf, bytes_total)); */ /* return ((tmsize_t) write(fdh.fd, buf, bytes_total)); */
} }
static uint64 static uint64_t _tiffSeekProc(thandle_t fd, uint64_t off, int whence)
_tiffSeekProc(thandle_t fd, uint64 off, int whence)
{ {
fd_as_handle_union_t fdh; fd_as_handle_union_t fdh;
_TIFF_off_t off_io = (_TIFF_off_t) off; _TIFF_off_t off_io = (_TIFF_off_t)off;
if ((uint64) off_io != off) if ((uint64_t)off_io != off)
{ {
errno=EINVAL; errno = EINVAL;
return (uint64) -1; /* this is really gross */ return (uint64_t)-1; /* this is really gross */
} }
fdh.h = fd; fdh.h = fd;
return((uint64)_TIFF_lseek_f(fdh.fd,off_io,whence)); return ((uint64_t)_TIFF_lseek_f(fdh.fd, off_io, whence));
} }
static int static int _tiffCloseProc(thandle_t fd)
_tiffCloseProc(thandle_t fd)
{ {
fd_as_handle_union_t fdh; fd_as_handle_union_t fdh;
fdh.h = fd; fdh.h = fd;
return(close(fdh.fd)); return (close(fdh.fd));
} }
static uint64 static uint64_t _tiffSizeProc(thandle_t fd)
_tiffSizeProc(thandle_t fd)
{ {
_TIFF_stat_s sb; _TIFF_stat_s sb;
fd_as_handle_union_t fdh; fd_as_handle_union_t fdh;
fdh.h = fd; fdh.h = fd;
if (_TIFF_fstat_f(fdh.fd,&sb)<0) if (_TIFF_fstat_f(fdh.fd, &sb) < 0)
return(0); return (0);
else else
return((uint64)sb.st_size); return ((uint64_t)sb.st_size);
} }
#ifdef HAVE_MMAP #ifdef HAVE_MMAP
#include <sys/mman.h> #include <sys/mman.h>
static int static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
{ {
uint64 size64 = _tiffSizeProc(fd); uint64_t size64 = _tiffSizeProc(fd);
tmsize_t sizem = (tmsize_t)size64; tmsize_t sizem = (tmsize_t)size64;
if (size64 && (uint64)sizem==size64) { if (size64 && (uint64_t)sizem == size64)
fd_as_handle_union_t fdh; {
fdh.h = fd; fd_as_handle_union_t fdh;
*pbase = (void*) fdh.h = fd;
mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, fdh.fd, 0); *pbase =
if (*pbase != (void*) -1) { (void *)mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, fdh.fd, 0);
*psize = (tmsize_t)sizem; if (*pbase != (void *)-1)
return (1); {
} *psize = (tmsize_t)sizem;
} return (1);
return (0); }
}
return (0);
} }
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) munmap(base, (off_t) size); (void)munmap(base, (off_t)size);
} }
#else /* !HAVE_MMAP */ #else /* !HAVE_MMAP */
static int static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
_tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
{ {
(void) fd; (void) pbase; (void) psize; (void)fd;
return (0); (void)pbase;
(void)psize;
return (0);
} }
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) base; (void) size; (void)fd;
(void)base;
(void)size;
} }
#endif /* !HAVE_MMAP */ #endif /* !HAVE_MMAP */
/* /*
* Open a TIFF file descriptor for read/writing. * Open a TIFF file descriptor for read/writing.
*/ */
TIFF* TIFF *TIFFFdOpen(int fd, const char *name, const char *mode)
TIFFFdOpen(int fd, const char* name, const char* mode)
{ {
TIFF* tif; return TIFFFdOpenExt(fd, name, mode, NULL);
}
fd_as_handle_union_t fdh; TIFF *TIFFFdOpenExt(int fd, const char *name, const char *mode,
fdh.fd = fd; TIFFOpenOptions *opts)
tif = TIFFClientOpen(name, mode, {
fdh.h, TIFF *tif;
_tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc, fd_as_handle_union_t fdh;
_tiffMapProc, _tiffUnmapProc); fdh.fd = fd;
if (tif) tif = TIFFClientOpenExt(name, mode, fdh.h, _tiffReadProc, _tiffWriteProc,
tif->tif_fd = fd; _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
return (tif); _tiffMapProc, _tiffUnmapProc, opts);
if (tif)
tif->tif_fd = fd;
return (tif);
} }
/* /*
* 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);
int m, fd; }
TIFF* tif;
m = _TIFFgetMode(mode, module); TIFF *TIFFOpenExt(const char *name, const char *mode, TIFFOpenOptions *opts)
if (m == -1) {
return ((TIFF*)0); static const char module[] = "TIFFOpen";
int m, fd;
TIFF *tif;
m = _TIFFgetMode(opts, NULL, mode, module);
if (m == -1)
return ((TIFF *)0);
/* for cygwin and mingw */ /* for cygwin and mingw */
#ifdef O_BINARY #ifdef O_BINARY
m |= O_BINARY; m |= O_BINARY;
#endif #endif
fd = open(name, m, 0666); fd = open(name, m, 0666);
if (fd < 0) { if (fd < 0)
if (errno > 0 && strerror(errno) != NULL ) { {
TIFFErrorExt(0, module, "%s: %s", name, strerror(errno) ); if (errno > 0 && strerror(errno) != NULL)
} else { {
TIFFErrorExt(0, module, "%s: Cannot open", name); _TIFFErrorEarly(opts, NULL, module, "%s: %s", name,
} strerror(errno));
return ((TIFF *)0); }
} else
{
_TIFFErrorEarly(opts, NULL, module, "%s: Cannot open", name);
}
return ((TIFF *)0);
}
tif = TIFFFdOpen((int)fd, name, mode); tif = TIFFFdOpenExt((int)fd, name, mode, opts);
if(!tif) if (!tif)
close(fd); close(fd);
return tif; return tif;
} }
#ifdef __WIN32__ #ifdef __WIN32__
@ -256,129 +263,108 @@ TIFFOpen(const char* name, const char* mode)
/* /*
* 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);
int m, fd; }
int mbsize; TIFF *TIFFOpenWExt(const wchar_t *name, const char *mode, TIFFOpenOptions *opts)
char *mbname; {
TIFF* tif; static const char module[] = "TIFFOpenW";
int m, fd;
int mbsize;
char *mbname;
TIFF *tif;
m = _TIFFgetMode(mode, module); m = _TIFFgetMode(opts, NULL, mode, module);
if (m == -1) if (m == -1)
return ((TIFF*)0); return ((TIFF *)0);
/* for cygwin and mingw */ /* for cygwin and mingw */
#ifdef O_BINARY #ifdef O_BINARY
m |= O_BINARY; m |= O_BINARY;
#endif #endif
fd = _wopen(name, m, 0666); fd = _wopen(name, m, 0666);
if (fd < 0) { if (fd < 0)
TIFFErrorExt(0, module, "%ls: Cannot open", name); {
return ((TIFF *)0); _TIFFErrorEarly(opts, NULL, module, "%ls: Cannot open", name);
} return ((TIFF *)0);
}
mbname = NULL; mbname = NULL;
mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL); mbsize = WideCharToMultiByte(CP_ACP, 0, name, -1, NULL, 0, NULL, NULL);
if (mbsize > 0) { if (mbsize > 0)
mbname = _TIFFmalloc(mbsize); {
if (!mbname) { mbname = _TIFFmalloc(mbsize);
TIFFErrorExt(0, module, if (!mbname)
"Can't allocate space for filename conversion buffer"); {
return ((TIFF*)0); _TIFFErrorEarly(
} opts, NULL, module,
"Can't allocate space for filename conversion buffer");
return ((TIFF *)0);
}
WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize, WideCharToMultiByte(CP_ACP, 0, name, -1, mbname, mbsize, NULL, NULL);
NULL, NULL); }
}
tif = TIFFFdOpen((int)fd, (mbname != NULL) ? mbname : "<unknown>", tif = TIFFFdOpenExt((int)fd, (mbname != NULL) ? mbname : "<unknown>", mode,
mode); opts);
_TIFFfree(mbname); _TIFFfree(mbname);
if(!tif) if (!tif)
close(fd); close(fd);
return tif; return tif;
} }
#endif #endif
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 static void unixWarningHandler(const char *module, const char *fmt, va_list ap)
_TIFFmemset(void* p, int v, tmsize_t c)
{ {
memset(p, v, (size_t) c); if (module != NULL)
} fprintf(stderr, "%s: ", module);
fprintf(stderr, "Warning, ");
void vfprintf(stderr, fmt, ap);
_TIFFmemcpy(void* d, const void* s, tmsize_t c) fprintf(stderr, ".\n");
{
memcpy(d, s, (size_t) c);
}
int
_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
{
return (memcmp(p1, p2, (size_t) c));
}
static void
unixWarningHandler(const char* module, const char* fmt, va_list ap)
{
if (module != NULL)
fprintf(stderr, "%s: ", module);
fprintf(stderr, "Warning, ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, ".\n");
} }
TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler; TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler;
static void static void unixErrorHandler(const char *module, const char *fmt, va_list ap)
unixErrorHandler(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 = unixErrorHandler; TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler;
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

29
3rdparty/libtiff/tif_version.c vendored
View File

@ -2,38 +2,27 @@
* Copyright (c) 1992-1997 Sam Leffler * Copyright (c) 1992-1997 Sam Leffler
* Copyright (c) 1992-1997 Silicon Graphics, Inc. * Copyright (c) 1992-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.
*/ */
#include "tiffiop.h" #include "tiffiop.h"
static const char TIFFVersion[] = TIFFLIB_VERSION_STR; static const char TIFFVersion[] = TIFFLIB_VERSION_STR;
const char* const char *TIFFGetVersion(void) { return (TIFFVersion); }
TIFFGetVersion(void)
{
return (TIFFVersion);
}
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

122
3rdparty/libtiff/tif_warning.c vendored
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);
}
}

1349
3rdparty/libtiff/tif_webp.c vendored
View File

File diff suppressed because it is too large Load Diff

593
3rdparty/libtiff/tif_win32.c vendored
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.
*/ */
@ -28,6 +28,7 @@
*/ */
#include "tiffiop.h" #include "tiffiop.h"
#include <stdlib.h>
#include <windows.h> #include <windows.h>
@ -54,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* ma; uint8_t *ma;
uint64 mb; uint64_t mb;
DWORD n; DWORD n;
DWORD o; DWORD o;
tmsize_t p; tmsize_t p;
ma=(uint8*)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)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* ma; switch (whence)
uint64 mb; {
DWORD n; case SEEK_SET:
DWORD o; dwMoveMethod = FILE_BEGIN;
tmsize_t p; break;
ma=(uint8*)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)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 static int _tiffCloseProc(thandle_t fd) { return (CloseHandle(fd) ? 0 : -1); }
_tiffSeekProc(thandle_t fd, uint64 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 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);
} }
/* /*
@ -182,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 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)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);
} }
/* /*
@ -228,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
@ -258,184 +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_EXISTING;
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_EXISTING;
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
#if (_MSC_VER < 1500) static void Win32WarningHandler(const char *module, const char *fmt, va_list ap)
# define vsnprintf _vsnprintf
#endif
static void
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:
*/

1359
3rdparty/libtiff/tif_write.c vendored
View File

File diff suppressed because it is too large Load Diff

1055
3rdparty/libtiff/tif_zip.c vendored
View File

File diff suppressed because it is too large Load Diff

676
3rdparty/libtiff/tif_zstd.c vendored
View File

@ -1,35 +1,35 @@
/* /*
* Copyright (c) 2017, Planet Labs * Copyright (c) 2017, Planet Labs
* Author: <even.rouault at spatialys.com> * Author: <even.rouault at spatialys.com>
* *
* 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.
*/ */
#include "tiffiop.h" #include "tiffiop.h"
#ifdef ZSTD_SUPPORT #ifdef ZSTD_SUPPORT
/* /*
* TIFF Library. * TIFF Library.
* *
* ZSTD Compression Support * ZSTD Compression Support
* *
*/ */
#include "tif_predict.h" #include "tif_predict.h"
#include "zstd.h" #include "zstd.h"
@ -37,406 +37,400 @@
#include <stdio.h> #include <stdio.h>
/* /*
* State block for each open TIFF file using ZSTD compression/decompression. * State block for each open TIFF file using ZSTD compression/decompression.
*/ */
typedef struct { typedef struct
TIFFPredictorState predict; {
ZSTD_DStream* dstream; TIFFPredictorState predict;
ZSTD_CStream* cstream; ZSTD_DStream *dstream;
int compression_level; /* compression level */ ZSTD_CStream *cstream;
ZSTD_outBuffer out_buffer; int compression_level; /* compression level */
int state; /* state flags */ ZSTD_outBuffer out_buffer;
int state; /* state flags */
#define LSTATE_INIT_DECODE 0x01 #define LSTATE_INIT_DECODE 0x01
#define LSTATE_INIT_ENCODE 0x02 #define LSTATE_INIT_ENCODE 0x02
TIFFVGetMethod vgetparent; /* super-class method */ TIFFVGetMethod vgetparent; /* super-class method */
TIFFVSetMethod vsetparent; /* super-class method */ TIFFVSetMethod vsetparent; /* super-class method */
} ZSTDState; } ZSTDState;
#define LState(tif) ((ZSTDState*) (tif)->tif_data) #define LState(tif) ((ZSTDState *)(tif)->tif_data)
#define DecoderState(tif) LState(tif) #define DecoderState(tif) LState(tif)
#define EncoderState(tif) LState(tif) #define EncoderState(tif) LState(tif)
static int ZSTDEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s); static int ZSTDEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s);
static int ZSTDDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s); static int ZSTDDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s);
static int static int ZSTDFixupTags(TIFF *tif)
ZSTDFixupTags(TIFF* tif)
{ {
(void) tif; (void)tif;
return 1; return 1;
} }
static int static int ZSTDSetupDecode(TIFF *tif)
ZSTDSetupDecode(TIFF* tif)
{ {
ZSTDState* sp = DecoderState(tif); ZSTDState *sp = DecoderState(tif);
assert(sp != NULL); assert(sp != NULL);
/* if we were last encoding, terminate this mode */ /* if we were last encoding, terminate this mode */
if (sp->state & LSTATE_INIT_ENCODE) { if (sp->state & LSTATE_INIT_ENCODE)
ZSTD_freeCStream(sp->cstream); {
sp->cstream = NULL; ZSTD_freeCStream(sp->cstream);
sp->state = 0; sp->cstream = NULL;
} sp->state = 0;
}
sp->state |= LSTATE_INIT_DECODE; sp->state |= LSTATE_INIT_DECODE;
return 1; return 1;
} }
/* /*
* Setup state for decoding a strip. * Setup state for decoding a strip.
*/ */
static int static int ZSTDPreDecode(TIFF *tif, uint16_t s)
ZSTDPreDecode(TIFF* tif, uint16 s)
{ {
static const char module[] = "ZSTDPreDecode"; static const char module[] = "ZSTDPreDecode";
ZSTDState* sp = DecoderState(tif); ZSTDState *sp = DecoderState(tif);
size_t zstd_ret; size_t zstd_ret;
(void) s; (void)s;
assert(sp != NULL); assert(sp != NULL);
if( (sp->state & LSTATE_INIT_DECODE) == 0 ) if ((sp->state & LSTATE_INIT_DECODE) == 0)
tif->tif_setupdecode(tif); tif->tif_setupdecode(tif);
if( sp->dstream )
{
ZSTD_freeDStream(sp->dstream);
sp->dstream = NULL;
}
if (sp->dstream == NULL)
{
sp->dstream = ZSTD_createDStream(); sp->dstream = ZSTD_createDStream();
if( sp->dstream == NULL ) { if (sp->dstream == NULL)
TIFFErrorExt(tif->tif_clientdata, module, {
"Cannot allocate decompression stream"); TIFFErrorExtR(tif, module, "Cannot allocate decompression stream");
return 0; return 0;
} }
zstd_ret = ZSTD_initDStream(sp->dstream); }
if( ZSTD_isError(zstd_ret) ) {
TIFFErrorExt(tif->tif_clientdata, module, zstd_ret = ZSTD_initDStream(sp->dstream);
"Error in ZSTD_initDStream(): %s", if (ZSTD_isError(zstd_ret))
ZSTD_getErrorName(zstd_ret)); {
TIFFErrorExtR(tif, module, "Error in ZSTD_initDStream(): %s",
ZSTD_getErrorName(zstd_ret));
return 0;
}
return 1;
}
static int ZSTDDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
{
static const char module[] = "ZSTDDecode";
ZSTDState *sp = DecoderState(tif);
ZSTD_inBuffer in_buffer;
ZSTD_outBuffer out_buffer;
size_t zstd_ret;
(void)s;
assert(sp != NULL);
assert(sp->state == LSTATE_INIT_DECODE);
in_buffer.src = tif->tif_rawcp;
in_buffer.size = (size_t)tif->tif_rawcc;
in_buffer.pos = 0;
out_buffer.dst = op;
out_buffer.size = (size_t)occ;
out_buffer.pos = 0;
do
{
zstd_ret = ZSTD_decompressStream(sp->dstream, &out_buffer, &in_buffer);
if (ZSTD_isError(zstd_ret))
{
TIFFErrorExtR(tif, module, "Error in ZSTD_decompressStream(): %s",
ZSTD_getErrorName(zstd_ret));
return 0; return 0;
} }
} while (zstd_ret != 0 && in_buffer.pos < in_buffer.size &&
out_buffer.pos < out_buffer.size);
return 1; if (out_buffer.pos < (size_t)occ)
{
TIFFErrorExtR(tif, module,
"Not enough data at scanline %lu (short %lu bytes)",
(unsigned long)tif->tif_row,
(unsigned long)((size_t)occ - out_buffer.pos));
return 0;
}
tif->tif_rawcp += in_buffer.pos;
tif->tif_rawcc -= in_buffer.pos;
return 1;
} }
static int static int ZSTDSetupEncode(TIFF *tif)
ZSTDDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{ {
static const char module[] = "ZSTDDecode"; ZSTDState *sp = EncoderState(tif);
ZSTDState* sp = DecoderState(tif);
ZSTD_inBuffer in_buffer;
ZSTD_outBuffer out_buffer;
size_t zstd_ret;
(void) s; assert(sp != NULL);
assert(sp != NULL); if (sp->state & LSTATE_INIT_DECODE)
assert(sp->state == LSTATE_INIT_DECODE); {
ZSTD_freeDStream(sp->dstream);
sp->dstream = NULL;
sp->state = 0;
}
in_buffer.src = tif->tif_rawcp; sp->state |= LSTATE_INIT_ENCODE;
in_buffer.size = (size_t) tif->tif_rawcc; return 1;
in_buffer.pos = 0;
out_buffer.dst = op;
out_buffer.size = (size_t) occ;
out_buffer.pos = 0;
do {
zstd_ret = ZSTD_decompressStream(sp->dstream, &out_buffer,
&in_buffer);
if( ZSTD_isError(zstd_ret) ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Error in ZSTD_decompressStream(): %s",
ZSTD_getErrorName(zstd_ret));
return 0;
}
} while( zstd_ret != 0 &&
in_buffer.pos < in_buffer.size &&
out_buffer.pos < out_buffer.size );
if (out_buffer.pos < (size_t)occ) {
TIFFErrorExt(tif->tif_clientdata, module,
"Not enough data at scanline %lu (short %lu bytes)",
(unsigned long) tif->tif_row,
(unsigned long) (size_t)occ - out_buffer.pos);
return 0;
}
tif->tif_rawcp += in_buffer.pos;
tif->tif_rawcc -= in_buffer.pos;
return 1;
}
static int
ZSTDSetupEncode(TIFF* tif)
{
ZSTDState* sp = EncoderState(tif);
assert(sp != NULL);
if (sp->state & LSTATE_INIT_DECODE) {
ZSTD_freeDStream(sp->dstream);
sp->dstream = NULL;
sp->state = 0;
}
sp->state |= LSTATE_INIT_ENCODE;
return 1;
} }
/* /*
* Reset encoding state at the start of a strip. * Reset encoding state at the start of a strip.
*/ */
static int static int ZSTDPreEncode(TIFF *tif, uint16_t s)
ZSTDPreEncode(TIFF* tif, uint16 s)
{ {
static const char module[] = "ZSTDPreEncode"; static const char module[] = "ZSTDPreEncode";
ZSTDState *sp = EncoderState(tif); ZSTDState *sp = EncoderState(tif);
size_t zstd_ret; size_t zstd_ret;
(void) s; (void)s;
assert(sp != NULL); assert(sp != NULL);
if( sp->state != LSTATE_INIT_ENCODE ) if (sp->state != LSTATE_INIT_ENCODE)
tif->tif_setupencode(tif); tif->tif_setupencode(tif);
if (sp->cstream) { if (sp->cstream == NULL)
ZSTD_freeCStream(sp->cstream); {
sp->cstream = NULL;
}
sp->cstream = ZSTD_createCStream(); sp->cstream = ZSTD_createCStream();
if( sp->cstream == NULL ) { if (sp->cstream == NULL)
TIFFErrorExt(tif->tif_clientdata, module, {
"Cannot allocate compression stream"); TIFFErrorExtR(tif, module, "Cannot allocate compression stream");
return 0; return 0;
} }
}
zstd_ret = ZSTD_initCStream(sp->cstream, sp->compression_level); zstd_ret = ZSTD_initCStream(sp->cstream, sp->compression_level);
if( ZSTD_isError(zstd_ret) ) { if (ZSTD_isError(zstd_ret))
TIFFErrorExt(tif->tif_clientdata, module, {
"Error in ZSTD_initCStream(): %s", TIFFErrorExtR(tif, module, "Error in ZSTD_initCStream(): %s",
ZSTD_getErrorName(zstd_ret)); ZSTD_getErrorName(zstd_ret));
return 0; return 0;
} }
sp->out_buffer.dst = tif->tif_rawdata; sp->out_buffer.dst = tif->tif_rawdata;
sp->out_buffer.size = (size_t)tif->tif_rawdatasize; sp->out_buffer.size = (size_t)tif->tif_rawdatasize;
sp->out_buffer.pos = 0; sp->out_buffer.pos = 0;
return 1; return 1;
} }
/* /*
* Encode a chunk of pixels. * Encode a chunk of pixels.
*/ */
static int static int ZSTDEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
ZSTDEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{ {
static const char module[] = "ZSTDEncode"; static const char module[] = "ZSTDEncode";
ZSTDState *sp = EncoderState(tif); ZSTDState *sp = EncoderState(tif);
ZSTD_inBuffer in_buffer; ZSTD_inBuffer in_buffer;
size_t zstd_ret; size_t zstd_ret;
assert(sp != NULL); assert(sp != NULL);
assert(sp->state == LSTATE_INIT_ENCODE); assert(sp->state == LSTATE_INIT_ENCODE);
(void) s; (void)s;
in_buffer.src = bp; in_buffer.src = bp;
in_buffer.size = (size_t)cc; in_buffer.size = (size_t)cc;
in_buffer.pos = 0; in_buffer.pos = 0;
do { do
zstd_ret = ZSTD_compressStream(sp->cstream, &sp->out_buffer, {
&in_buffer); zstd_ret =
if( ZSTD_isError(zstd_ret) ) { ZSTD_compressStream(sp->cstream, &sp->out_buffer, &in_buffer);
TIFFErrorExt(tif->tif_clientdata, module, if (ZSTD_isError(zstd_ret))
"Error in ZSTD_compressStream(): %s", {
ZSTD_getErrorName(zstd_ret)); TIFFErrorExtR(tif, module, "Error in ZSTD_compressStream(): %s",
return 0; ZSTD_getErrorName(zstd_ret));
} return 0;
if( sp->out_buffer.pos == sp->out_buffer.size ) { }
tif->tif_rawcc = tif->tif_rawdatasize; if (sp->out_buffer.pos == sp->out_buffer.size)
if (!TIFFFlushData1(tif)) {
return 0; tif->tif_rawcc = tif->tif_rawdatasize;
sp->out_buffer.dst = tif->tif_rawcp; if (!TIFFFlushData1(tif))
sp->out_buffer.pos = 0; return 0;
} sp->out_buffer.dst = tif->tif_rawcp;
} while( in_buffer.pos < in_buffer.size ); sp->out_buffer.pos = 0;
}
} while (in_buffer.pos < in_buffer.size);
return 1; return 1;
} }
/* /*
* Finish off an encoded strip by flushing it. * Finish off an encoded strip by flushing it.
*/ */
static int static int ZSTDPostEncode(TIFF *tif)
ZSTDPostEncode(TIFF* tif)
{ {
static const char module[] = "ZSTDPostEncode"; static const char module[] = "ZSTDPostEncode";
ZSTDState *sp = EncoderState(tif); ZSTDState *sp = EncoderState(tif);
size_t zstd_ret; size_t zstd_ret;
do { do
zstd_ret = ZSTD_endStream(sp->cstream, &sp->out_buffer); {
if( ZSTD_isError(zstd_ret) ) { zstd_ret = ZSTD_endStream(sp->cstream, &sp->out_buffer);
TIFFErrorExt(tif->tif_clientdata, module, if (ZSTD_isError(zstd_ret))
"Error in ZSTD_endStream(): %s", {
ZSTD_getErrorName(zstd_ret)); TIFFErrorExtR(tif, module, "Error in ZSTD_endStream(): %s",
return 0; ZSTD_getErrorName(zstd_ret));
} return 0;
if( sp->out_buffer.pos > 0 ) { }
tif->tif_rawcc = sp->out_buffer.pos; if (sp->out_buffer.pos > 0)
if (!TIFFFlushData1(tif)) {
return 0; tif->tif_rawcc = sp->out_buffer.pos;
sp->out_buffer.dst = tif->tif_rawcp; if (!TIFFFlushData1(tif))
sp->out_buffer.pos = 0; return 0;
} sp->out_buffer.dst = tif->tif_rawcp;
} while (zstd_ret != 0); sp->out_buffer.pos = 0;
return 1; }
} while (zstd_ret != 0);
return 1;
} }
static void static void ZSTDCleanup(TIFF *tif)
ZSTDCleanup(TIFF* tif)
{ {
ZSTDState* sp = LState(tif); ZSTDState *sp = LState(tif);
assert(sp != 0); assert(sp != 0);
(void)TIFFPredictorCleanup(tif); (void)TIFFPredictorCleanup(tif);
tif->tif_tagmethods.vgetfield = sp->vgetparent; tif->tif_tagmethods.vgetfield = sp->vgetparent;
tif->tif_tagmethods.vsetfield = sp->vsetparent; tif->tif_tagmethods.vsetfield = sp->vsetparent;
if (sp->dstream) { if (sp->dstream)
ZSTD_freeDStream(sp->dstream); {
sp->dstream = NULL; ZSTD_freeDStream(sp->dstream);
} sp->dstream = NULL;
if (sp->cstream) { }
ZSTD_freeCStream(sp->cstream); if (sp->cstream)
sp->cstream = NULL; {
} ZSTD_freeCStream(sp->cstream);
_TIFFfree(sp); sp->cstream = NULL;
tif->tif_data = NULL; }
_TIFFfreeExt(tif, sp);
tif->tif_data = NULL;
_TIFFSetDefaultCompressionState(tif); _TIFFSetDefaultCompressionState(tif);
} }
static int static int ZSTDVSetField(TIFF *tif, uint32_t tag, va_list ap)
ZSTDVSetField(TIFF* tif, uint32 tag, va_list ap)
{ {
static const char module[] = "ZSTDVSetField"; static const char module[] = "ZSTDVSetField";
ZSTDState* sp = LState(tif); ZSTDState *sp = LState(tif);
switch (tag) { switch (tag)
{
case TIFFTAG_ZSTD_LEVEL: case TIFFTAG_ZSTD_LEVEL:
sp->compression_level = (int) va_arg(ap, int); sp->compression_level = (int)va_arg(ap, int);
if( sp->compression_level <= 0 || if (sp->compression_level <= 0 ||
sp->compression_level > ZSTD_maxCLevel() ) sp->compression_level > ZSTD_maxCLevel())
{ {
TIFFWarningExt(tif->tif_clientdata, module, TIFFWarningExtR(tif, module,
"ZSTD_LEVEL should be between 1 and %d", "ZSTD_LEVEL should be between 1 and %d",
ZSTD_maxCLevel()); ZSTD_maxCLevel());
} }
return 1; return 1;
default: default:
return (*sp->vsetparent)(tif, tag, ap); return (*sp->vsetparent)(tif, tag, ap);
} }
/*NOTREACHED*/ /*NOTREACHED*/
} }
static int static int ZSTDVGetField(TIFF *tif, uint32_t tag, va_list ap)
ZSTDVGetField(TIFF* tif, uint32 tag, va_list ap)
{ {
ZSTDState* sp = LState(tif); ZSTDState *sp = LState(tif);
switch (tag) { switch (tag)
{
case TIFFTAG_ZSTD_LEVEL: case TIFFTAG_ZSTD_LEVEL:
*va_arg(ap, int*) = sp->compression_level; *va_arg(ap, int *) = sp->compression_level;
break; break;
default: default:
return (*sp->vgetparent)(tif, tag, ap); return (*sp->vgetparent)(tif, tag, ap);
} }
return 1; return 1;
} }
static const TIFFField ZSTDFields[] = { static const TIFFField ZSTDFields[] = {
{ TIFFTAG_ZSTD_LEVEL, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, {TIFFTAG_ZSTD_LEVEL, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "ZSTD compression_level",
FIELD_PSEUDO, TRUE, FALSE, "ZSTD compression_level", NULL }, NULL},
}; };
int int TIFFInitZSTD(TIFF *tif, int scheme)
TIFFInitZSTD(TIFF* tif, int scheme)
{ {
static const char module[] = "TIFFInitZSTD"; static const char module[] = "TIFFInitZSTD";
ZSTDState* sp; ZSTDState *sp;
assert( scheme == COMPRESSION_ZSTD ); (void)scheme;
assert(scheme == COMPRESSION_ZSTD);
/* /*
* Merge codec-specific tag information. * Merge codec-specific tag information.
*/ */
if (!_TIFFMergeFields(tif, ZSTDFields, TIFFArrayCount(ZSTDFields))) { if (!_TIFFMergeFields(tif, ZSTDFields, TIFFArrayCount(ZSTDFields)))
TIFFErrorExt(tif->tif_clientdata, module, {
"Merging ZSTD codec-specific tags failed"); TIFFErrorExtR(tif, module, "Merging ZSTD codec-specific tags failed");
return 0;
}
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (uint8*) _TIFFmalloc(sizeof(ZSTDState));
if (tif->tif_data == NULL)
goto bad;
sp = LState(tif);
/*
* Override parent get/set field methods.
*/
sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield = ZSTDVGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vsetfield = ZSTDVSetField; /* hook for codec tags */
/* Default values for codec-specific fields */
sp->compression_level = 9; /* default comp. level */
sp->state = 0;
sp->dstream = 0;
sp->cstream = 0;
sp->out_buffer.dst = NULL;
sp->out_buffer.size = 0;
sp->out_buffer.pos = 0;
/*
* Install codec methods.
*/
tif->tif_fixuptags = ZSTDFixupTags;
tif->tif_setupdecode = ZSTDSetupDecode;
tif->tif_predecode = ZSTDPreDecode;
tif->tif_decoderow = ZSTDDecode;
tif->tif_decodestrip = ZSTDDecode;
tif->tif_decodetile = ZSTDDecode;
tif->tif_setupencode = ZSTDSetupEncode;
tif->tif_preencode = ZSTDPreEncode;
tif->tif_postencode = ZSTDPostEncode;
tif->tif_encoderow = ZSTDEncode;
tif->tif_encodestrip = ZSTDEncode;
tif->tif_encodetile = ZSTDEncode;
tif->tif_cleanup = ZSTDCleanup;
/*
* Setup predictor setup.
*/
(void) TIFFPredictorInit(tif);
return 1;
bad:
TIFFErrorExt(tif->tif_clientdata, module,
"No space for ZSTD state block");
return 0; return 0;
}
/*
* Allocate state block so tag methods have storage to record values.
*/
tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(ZSTDState));
if (tif->tif_data == NULL)
goto bad;
sp = LState(tif);
/*
* Override parent get/set field methods.
*/
sp->vgetparent = tif->tif_tagmethods.vgetfield;
tif->tif_tagmethods.vgetfield = ZSTDVGetField; /* hook for codec tags */
sp->vsetparent = tif->tif_tagmethods.vsetfield;
tif->tif_tagmethods.vsetfield = ZSTDVSetField; /* hook for codec tags */
/* Default values for codec-specific fields */
sp->compression_level = 9; /* default comp. level */
sp->state = 0;
sp->dstream = 0;
sp->cstream = 0;
sp->out_buffer.dst = NULL;
sp->out_buffer.size = 0;
sp->out_buffer.pos = 0;
/*
* Install codec methods.
*/
tif->tif_fixuptags = ZSTDFixupTags;
tif->tif_setupdecode = ZSTDSetupDecode;
tif->tif_predecode = ZSTDPreDecode;
tif->tif_decoderow = ZSTDDecode;
tif->tif_decodestrip = ZSTDDecode;
tif->tif_decodetile = ZSTDDecode;
tif->tif_setupencode = ZSTDSetupEncode;
tif->tif_preencode = ZSTDPreEncode;
tif->tif_postencode = ZSTDPostEncode;
tif->tif_encoderow = ZSTDEncode;
tif->tif_encodestrip = ZSTDEncode;
tif->tif_encodetile = ZSTDEncode;
tif->tif_cleanup = ZSTDCleanup;
/*
* Setup predictor setup.
*/
(void)TIFFPredictorInit(tif);
return 1;
bad:
TIFFErrorExtR(tif, module, "No space for ZSTD state block");
return 0;
} }
#endif /* ZSTD_SUPPORT */ #endif /* ZSTD_SUPPORT */
/* vim: set ts=8 sts=8 sw=8 noet: */

1381
3rdparty/libtiff/tiff.h vendored
View File

File diff suppressed because it is too large Load Diff

42
3rdparty/libtiff/tiffconf.h.cmake.in vendored
View File

@ -4,9 +4,21 @@
from this file in your programs. from this file in your programs.
*/ */
/* clang-format off */
/* clang-format disabled because CMake scripts are very sensitive to the
* formatting of this file. configure_file variables of type "@VAR@" are
* modified by clang-format and won't be substituted.
*/
#ifndef _TIFFCONF_ #ifndef _TIFFCONF_
#define _TIFFCONF_ #define _TIFFCONF_
#include <stddef.h>
#include <stdint.h>
#include <inttypes.h>
/* Signed 16-bit type */ /* Signed 16-bit type */
#define TIFF_INT16_T @TIFF_INT16_T@ #define TIFF_INT16_T @TIFF_INT16_T@
@ -31,23 +43,26 @@
/* Unsigned 8-bit type */ /* Unsigned 8-bit type */
#define TIFF_UINT8_T @TIFF_UINT8_T@ #define TIFF_UINT8_T @TIFF_UINT8_T@
/* Unsigned size type */
#define TIFF_SIZE_T @TIFF_SIZE_T@
/* Signed size type */ /* Signed size type */
#define TIFF_SSIZE_T @TIFF_SSIZE_T@ #define TIFF_SSIZE_T @TIFF_SSIZE_T@
/* Pointer difference type */
#define TIFF_PTRDIFF_T @TIFF_PTRDIFF_T@
/* Compatibility stuff. */ /* Compatibility stuff. */
/* Define as 0 or 1 according to the floating point format suported by the /* Define as 0 or 1 according to the floating point format supported by the
machine */ machine */
#cmakedefine HAVE_IEEEFP 1 #cmakedefine HAVE_IEEEFP 1
/* Set the native cpu bit order (FILLORDER_LSB2MSB or FILLORDER_MSB2LSB) */ /* The concept of HOST_FILLORDER is broken. Since libtiff 4.5.1
#define HOST_FILLORDER @HOST_FILLORDER@ * this macro will always be hardcoded to FILLORDER_LSB2MSB on all
* architectures, to reflect past long behavior of doing so on x86 architecture.
* Note however that the default FillOrder used by libtiff is FILLORDER_MSB2LSB,
* as mandated per the TIFF specification.
* The influence of HOST_FILLORDER is only when passing the 'H' mode in
* TIFFOpen().
* You should NOT rely on this macro to decide the CPU endianness!
* This macro will be removed in libtiff 4.6
*/
#define HOST_FILLORDER FILLORDER_LSB2MSB
/* Native cpu byte order: 1 if big-endian (Motorola) or 0 if little-endian /* Native cpu byte order: 1 if big-endian (Motorola) or 0 if little-endian
(Intel) */ (Intel) */
@ -62,6 +77,9 @@
/* Support JBIG compression (requires JBIG-KIT library) */ /* Support JBIG compression (requires JBIG-KIT library) */
#cmakedefine JBIG_SUPPORT #cmakedefine JBIG_SUPPORT
/* Support LERC compression */
#cmakedefine LERC_SUPPORT 1
/* Support LogLuv high dynamic range encoding */ /* Support LogLuv high dynamic range encoding */
#cmakedefine LOGLUV_SUPPORT 1 #cmakedefine LOGLUV_SUPPORT 1
@ -91,8 +109,8 @@
#cmakedefine LIBDEFLATE_SUPPORT 1 #cmakedefine LIBDEFLATE_SUPPORT 1
/* Support strip chopping (whether or not to convert single-strip uncompressed /* Support strip chopping (whether or not to convert single-strip uncompressed
images to mutiple strips of ~8Kb to reduce memory usage) */ images to multiple strips of ~8Kb to reduce memory usage) */
#cmakedefine STRIPCHOP_DEFAULT 1 #cmakedefine STRIPCHOP_DEFAULT TIFF_STRIPCHOP
/* Enable SubIFD tag (330) support */ /* Enable SubIFD tag (330) support */
#cmakedefine SUBIFD_SUPPORT 1 #cmakedefine SUBIFD_SUPPORT 1
@ -122,3 +140,5 @@
#define IPTC_SUPPORT #define IPTC_SUPPORT
#endif /* _TIFFCONF_ */ #endif /* _TIFFCONF_ */
/* clang-format on */

833
3rdparty/libtiff/tiffio.h vendored
View File

@ -23,7 +23,7 @@
*/ */
#ifndef _TIFFIO_ #ifndef _TIFFIO_
#define _TIFFIO_ #define _TIFFIO_
/* /*
* TIFF I/O Library Definitions. * TIFF I/O Library Definitions.
@ -60,20 +60,22 @@ typedef struct tiff TIFF;
*/ */
/* /*
* this is the machine addressing size type, only it's signed, so make it * this is the machine addressing size type, only it's signed, so make it
* int32 on 32bit machines, int64 on 64bit machines * int32_t on 32bit machines, int64_t on 64bit machines
*/ */
typedef TIFF_SSIZE_T tmsize_t; typedef TIFF_SSIZE_T tmsize_t;
typedef uint64 toff_t; /* file offset */ #define TIFF_TMSIZE_T_MAX (tmsize_t)(SIZE_MAX >> 1)
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 ttag_t; /* directory tag */ typedef uint32_t ttag_t; /* directory tag */
typedef uint16 tdir_t; /* directory index */ typedef uint32_t tdir_t; /* directory index */
typedef uint16 tsample_t; /* sample number */ typedef uint16_t tsample_t; /* sample number */
typedef uint32 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__
@ -87,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 */
/* /*
@ -110,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
*/ */
@ -133,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 d_Vrwr; /* Pixel values for ref. white */ float d_YCB;
uint32 d_Vrwg; uint32_t d_Vrwr; /* Pixel values for ref. white */
uint32 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* Cr_g_tab; int *Cb_b_tab;
int32* Cb_g_tab; int32_t *Cr_g_tab;
int32* 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;
/* /*
@ -178,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*, uint32, uint32, uint32, uint32, int32, int32, 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*, uint32, uint32, uint32, uint32, int32, int32, 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 width; /* image width */ int alpha; /* type of alpha data present */
uint32 height; /* image height */ uint32_t width; /* image width */
uint16 bitspersample; /* image bits/sample */ uint32_t height; /* image height */
uint16 samplesperpixel; /* image samples/pixel */ uint16_t bitspersample; /* image bits/sample */
uint16 orientation; /* image orientation */ uint16_t samplesperpixel; /* image samples/pixel */
uint16 req_orientation; /* requested orientation */ uint16_t orientation; /* image orientation */
uint16 photometric; /* image photometric interp */ uint16_t req_orientation; /* requested orientation */
uint16* redcmap; /* colormap palette */ uint16_t photometric; /* image photometric interp */
uint16* greencmap; uint16_t *redcmap; /* colormap palette */
uint16* bluecmap; uint16_t *greencmap;
/* get image data routine */ uint16_t *bluecmap;
int (*get)(TIFFRGBAImage*, uint32*, uint32, uint32); /* 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** BWmap; /* black&white map */ } put;
uint32** 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* UaToAa; /* Unassociated alpha to associated alpha conversion LUT */ uint8_t *UaToAa; /* Unassociated alpha to associated alpha conversion LUT */
uint8* 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)
@ -246,327 +255,399 @@ 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 scheme; char *name;
TIFFInitMethod init; uint16_t scheme;
TIFFInitMethod init;
} TIFFCodec; } TIFFCodec;
#include <stdio.h> typedef struct
{
uint32_t uNum;
uint32_t uDenom;
} TIFFRational_t;
#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
#define LOGLUV_PUBLIC 1 #define LOGLUV_PUBLIC 1
#endif #endif
#if defined(__GNUC__) || defined(__attribute__) #if defined(__GNUC__) || defined(__clang__) || 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); extern const TIFFCodec *TIFFFindCODEC(uint16_t);
extern TIFFCodec* TIFFRegisterCODEC(uint16, const char*, TIFFInitMethod); extern TIFFCodec *TIFFRegisterCODEC(uint16_t, const char *, TIFFInitMethod);
extern void TIFFUnRegisterCODEC(TIFFCodec*); extern void TIFFUnRegisterCODEC(TIFFCodec *);
extern int TIFFIsCODECConfigured(uint16); 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 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 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, TIFFDataType); typedef struct _TIFFField TIFFField;
extern const TIFFField* TIFFFieldWithTag(TIFF*, uint32); typedef struct _TIFFFieldArray TIFFFieldArray;
extern const TIFFField* TIFFFieldWithName(TIFF*, const char *);
extern uint32 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*);
typedef int (*TIFFVSetMethod)(TIFF*, uint32, va_list); extern uint32_t TIFFFieldTag(const TIFFField *);
typedef int (*TIFFVGetMethod)(TIFF*, uint32, 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 tag, ...); extern void TIFFCleanup(TIFF *tif);
extern int TIFFVGetField(TIFF* tif, uint32 tag, va_list ap); extern void TIFFClose(TIFF *tif);
extern int TIFFGetFieldDefaulted(TIFF* tif, uint32 tag, ...); extern int TIFFFlush(TIFF *tif);
extern int TIFFVGetFieldDefaulted(TIFF* tif, uint32 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 TIFFScanlineSize64(TIFF* tif); extern int TIFFReadDirectory(TIFF *tif);
extern tmsize_t TIFFScanlineSize(TIFF* tif); extern int TIFFReadCustomDirectory(TIFF *tif, toff_t diroff,
extern uint64 TIFFRasterScanlineSize64(TIFF* tif); const TIFFFieldArray *infoarray);
extern tmsize_t TIFFRasterScanlineSize(TIFF* tif); extern int TIFFReadEXIFDirectory(TIFF *tif, toff_t diroff);
extern uint64 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 TIFFRawStripSize64(TIFF* tif, uint32 strip); extern tmsize_t TIFFScanlineSize(TIFF *tif);
extern tmsize_t TIFFRawStripSize(TIFF* tif, uint32 strip); extern uint64_t TIFFRasterScanlineSize64(TIFF *tif);
extern uint64 TIFFVStripSize64(TIFF* tif, uint32 nrows); extern tmsize_t TIFFRasterScanlineSize(TIFF *tif);
extern tmsize_t TIFFVStripSize(TIFF* tif, uint32 nrows); extern uint64_t TIFFStripSize64(TIFF *tif);
extern uint64 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 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 TIFFVTileSize64(TIFF* tif, uint32 nrows); extern tmsize_t TIFFVStripSize(TIFF *tif, uint32_t nrows);
extern tmsize_t TIFFVTileSize(TIFF* tif, uint32 nrows); extern uint64_t TIFFTileRowSize64(TIFF *tif);
extern uint32 TIFFDefaultStripSize(TIFF* tif, uint32 request); extern tmsize_t TIFFTileRowSize(TIFF *tif);
extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*); 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 TIFFReadWriteProc TIFFGetReadProc(TIFF*); extern int TIFFIsTiled(TIFF *);
extern TIFFReadWriteProc TIFFGetWriteProc(TIFF*); extern int TIFFIsByteSwapped(TIFF *);
extern TIFFSeekProc TIFFGetSeekProc(TIFF*); extern int TIFFIsUpSampled(TIFF *);
extern TIFFCloseProc TIFFGetCloseProc(TIFF*); extern int TIFFIsMSB2LSB(TIFF *);
extern TIFFSizeProc TIFFGetSizeProc(TIFF*); extern int TIFFIsBigEndian(TIFF *);
extern TIFFMapFileProc TIFFGetMapFileProc(TIFF*); extern int TIFFIsBigTIFF(TIFF *);
extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF*); extern TIFFReadWriteProc TIFFGetReadProc(TIFF *);
extern uint32 TIFFCurrentRow(TIFF*); extern TIFFReadWriteProc TIFFGetWriteProc(TIFF *);
extern uint16 TIFFCurrentDirectory(TIFF*); extern TIFFSeekProc TIFFGetSeekProc(TIFF *);
extern uint16 TIFFNumberOfDirectories(TIFF*); extern TIFFCloseProc TIFFGetCloseProc(TIFF *);
extern uint64 TIFFCurrentDirOffset(TIFF*); extern TIFFSizeProc TIFFGetSizeProc(TIFF *);
extern uint32 TIFFCurrentStrip(TIFF*); extern TIFFMapFileProc TIFFGetMapFileProc(TIFF *);
extern uint32 TIFFCurrentTile(TIFF* tif); extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF *);
extern int TIFFReadBufferSetup(TIFF* tif, void* bp, tmsize_t size); extern uint32_t TIFFCurrentRow(TIFF *);
extern int TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size); extern tdir_t TIFFCurrentDirectory(TIFF *);
extern int TIFFSetupStrips(TIFF *); extern tdir_t TIFFNumberOfDirectories(TIFF *);
extern int TIFFWriteCheck(TIFF*, int, const char *); extern uint64_t TIFFCurrentDirOffset(TIFF *);
extern void TIFFFreeDirectory(TIFF*); extern uint32_t TIFFCurrentStrip(TIFF *);
extern int TIFFCreateDirectory(TIFF*); extern uint32_t TIFFCurrentTile(TIFF *tif);
extern int TIFFCreateCustomDirectory(TIFF*,const TIFFFieldArray*); extern int TIFFReadBufferSetup(TIFF *tif, void *bp, tmsize_t size);
extern int TIFFCreateEXIFDirectory(TIFF*); extern int TIFFWriteBufferSetup(TIFF *tif, void *bp, tmsize_t size);
extern int TIFFCreateGPSDirectory(TIFF*); extern int TIFFSetupStrips(TIFF *);
extern int TIFFLastDirectory(TIFF*); extern int TIFFWriteCheck(TIFF *, int, const char *);
extern int TIFFSetDirectory(TIFF*, uint16); extern void TIFFFreeDirectory(TIFF *);
extern int TIFFSetSubDirectory(TIFF*, uint64); extern int TIFFCreateDirectory(TIFF *);
extern int TIFFUnlinkDirectory(TIFF*, uint16); extern int TIFFCreateCustomDirectory(TIFF *, const TIFFFieldArray *);
extern int TIFFSetField(TIFF*, uint32, ...); extern int TIFFCreateEXIFDirectory(TIFF *);
extern int TIFFVSetField(TIFF*, uint32, va_list); extern int TIFFCreateGPSDirectory(TIFF *);
extern int TIFFUnsetField(TIFF*, uint32); extern int TIFFLastDirectory(TIFF *);
extern int TIFFWriteDirectory(TIFF *); extern int TIFFSetDirectory(TIFF *, tdir_t);
extern int TIFFWriteCustomDirectory(TIFF *, uint64 *); extern int TIFFSetSubDirectory(TIFF *, uint64_t);
extern int TIFFCheckpointDirectory(TIFF *); extern int TIFFUnlinkDirectory(TIFF *, tdir_t);
extern int TIFFRewriteDirectory(TIFF *); extern int TIFFSetField(TIFF *, uint32_t, ...);
extern int TIFFDeferStrileArrayWriting(TIFF *); extern int TIFFVSetField(TIFF *, uint32_t, va_list);
extern int TIFFForceStrileArrayWriting(TIFF* ); extern int TIFFUnsetField(TIFF *, uint32_t);
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 row, uint16 sample = 0); extern int TIFFReadScanline(TIFF *tif, void *buf, uint32_t row,
extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample = 0); uint16_t sample = 0);
extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int = 0); extern int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row,
extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, 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 row, uint16 sample); extern int TIFFReadScanline(TIFF *tif, void *buf, uint32_t row,
extern int TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample); uint16_t sample);
extern int TIFFReadRGBAImage(TIFF*, uint32, uint32, uint32*, int); extern int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row,
extern int TIFFReadRGBAImageOriented(TIFF*, uint32, uint32, uint32*, 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, uint32 * ); extern int TIFFReadRGBAStrip(TIFF *, uint32_t, uint32_t *);
extern int TIFFReadRGBATile(TIFF*, uint32, uint32, uint32 * ); extern int TIFFReadRGBATile(TIFF *, uint32_t, uint32_t, uint32_t *);
extern int TIFFReadRGBAStripExt(TIFF*, uint32, uint32 *, int stop_on_error ); extern int TIFFReadRGBAStripExt(TIFF *, uint32_t, uint32_t *,
extern int TIFFReadRGBATileExt(TIFF*, uint32, uint32, uint32 *, 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*, uint32, uint32); 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 TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s);
extern int TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s);
extern uint32 TIFFNumberOfTiles(TIFF*);
extern tmsize_t TIFFReadTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s);
extern tmsize_t TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s);
extern uint32 TIFFComputeStrip(TIFF*, uint32, uint16);
extern uint32 TIFFNumberOfStrips(TIFF*);
extern tmsize_t TIFFReadEncodedStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size);
extern tmsize_t TIFFReadRawStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size);
extern tmsize_t TIFFReadEncodedTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size);
extern tmsize_t TIFFReadRawTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size);
extern int TIFFReadFromUserBuffer(TIFF* tif, uint32 strile,
void* inbuf, tmsize_t insize,
void* outbuf, tmsize_t outsize);
extern tmsize_t TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc);
extern tmsize_t TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc);
extern tmsize_t TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc);
extern tmsize_t TIFFWriteRawTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc);
extern int TIFFDataWidth(TIFFDataType); /* table of tag datatype widths */
extern void TIFFSetWriteOffset(TIFF* tif, toff_t off);
extern void TIFFSwabShort(uint16*);
extern void TIFFSwabLong(uint32*);
extern void TIFFSwabLong8(uint64*);
extern void TIFFSwabFloat(float*);
extern void TIFFSwabDouble(double*);
extern void TIFFSwabArrayOfShort(uint16* wp, tmsize_t n);
extern void TIFFSwabArrayOfTriples(uint8* tp, tmsize_t n);
extern void TIFFSwabArrayOfLong(uint32* lp, tmsize_t n);
extern void TIFFSwabArrayOfLong8(uint64* lp, tmsize_t n);
extern void TIFFSwabArrayOfFloat(float* fp, tmsize_t n);
extern void TIFFSwabArrayOfDouble(double* dp, tmsize_t n);
extern void TIFFReverseBits(uint8* cp, tmsize_t n);
extern const unsigned char* TIFFGetBitRevTable(int);
extern uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile); extern const char *TIFFFileName(TIFF *);
extern uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile); extern const char *TIFFSetFileName(TIFF *, const char *);
extern uint64 TIFFGetStrileOffsetWithErr(TIFF *tif, uint32 strile, int *pbErr); extern void TIFFError(const char *, const char *, ...)
extern uint64 TIFFGetStrileByteCountWithErr(TIFF *tif, uint32 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*); extern void XYZtoRGB24(float *, uint8_t *);
extern int uv_decode(double*, double*, int); extern int uv_decode(double *, double *, int);
extern void LogLuv24toXYZ(uint32, float*); extern void LogLuv24toXYZ(uint32_t, float *);
extern void LogLuv32toXYZ(uint32, 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 LogLuv24fromXYZ(float*, int = SGILOGENCODE_NODITHER); extern uint32_t LogLuv24fromXYZ(float *, int = SGILOGENCODE_NODITHER);
extern uint32 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 LogLuv24fromXYZ(float*, int); extern uint32_t LogLuv24fromXYZ(float *, int);
extern uint32 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, int32, int32, 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 *, uint32 *, uint32 *); 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, int32, int32, extern void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *, uint32_t, int32_t, int32_t,
uint32 *, uint32 *, uint32 *); 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);
#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:
*/

33
3rdparty/libtiff/tiffio.hxx vendored
View File

@ -2,47 +2,38 @@
* 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 _TIFFIO_HXX_ #ifndef _TIFFIO_HXX_
#define _TIFFIO_HXX_ #define _TIFFIO_HXX_
/* /*
* TIFF I/O library definitions which provide C++ streams API. * TIFF I/O library definitions which provide C++ streams API.
*/ */
#include <iostream>
#include "tiff.h" #include "tiff.h"
#include "tiffio.h" #include "tiffio.h"
#include <iostream>
extern TIFF* TIFFStreamOpen(const char*, std::ostream *); extern TIFF *TIFFStreamOpen(const char *, std::ostream *);
extern TIFF* TIFFStreamOpen(const char*, std::istream *); extern TIFF *TIFFStreamOpen(const char *, std::istream *);
#endif /* _TIFFIO_HXX_ */ #endif /* _TIFFIO_HXX_ */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c++
* c-basic-offset: 8
* fill-column: 78
* End:
*/

662
3rdparty/libtiff/tiffiop.h vendored
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 _TIFFIOP_ #ifndef _TIFFIOP_
#define _TIFFIOP_ #define _TIFFIOP_
/* /*
* ``Library-private'' definitions. * ``Library-private'' definitions.
*/ */
@ -31,66 +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
#ifdef HAVE_STRING_H #include <string.h>
# include <string.h>
#endif
#ifdef HAVE_ASSERT_H #ifdef HAVE_ASSERT_H
# include <assert.h> #include <assert.h>
#else #else
# define assert(x) #define assert(x)
#endif
#ifdef HAVE_SEARCH_H
# include <search.h>
#else
extern void *lfind(const void *, const void *, size_t *, size_t,
int (*)(const void *, const void *));
#endif
#if !defined(HAVE_SNPRINTF) && !defined(HAVE__SNPRINTF)
#undef snprintf
#define snprintf _TIFF_snprintf_f
extern int snprintf(char* str, size_t size, const char* format, ...);
#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
#define TIFF_SIZE_T_MAX ((size_t) ~ ((size_t)0)) typedef struct client_info
#define TIFF_TMSIZE_T_MAX (tmsize_t)(TIFF_SIZE_T_MAX >> 1) {
/*
* Largest 32-bit unsigned integer value.
*/
#define TIFF_UINT32_MAX 0xFFFFFFFFU
/*
* Largest 64-bit unsigned integer value.
*/
#define TIFF_UINT64_MAX (((uint64)(TIFF_UINT32_MAX)) << 32 | TIFF_UINT32_MAX)
typedef struct client_info {
struct client_info *next; struct client_info *next;
void *data; void *data;
char *name; char *name;
@ -100,187 +82,231 @@ 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); typedef int (*TIFFPreMethod)(TIFF *, uint16_t);
typedef int (*TIFFCodeMethod)(TIFF* tif, uint8* buf, tmsize_t size, uint16 sample); typedef int (*TIFFCodeMethod)(TIFF *tif, uint8_t *buf, tmsize_t size,
typedef int (*TIFFSeekMethod)(TIFF*, uint32); uint16_t sample);
typedef void (*TIFFPostMethod)(TIFF* tif, uint8* buf, tmsize_t size); typedef int (*TIFFSeekMethod)(TIFF *, uint32_t);
typedef uint32 (*TIFFStripMethod)(TIFF*, uint32); typedef void (*TIFFPostMethod)(TIFF *tif, uint8_t *buf, tmsize_t size);
typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*); 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 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 tif_diroff; /* file offset of current directory */ 0x20000U /* skip reading of raw uncompressed image data */
uint64 tif_nextdiroff; /* file offset of following directory */ #define TIFF_INCUSTOMIFD 0x40000U /* currently writing a custom IFD */
uint64* tif_dirlist; /* list of offsets to already seen directories to prevent IFD looping */ #define TIFF_BIGTIFF 0x80000U /* read/write bigtiff */
uint16 tif_dirlistsize; /* number of entries in offset list */ #define TIFF_BUF4WRITE 0x100000U /* rawcc bytes are for writing */
uint16 tif_dirnumber; /* number of already seen directories */ #define TIFF_DIRTYSTRIP 0x200000U /* stripoffsets/stripbytecount dirty*/
TIFFDirectory tif_dir; /* internal rep of current directory */ #define TIFF_PERSAMPLE 0x400000U /* get/set per sample tags as arrays */
TIFFDirectory tif_customdir; /* custom IFDs are separated from the main ones */ #define TIFF_BUFFERMMAP \
union { 0x800000U /* read buffer (tif_rawdata) points into mmap() memory */
TIFFHeaderCommon common; #define TIFF_DEFERSTRILELOAD \
TIFFHeaderClassic classic; 0x1000000U /* defer strip/tile offset/bytecount array loading. */
TIFFHeaderBig big; #define TIFF_LAZYSTRILELOAD \
} tif_header; 0x2000000U /* lazy/ondemand loading of strip/tile offset/bytecount values. \
uint16 tif_header_size; /* file's header block and its length */ Only used if TIFF_DEFERSTRILELOAD is set and in read-only \
uint32 tif_row; /* current scanline */ mode */
uint16 tif_curdir; /* current directory (index) */ #define TIFF_CHOPPEDUPARRAYS \
uint32 tif_curstrip; /* current strip for read/write */ 0x4000000U /* set when allocChoppedUpStripArrays() has modified strip \
uint64 tif_curoff; /* current offset for read/write */ array */
uint64 tif_dataoff; /* current offset for writing dir */ uint64_t tif_diroff; /* file offset of current directory */
/* SubIFD support */ uint64_t tif_nextdiroff; /* file offset of following directory */
uint16 tif_nsubifd; /* remaining subifds to write */ uint64_t tif_lastdiroff; /* file offset of last directory written so far */
uint64 tif_subifdoff; /* offset for patching SubIFD link */ TIFFHashSet *tif_map_dir_offset_to_number;
/* tiling support */ TIFFHashSet *tif_map_dir_number_to_offset;
uint32 tif_col; /* current column (offset by row too) */ int tif_setdirectory_force_absolute; /* switch between relative and absolute
uint32 tif_curtile; /* current tile for read/write */ stepping in TIFFSetDirectory() */
tmsize_t tif_tilesize; /* # of bytes in a tile */ TIFFDirectory tif_dir; /* internal rep of current directory */
/* compression scheme hooks */ TIFFDirectory
int tif_decodestatus; tif_customdir; /* custom IFDs are separated from the main ones */
TIFFBoolMethod tif_fixuptags; /* called in TIFFReadDirectory */ union
TIFFBoolMethod tif_setupdecode; /* called once before predecode */ {
TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */ TIFFHeaderCommon common;
TIFFBoolMethod tif_setupencode; /* called once before preencode */ TIFFHeaderClassic classic;
int tif_encodestatus; TIFFHeaderBig big;
TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */ } tif_header;
TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */ uint16_t tif_header_size; /* file's header block and its length */
TIFFCodeMethod tif_decoderow; /* scanline decoding routine */ uint32_t tif_row; /* current scanline */
TIFFCodeMethod tif_encoderow; /* scanline encoding routine */ tdir_t tif_curdir; /* current directory (index) */
TIFFCodeMethod tif_decodestrip; /* strip decoding routine */ uint32_t tif_curstrip; /* current strip for read/write */
TIFFCodeMethod tif_encodestrip; /* strip encoding routine */ uint64_t tif_curoff; /* current offset for read/write */
TIFFCodeMethod tif_decodetile; /* tile decoding routine */ uint64_t tif_lastvalidoff; /* last valid offset allowed for rewrite in
TIFFCodeMethod tif_encodetile; /* tile encoding routine */ place. Used only by TIFFAppendToStrip() */
TIFFVoidMethod tif_close; /* cleanup-on-close routine */ uint64_t tif_dataoff; /* current offset for writing dir */
TIFFSeekMethod tif_seek; /* position within a strip routine */ /* SubIFD support */
TIFFVoidMethod tif_cleanup; /* cleanup state routine */ uint16_t tif_nsubifd; /* remaining subifds to write */
TIFFStripMethod tif_defstripsize; /* calculate/constrain strip size */ uint64_t tif_subifdoff; /* offset for patching SubIFD link */
TIFFTileMethod tif_deftilesize; /* calculate/constrain tile size */ /* tiling support */
uint8* tif_data; /* compression scheme private data */ uint32_t tif_col; /* current column (offset by row too) */
/* input/output buffering */ uint32_t tif_curtile; /* current tile for read/write */
tmsize_t tif_scanlinesize; /* # of bytes in a scanline */ tmsize_t tif_tilesize; /* # of bytes in a tile */
tmsize_t tif_scanlineskew; /* scanline skew for reading strips */ /* compression scheme hooks */
uint8* tif_rawdata; /* raw data buffer */ int tif_decodestatus;
tmsize_t tif_rawdatasize; /* # of bytes in raw data buffer */ TIFFBoolMethod tif_fixuptags; /* called in TIFFReadDirectory */
tmsize_t tif_rawdataoff; /* rawdata offset within strip */ TIFFBoolMethod tif_setupdecode; /* called once before predecode */
tmsize_t tif_rawdataloaded;/* amount of data in rawdata */ TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */
uint8* tif_rawcp; /* current spot in raw buffer */ TIFFBoolMethod tif_setupencode; /* called once before preencode */
tmsize_t tif_rawcc; /* bytes unread from raw buffer */ int tif_encodestatus;
/* memory-mapped file support */ TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */
uint8* tif_base; /* base of mapped file */ TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */
tmsize_t tif_size; /* size of mapped file region (bytes, thus tmsize_t) */ TIFFCodeMethod tif_decoderow; /* scanline decoding routine */
TIFFMapFileProc tif_mapproc; /* map file method */ TIFFCodeMethod tif_encoderow; /* scanline encoding routine */
TIFFUnmapFileProc tif_unmapproc; /* unmap file method */ TIFFCodeMethod tif_decodestrip; /* strip decoding routine */
/* input/output callback methods */ TIFFCodeMethod tif_encodestrip; /* strip encoding routine */
thandle_t tif_clientdata; /* callback parameter */ TIFFCodeMethod tif_decodetile; /* tile decoding routine */
TIFFReadWriteProc tif_readproc; /* read method */ TIFFCodeMethod tif_encodetile; /* tile encoding routine */
TIFFReadWriteProc tif_writeproc; /* write method */ TIFFVoidMethod tif_close; /* cleanup-on-close routine */
TIFFSeekProc tif_seekproc; /* lseek method */ TIFFSeekMethod tif_seek; /* position within a strip routine */
TIFFCloseProc tif_closeproc; /* close method */ TIFFVoidMethod tif_cleanup; /* cleanup state routine */
TIFFSizeProc tif_sizeproc; /* filesize method */ TIFFStripMethod tif_defstripsize; /* calculate/constrain strip size */
/* post-decoding support */ TIFFTileMethod tif_deftilesize; /* calculate/constrain tile size */
TIFFPostMethod tif_postdecode; /* post decoding routine */ uint8_t *tif_data; /* compression scheme private data */
/* tag support */ /* input/output buffering */
TIFFField** tif_fields; /* sorted table of registered tags */ tmsize_t tif_scanlinesize; /* # of bytes in a scanline */
size_t tif_nfields; /* # entries in registered tag table */ tmsize_t tif_scanlineskew; /* scanline skew for reading strips */
const TIFFField* tif_foundfield; /* cached pointer to already found tag */ uint8_t *tif_rawdata; /* raw data buffer */
TIFFTagMethods tif_tagmethods; /* tag get/set/print routines */ tmsize_t tif_rawdatasize; /* # of bytes in raw data buffer */
TIFFClientInfoLink* tif_clientinfo; /* extra client information. */ tmsize_t tif_rawdataoff; /* rawdata offset within strip */
/* Backward compatibility stuff. We need these two fields for tmsize_t tif_rawdataloaded; /* amount of data in rawdata */
* setting up an old tag extension scheme. */ uint8_t *tif_rawcp; /* current spot in raw buffer */
TIFFFieldArray* tif_fieldscompat; tmsize_t tif_rawcc; /* bytes unread from raw buffer */
size_t tif_nfieldscompat; /* memory-mapped file support */
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 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)x < (0xffffffff - (uint32)(y-1))) ? \ #define TIFFhowmany_32(x, y) \
((((uint32)(x))+(((uint32)(y))-1))/((uint32)(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)(x) / (uint32)(y)) + ((((uint32)(x) % (uint32)(y)) != 0) ? 1 : 0)) (((uint32_t)(x) / (uint32_t)(y)) + \
#define TIFFhowmany8_32(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(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)(x))+(((uint64)(y))-1))/((uint64)(y))) (((x)&0x07) ? ((uint32_t)(x) >> 3) + 1 : (uint32_t)(x) >> 3)
#define TIFFhowmany8_64(x) (((x)&0x07)?((uint64)(x)>>3)+1:(uint64)(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.
@ -301,28 +327,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
@ -331,7 +360,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
@ -339,139 +369,155 @@ 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* pp, tmsize_t cc, uint16 s); const char *mode, const char *module);
extern int _TIFFNoStripEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s); extern int _TIFFNoRowEncode(TIFF *tif, uint8_t *pp, tmsize_t cc,
extern int _TIFFNoTileEncode(TIFF*, uint8* pp, tmsize_t cc, uint16 s); uint16_t s);
extern int _TIFFNoRowDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s); extern int _TIFFNoStripEncode(TIFF *tif, uint8_t *pp, tmsize_t cc,
extern int _TIFFNoStripDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s); uint16_t s);
extern int _TIFFNoTileDecode(TIFF*, uint8* pp, tmsize_t cc, uint16 s); extern int _TIFFNoTileEncode(TIFF *, uint8_t *pp, tmsize_t cc, uint16_t s);
extern void _TIFFNoPostDecode(TIFF* tif, uint8* buf, tmsize_t cc); extern int _TIFFNoRowDecode(TIFF *tif, uint8_t *pp, tmsize_t cc,
extern int _TIFFNoPreCode(TIFF* tif, uint16 s); uint16_t s);
extern int _TIFFNoSeek(TIFF* tif, uint32 off); extern int _TIFFNoStripDecode(TIFF *tif, uint8_t *pp, tmsize_t cc,
extern void _TIFFSwab16BitData(TIFF* tif, uint8* buf, tmsize_t cc); uint16_t s);
extern void _TIFFSwab24BitData(TIFF* tif, uint8* buf, tmsize_t cc); extern int _TIFFNoTileDecode(TIFF *, uint8_t *pp, tmsize_t cc, uint16_t s);
extern void _TIFFSwab32BitData(TIFF* tif, uint8* buf, tmsize_t cc); extern void _TIFFNoPostDecode(TIFF *tif, uint8_t *buf, tmsize_t cc);
extern void _TIFFSwab64BitData(TIFF* tif, uint8* 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, 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 _TIFFDefaultStripSize(TIFF* tif, uint32 s); extern int TIFFDefaultDirectory(TIFF *tif);
extern void _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th); extern void _TIFFSetDefaultCompressionState(TIFF *tif);
extern int _TIFFDataSize(TIFFDataType type); 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);
/*--: Rational2Double: Return size of TIFFSetGetFieldType in bytes. */ extern void _TIFFsetByteArray(void **, const void *, uint32_t);
extern int _TIFFSetGetFieldSize(TIFFSetGetFieldType setgettype); extern void _TIFFsetByteArrayExt(TIFF *, void **, const void *, uint32_t);
extern void _TIFFsetShortArray(uint16_t **, const uint16_t *, uint32_t);
extern void _TIFFsetShortArrayExt(TIFF *, uint16_t **, const uint16_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 _TIFFsetByteArray(void**, void*, uint32); extern void _TIFFprintAscii(FILE *, const char *);
extern void _TIFFsetString(char**, char*); extern void _TIFFprintAsciiTag(FILE *, const char *, const char *);
extern void _TIFFsetShortArray(uint16**, uint16*, uint32);
extern void _TIFFsetLongArray(uint32**, uint32*, uint32);
extern void _TIFFsetFloatArray(float**, float*, uint32);
extern void _TIFFsetDoubleArray(double**, double*, uint32);
extern void _TIFFprintAscii(FILE*, const char*); extern TIFFErrorHandler _TIFFwarningHandler;
extern void _TIFFprintAsciiTag(FILE*, const char*, const char*); extern TIFFErrorHandler _TIFFerrorHandler;
extern TIFFErrorHandlerExt _TIFFwarningHandlerExt;
extern TIFFErrorHandlerExt _TIFFerrorHandlerExt;
void _TIFFErrorEarly(TIFFOpenOptions *opts, thandle_t clientdata,
const char *module, const char *fmt, ...)
TIFF_ATTRIBUTE((__format__(__printf__, 4, 5)));
extern TIFFErrorHandler _TIFFwarningHandler; extern uint32_t _TIFFMultiply32(TIFF *, uint32_t, uint32_t, const char *);
extern TIFFErrorHandler _TIFFerrorHandler; extern uint64_t _TIFFMultiply64(TIFF *, uint64_t, uint64_t, const char *);
extern TIFFErrorHandlerExt _TIFFwarningHandlerExt; extern tmsize_t _TIFFMultiplySSize(TIFF *, tmsize_t, tmsize_t,
extern TIFFErrorHandlerExt _TIFFerrorHandlerExt; const char *);
extern tmsize_t _TIFFCastUInt64ToSSize(TIFF *, uint64_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 uint32 _TIFFMultiply32(TIFF*, uint32, uint32, const char*); extern double _TIFFUInt64ToDouble(uint64_t);
extern uint64 _TIFFMultiply64(TIFF*, uint64, uint64, const char*); extern float _TIFFUInt64ToFloat(uint64_t);
extern tmsize_t _TIFFMultiplySSize(TIFF*, tmsize_t, tmsize_t, const char*);
extern tmsize_t _TIFFCastUInt64ToSSize(TIFF*, uint64, 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); extern float _TIFFClampDoubleToFloat(double);
extern float _TIFFUInt64ToFloat(uint64); extern uint32_t _TIFFClampDoubleToUInt32(double);
extern float _TIFFClampDoubleToFloat(double); extern void _TIFFCleanupIFDOffsetAndNumberMaps(TIFF *tif);
extern tmsize_t extern tmsize_t _TIFFReadEncodedStripAndAllocBuffer(TIFF *tif,
_TIFFReadEncodedStripAndAllocBuffer(TIFF* tif, uint32 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 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 x, uint32 y, uint32 z, uint16 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
#ifdef LERC_SUPPORT
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
#ifdef VMS
extern const TIFFCodec _TIFFBuiltinCODECS[];
#else
extern TIFFCodec _TIFFBuiltinCODECS[];
#endif #endif
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:
*/

9
3rdparty/libtiff/tiffvers.h vendored
View File

@ -1,9 +0,0 @@
#define TIFFLIB_VERSION_STR "LIBTIFF, Version 4.2.0\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
/*
* This define can be used in code that requires
* compilation-related definitions specific to a
* version or versions of the library. Runtime
* version checking should be done based on the
* string returned by TIFFGetVersion.
*/
#define TIFFLIB_VERSION 20201219

36
3rdparty/libtiff/tiffvers.h.cmake.in vendored Normal file
View File

@ -0,0 +1,36 @@
/* tiffvers.h version information is updated according to version information
* in configure.ac */
/* clang-format off */
/* clang-format disabled because FindTIFF.cmake is very sensitive to the
* formatting of below line being a single line.
* Furthermore, configure_file variables of type "@VAR@" are
* modified by clang-format and won't be substituted by CMake.
*/
#define TIFFLIB_VERSION_STR "LIBTIFF, Version @LIBTIFF_VERSION@\nCopyright (c) 1988-1996 Sam Leffler\nCopyright (c) 1991-1996 Silicon Graphics, Inc."
/*
* This define can be used in code that requires
* compilation-related definitions specific to a
* version or versions of the library. Runtime
* version checking should be done based on the
* string returned by TIFFGetVersion.
*/
#define TIFFLIB_VERSION @LIBTIFF_RELEASE_DATE@
/* The following defines have been added in 4.5.0 */
#define TIFFLIB_MAJOR_VERSION @LIBTIFF_MAJOR_VERSION@
#define TIFFLIB_MINOR_VERSION @LIBTIFF_MINOR_VERSION@
#define TIFFLIB_MICRO_VERSION @LIBTIFF_MICRO_VERSION@
#define TIFFLIB_VERSION_STR_MAJ_MIN_MIC "@LIBTIFF_VERSION@"
/* 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
3rdparty/libtiff/uvcode.h vendored
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:
*/

50
modules/imgcodecs/src/grfmt_tiff.cpp
View File

@ -60,6 +60,16 @@ namespace tiff_dummy_namespace {
} }
using namespace tiff_dummy_namespace; using namespace tiff_dummy_namespace;
#ifndef _MSC_VER
namespace numeric_types = tiff_dummy_namespace;
#else
#include <cstdint>
namespace numeric_types {
using uint16 = std::uint16_t;
using uint32 = std::uint32_t;
}
#endif
namespace cv namespace cv
{ {
@ -264,8 +274,8 @@ bool TiffDecoder::readHeader()
if (tif) if (tif)
{ {
uint32 wdth = 0, hght = 0; numeric_types::uint32 wdth = 0, hght = 0;
uint16 photometric = 0; numeric_types::uint16 photometric = 0;
CV_TIFF_CHECK_CALL(TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &wdth)); CV_TIFF_CHECK_CALL(TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &wdth));
CV_TIFF_CHECK_CALL(TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &hght)); CV_TIFF_CHECK_CALL(TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &hght));
@ -273,7 +283,7 @@ bool TiffDecoder::readHeader()
{ {
bool isGrayScale = photometric == PHOTOMETRIC_MINISWHITE || photometric == PHOTOMETRIC_MINISBLACK; bool isGrayScale = photometric == PHOTOMETRIC_MINISWHITE || photometric == PHOTOMETRIC_MINISBLACK;
uint16 bpp = 8, ncn = isGrayScale ? 1 : 3; numeric_types::uint16 bpp = 8, ncn = isGrayScale ? 1 : 3;
if (0 == TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bpp)) if (0 == TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bpp))
{ {
// TIFF bi-level images don't require TIFFTAG_BITSPERSAMPLE tag // TIFF bi-level images don't require TIFFTAG_BITSPERSAMPLE tag
@ -296,7 +306,7 @@ bool TiffDecoder::readHeader()
(ncn != 1 && ncn != 3 && ncn != 4))) (ncn != 1 && ncn != 3 && ncn != 4)))
bpp = 8; bpp = 8;
uint16 sample_format = SAMPLEFORMAT_UINT; numeric_types::uint16 sample_format = SAMPLEFORMAT_UINT;
TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &sample_format); TIFFGetField(tif, TIFFTAG_SAMPLEFORMAT, &sample_format);
int wanted_channels = normalizeChannelsNumber(ncn); int wanted_channels = normalizeChannelsNumber(ncn);
switch (bpp) switch (bpp)
@ -378,7 +388,7 @@ bool TiffDecoder::nextPage()
readHeader(); readHeader();
} }
static void fixOrientationPartial(Mat &img, uint16 orientation) static void fixOrientationPartial(Mat &img, numeric_types::uint16 orientation)
{ {
switch(orientation) { switch(orientation) {
case ORIENTATION_RIGHTTOP: case ORIENTATION_RIGHTTOP:
@ -434,7 +444,7 @@ static void fixOrientationFull(Mat &img, int orientation)
* For 8 bit some corrections are done by TIFFReadRGBAStrip/Tile already. * For 8 bit some corrections are done by TIFFReadRGBAStrip/Tile already.
* Not so for 16/32/64 bit. * Not so for 16/32/64 bit.
*/ */
static void fixOrientation(Mat &img, uint16 orientation, bool isOrientationFull) static void fixOrientation(Mat &img, numeric_types::uint16 orientation, bool isOrientationFull)
{ {
if( isOrientationFull ) if( isOrientationFull )
{ {
@ -595,7 +605,7 @@ bool TiffDecoder::readData( Mat& img )
CV_Assert(!m_tif.empty()); CV_Assert(!m_tif.empty());
TIFF* tif = (TIFF*)m_tif.get(); TIFF* tif = (TIFF*)m_tif.get();
uint16 photometric = (uint16)-1; numeric_types::uint16 photometric = (numeric_types::uint16)-1;
CV_TIFF_CHECK_CALL(TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric)); CV_TIFF_CHECK_CALL(TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric));
if (m_hdr && depth >= CV_32F) if (m_hdr && depth >= CV_32F)
@ -611,14 +621,14 @@ bool TiffDecoder::readData( Mat& img )
{ {
int is_tiled = TIFFIsTiled(tif) != 0; int is_tiled = TIFFIsTiled(tif) != 0;
bool isGrayScale = photometric == PHOTOMETRIC_MINISWHITE || photometric == PHOTOMETRIC_MINISBLACK; bool isGrayScale = photometric == PHOTOMETRIC_MINISWHITE || photometric == PHOTOMETRIC_MINISBLACK;
uint16 bpp = 8, ncn = isGrayScale ? 1 : 3; numeric_types::uint16 bpp = 8, ncn = isGrayScale ? 1 : 3;
if (0 == TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bpp)) if (0 == TIFFGetField(tif, TIFFTAG_BITSPERSAMPLE, &bpp))
{ {
// TIFF bi-level images don't require TIFFTAG_BITSPERSAMPLE tag // TIFF bi-level images don't require TIFFTAG_BITSPERSAMPLE tag
bpp = 1; bpp = 1;
} }
CV_TIFF_CHECK_CALL_DEBUG(TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &ncn)); CV_TIFF_CHECK_CALL_DEBUG(TIFFGetField(tif, TIFFTAG_SAMPLESPERPIXEL, &ncn));
uint16 img_orientation = ORIENTATION_TOPLEFT; numeric_types::uint16 img_orientation = ORIENTATION_TOPLEFT;
CV_TIFF_CHECK_CALL_DEBUG(TIFFGetField(tif, TIFFTAG_ORIENTATION, &img_orientation)); CV_TIFF_CHECK_CALL_DEBUG(TIFFGetField(tif, TIFFTAG_ORIENTATION, &img_orientation));
constexpr const int bitsPerByte = 8; constexpr const int bitsPerByte = 8;
int dst_bpp = (int)(img.elemSize1() * bitsPerByte); int dst_bpp = (int)(img.elemSize1() * bitsPerByte);
@ -628,7 +638,7 @@ bool TiffDecoder::readData( Mat& img )
int wanted_channels = normalizeChannelsNumber(img.channels()); int wanted_channels = normalizeChannelsNumber(img.channels());
bool doReadScanline = false; bool doReadScanline = false;
uint32 tile_width0 = m_width, tile_height0 = 0; numeric_types::uint32 tile_width0 = m_width, tile_height0 = 0;
if (is_tiled) if (is_tiled)
{ {
@ -646,7 +656,7 @@ bool TiffDecoder::readData( Mat& img )
tile_width0 = m_width; tile_width0 = m_width;
if (tile_height0 == 0 || if (tile_height0 == 0 ||
(!is_tiled && tile_height0 == std::numeric_limits<uint32>::max()) ) (!is_tiled && tile_height0 == std::numeric_limits<numeric_types::uint32>::max()) )
tile_height0 = m_height; tile_height0 = m_height;
const int TILE_MAX_WIDTH = (1 << 24); const int TILE_MAX_WIDTH = (1 << 24);
@ -671,7 +681,7 @@ bool TiffDecoder::readData( Mat& img )
( (uint64_t) MAX_TILE_SIZE * 95 / 100) ( (uint64_t) MAX_TILE_SIZE * 95 / 100)
) )
{ {
uint16_t planerConfig = (uint16)-1; uint16_t planerConfig = (numeric_types::uint16)-1;
CV_TIFF_CHECK_CALL(TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &planerConfig)); CV_TIFF_CHECK_CALL(TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &planerConfig));
doReadScanline = (!is_tiled) // no tile doReadScanline = (!is_tiled) // no tile
@ -727,7 +737,7 @@ bool TiffDecoder::readData( Mat& img )
MAX_TILE_SIZE * 95 / 100 MAX_TILE_SIZE * 95 / 100
) )
{ {
uint16_t planerConfig = (uint16)-1; uint16_t planerConfig = (numeric_types::uint16)-1;
CV_TIFF_CHECK_CALL(TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &planerConfig)); CV_TIFF_CHECK_CALL(TIFFGetField(tif, TIFFTAG_PLANARCONFIG, &planerConfig));
doReadScanline = (!is_tiled) // no tile doReadScanline = (!is_tiled) // no tile
@ -811,7 +821,7 @@ bool TiffDecoder::readData( Mat& img )
uchar* bstart = src_buffer; uchar* bstart = src_buffer;
if (doReadScanline) if (doReadScanline)
{ {
CV_TIFF_CHECK_CALL((int)TIFFReadScanline(tif, (uint32*)src_buffer, y) >= 0); CV_TIFF_CHECK_CALL((int)TIFFReadScanline(tif, (numeric_types::uint32*)src_buffer, y) >= 0);
if ( isNeedConvert16to8 ) if ( isNeedConvert16to8 )
{ {
@ -833,11 +843,11 @@ bool TiffDecoder::readData( Mat& img )
} }
else if (!is_tiled) else if (!is_tiled)
{ {
CV_TIFF_CHECK_CALL(TIFFReadRGBAStrip(tif, y, (uint32*)src_buffer)); CV_TIFF_CHECK_CALL(TIFFReadRGBAStrip(tif, y, (numeric_types::uint32*)src_buffer));
} }
else else
{ {
CV_TIFF_CHECK_CALL(TIFFReadRGBATile(tif, x, y, (uint32*)src_buffer)); CV_TIFF_CHECK_CALL(TIFFReadRGBATile(tif, x, y, (numeric_types::uint32*)src_buffer));
// Tiles fill the buffer from the bottom up // Tiles fill the buffer from the bottom up
bstart += (tile_height0 - tile_height) * tile_width0 * 4; bstart += (tile_height0 - tile_height) * tile_width0 * 4;
} }
@ -931,15 +941,15 @@ bool TiffDecoder::readData( Mat& img )
{ {
if (doReadScanline) if (doReadScanline)
{ {
CV_TIFF_CHECK_CALL((int)TIFFReadScanline(tif, (uint32*)src_buffer, y) >= 0); CV_TIFF_CHECK_CALL((int)TIFFReadScanline(tif, (numeric_types::uint32*)src_buffer, y) >= 0);
} }
else if (!is_tiled) else if (!is_tiled)
{ {
CV_TIFF_CHECK_CALL((int)TIFFReadEncodedStrip(tif, tileidx, (uint32*)src_buffer, src_buffer_size) >= 0); CV_TIFF_CHECK_CALL((int)TIFFReadEncodedStrip(tif, tileidx, (numeric_types::uint32*)src_buffer, src_buffer_size) >= 0);
} }
else else
{ {
CV_TIFF_CHECK_CALL((int)TIFFReadEncodedTile(tif, tileidx, (uint32*)src_buffer, src_buffer_size) >= 0); CV_TIFF_CHECK_CALL((int)TIFFReadEncodedTile(tif, tileidx, (numeric_types::uint32*)src_buffer, src_buffer_size) >= 0);
} }
for (int i = 0; i < tile_height; i++) for (int i = 0; i < tile_height; i++)
@ -1256,7 +1266,7 @@ bool TiffEncoder::writeLibTiff( const std::vector<Mat>& img_vec, const std::vect
int page_compression = compression; int page_compression = compression;
int bitsPerChannel = -1; int bitsPerChannel = -1;
uint16 sample_format = SAMPLEFORMAT_INT; numeric_types::uint16 sample_format = SAMPLEFORMAT_INT;
switch (depth) switch (depth)
{ {
case CV_8U: case CV_8U: