mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-06-10 19:24:07 +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()

4819
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

10
3rdparty/libtiff/t4.h vendored
View File

@ -30,7 +30,8 @@
* 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 length; /* bit length of g3 code */
unsigned short code; /* g3 code */ unsigned short code; /* g3 code */
short runlen; /* run length in bits */ short runlen; /* run length in bits */
@ -281,10 +282,3 @@ 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:
*/

263
3rdparty/libtiff/tif_aux.c vendored
View File

@ -27,42 +27,45 @@
* *
* 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); {
TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
return 0; return 0;
} }
return first * second; return first * second;
} }
uint64 uint64_t _TIFFMultiply64(TIFF *tif, uint64_t first, uint64_t second,
_TIFFMultiply64(TIFF* tif, uint64 first, uint64 second, const char* where) const char *where)
{ {
if (second && first > TIFF_UINT64_MAX / second) { if (second && first > UINT64_MAX / second)
TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where); {
TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
return 0; return 0;
} }
return first * second; return first * second;
} }
tmsize_t tmsize_t _TIFFMultiplySSize(TIFF *tif, tmsize_t first, tmsize_t second,
_TIFFMultiplySSize(TIFF* tif, tmsize_t first, tmsize_t second, const char* where) const char *where)
{ {
if (first <= 0 || second <= 0) if (first <= 0 || second <= 0)
{ {
if (tif != NULL && where != NULL) 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;
} }
@ -71,30 +74,28 @@ _TIFFMultiplySSize(TIFF* tif, tmsize_t first, tmsize_t second, const char* where
{ {
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);
@ -103,29 +104,30 @@ _TIFFCheckRealloc(TIFF* tif, void* buffer,
*/ */
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, {
TIFFErrorExtR(tif, tif->tif_name,
"Failed to allocate memory for %s " "Failed to allocate memory for %s "
"(%ld elements of %ld bytes each)", "(%" TIFF_SSIZE_FORMAT " elements of %" TIFF_SSIZE_FORMAT
what,(long) nmemb, (long) elem_size); " 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;
@ -133,22 +135,24 @@ TIFFDefaultTransferFunction(TIFFDirectory* td)
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.); double t = (double)i / ((double)n - 1.);
tf[0][i] = (uint16)floor(65535.*pow(t, 2.2) + .5); 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); {
tf[1] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
if (tf[1] == NULL) if (tf[1] == NULL)
goto bad; goto bad;
_TIFFmemcpy(tf[1], tf[0], nbytes); _TIFFmemcpy(tf[1], tf[0], nbytes);
tf[2] = (uint16 *)_TIFFmalloc(nbytes); tf[2] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
if (tf[2] == NULL) if (tf[2] == NULL)
goto bad; goto bad;
_TIFFmemcpy(tf[2], tf[0], nbytes); _TIFFmemcpy(tf[2], tf[0], nbytes);
@ -157,24 +161,24 @@ TIFFDefaultTransferFunction(TIFFDirectory* td)
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 * YCbCr (Class Y) images must have the ReferenceBlackWhite
* tag set. Fix the broken images, which lacks that tag. * tag set. Fix the broken images, which lacks that tag.
@ -183,11 +187,14 @@ TIFFDefaultRefBlackWhite(TIFFDirectory* td)
td->td_refblackwhite[1] = td->td_refblackwhite[3] = td->td_refblackwhite[1] = td->td_refblackwhite[3] =
td->td_refblackwhite[5] = 255.0F; td->td_refblackwhite[5] = 255.0F;
td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0F; td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0F;
} else { }
else
{
/* /*
* Assume RGB (Class R) * Assume RGB (Class R)
*/ */
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++)
{
td->td_refblackwhite[2 * i + 0] = 0; td->td_refblackwhite[2 * i + 0] = 0;
td->td_refblackwhite[2 * i + 1] = td->td_refblackwhite[2 * i + 1] =
(float)((1L << td->td_bitspersample) - 1L); (float)((1L << td->td_bitspersample) - 1L);
@ -204,90 +211,115 @@ 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: case TIFFTAG_SUBFILETYPE:
*va_arg(ap, uint32 *) = td->td_subfiletype; *va_arg(ap, uint32_t *) = td->td_subfiletype;
return (1); return (1);
case TIFFTAG_BITSPERSAMPLE: case TIFFTAG_BITSPERSAMPLE:
*va_arg(ap, uint16 *) = td->td_bitspersample; *va_arg(ap, uint16_t *) = td->td_bitspersample;
return (1); return (1);
case TIFFTAG_THRESHHOLDING: case TIFFTAG_THRESHHOLDING:
*va_arg(ap, uint16 *) = td->td_threshholding; *va_arg(ap, uint16_t *) = td->td_threshholding;
return (1); return (1);
case TIFFTAG_FILLORDER: case TIFFTAG_FILLORDER:
*va_arg(ap, uint16 *) = td->td_fillorder; *va_arg(ap, uint16_t *) = td->td_fillorder;
return (1); return (1);
case TIFFTAG_ORIENTATION: case TIFFTAG_ORIENTATION:
*va_arg(ap, uint16 *) = td->td_orientation; *va_arg(ap, uint16_t *) = td->td_orientation;
return (1); return (1);
case TIFFTAG_SAMPLESPERPIXEL: case TIFFTAG_SAMPLESPERPIXEL:
*va_arg(ap, uint16 *) = td->td_samplesperpixel; *va_arg(ap, uint16_t *) = td->td_samplesperpixel;
return (1); return (1);
case TIFFTAG_ROWSPERSTRIP: case TIFFTAG_ROWSPERSTRIP:
*va_arg(ap, uint32 *) = td->td_rowsperstrip; *va_arg(ap, uint32_t *) = td->td_rowsperstrip;
return (1); return (1);
case TIFFTAG_MINSAMPLEVALUE: case TIFFTAG_MINSAMPLEVALUE:
*va_arg(ap, uint16 *) = td->td_minsamplevalue; *va_arg(ap, uint16_t *) = td->td_minsamplevalue;
return (1); return (1);
case TIFFTAG_MAXSAMPLEVALUE: case TIFFTAG_MAXSAMPLEVALUE:
*va_arg(ap, uint16 *) = td->td_maxsamplevalue; {
uint16_t maxsamplevalue;
/* td_bitspersample=1 is always set in TIFFDefaultDirectory().
* Therefore, td_maxsamplevalue has to be re-calculated in
* 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); return (1);
}
case TIFFTAG_PLANARCONFIG: case TIFFTAG_PLANARCONFIG:
*va_arg(ap, uint16 *) = td->td_planarconfig; *va_arg(ap, uint16_t *) = td->td_planarconfig;
return (1); return (1);
case TIFFTAG_RESOLUTIONUNIT: case TIFFTAG_RESOLUTIONUNIT:
*va_arg(ap, uint16 *) = td->td_resolutionunit; *va_arg(ap, uint16_t *) = td->td_resolutionunit;
return (1); return (1);
case TIFFTAG_PREDICTOR: case TIFFTAG_PREDICTOR:
{ {
TIFFPredictorState *sp = (TIFFPredictorState *)tif->tif_data; TIFFPredictorState *sp = (TIFFPredictorState *)tif->tif_data;
if (sp == NULL) if (sp == NULL)
{ {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, TIFFErrorExtR(
tif, tif->tif_name,
"Cannot get \"Predictor\" tag as plugin is not configured"); "Cannot get \"Predictor\" tag as plugin is not configured");
*va_arg(ap, uint16*) = 0; *va_arg(ap, uint16_t *) = 0;
return 0; return 0;
} }
*va_arg(ap, uint16*) = (uint16) sp->predictor; *va_arg(ap, uint16_t *) = (uint16_t)sp->predictor;
return 1; return 1;
} }
case TIFFTAG_DOTRANGE: case TIFFTAG_DOTRANGE:
*va_arg(ap, uint16 *) = 0; *va_arg(ap, uint16_t *) = 0;
*va_arg(ap, uint16 *) = (1<<td->td_bitspersample)-1; *va_arg(ap, uint16_t *) = (1 << td->td_bitspersample) - 1;
return (1); return (1);
case TIFFTAG_INKSET: case TIFFTAG_INKSET:
*va_arg(ap, uint16 *) = INKSET_CMYK; *va_arg(ap, uint16_t *) = INKSET_CMYK;
return 1; return 1;
case TIFFTAG_NUMBEROFINKS: case TIFFTAG_NUMBEROFINKS:
*va_arg(ap, uint16 *) = 4; *va_arg(ap, uint16_t *) = 4;
return (1); return (1);
case TIFFTAG_EXTRASAMPLES: case TIFFTAG_EXTRASAMPLES:
*va_arg(ap, uint16 *) = td->td_extrasamples; *va_arg(ap, uint16_t *) = td->td_extrasamples;
*va_arg(ap, const uint16 **) = td->td_sampleinfo; *va_arg(ap, const uint16_t **) = td->td_sampleinfo;
return (1); return (1);
case TIFFTAG_MATTEING: case TIFFTAG_MATTEING:
*va_arg(ap, uint16 *) = *va_arg(ap, uint16_t *) =
(td->td_extrasamples == 1 && (td->td_extrasamples == 1 &&
td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA); td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
return (1); return (1);
case TIFFTAG_TILEDEPTH: case TIFFTAG_TILEDEPTH:
*va_arg(ap, uint32 *) = td->td_tiledepth; *va_arg(ap, uint32_t *) = td->td_tiledepth;
return (1); return (1);
case TIFFTAG_DATATYPE: case TIFFTAG_DATATYPE:
*va_arg(ap, uint16 *) = td->td_sampleformat-1; *va_arg(ap, uint16_t *) = td->td_sampleformat - 1;
return (1); return (1);
case TIFFTAG_SAMPLEFORMAT: case TIFFTAG_SAMPLEFORMAT:
*va_arg(ap, uint16 *) = td->td_sampleformat; *va_arg(ap, uint16_t *) = td->td_sampleformat;
return (1); return (1);
case TIFFTAG_IMAGEDEPTH: case TIFFTAG_IMAGEDEPTH:
*va_arg(ap, uint32 *) = td->td_imagedepth; *va_arg(ap, uint32_t *) = td->td_imagedepth;
return (1); return (1);
case TIFFTAG_YCBCRCOEFFICIENTS: case TIFFTAG_YCBCRCOEFFICIENTS:
{ {
@ -297,11 +329,11 @@ TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap)
return 1; return 1;
} }
case TIFFTAG_YCBCRSUBSAMPLING: case TIFFTAG_YCBCRSUBSAMPLING:
*va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[0]; *va_arg(ap, uint16_t *) = td->td_ycbcrsubsampling[0];
*va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[1]; *va_arg(ap, uint16_t *) = td->td_ycbcrsubsampling[1];
return (1); return (1);
case TIFFTAG_YCBCRPOSITIONING: case TIFFTAG_YCBCRPOSITIONING:
*va_arg(ap, uint16 *) = td->td_ycbcrpositioning; *va_arg(ap, uint16_t *) = td->td_ycbcrpositioning;
return (1); return (1);
case TIFFTAG_WHITEPOINT: case TIFFTAG_WHITEPOINT:
{ {
@ -310,25 +342,27 @@ TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap)
Technical Note tells that it should be CIE D50. */ Technical Note tells that it should be CIE D50. */
static const float whitepoint[] = { static const float whitepoint[] = {
D50_X0 / (D50_X0 + D50_Y0 + D50_Z0), D50_X0 / (D50_X0 + D50_Y0 + D50_Z0),
D50_Y0 / (D50_X0 + D50_Y0 + D50_Z0) D50_Y0 / (D50_X0 + D50_Y0 + D50_Z0)};
};
*va_arg(ap, const float **) = whitepoint; *va_arg(ap, const float **) = whitepoint;
return 1; return 1;
} }
case TIFFTAG_TRANSFERFUNCTION: case TIFFTAG_TRANSFERFUNCTION:
if (!td->td_transferfunction[0] && if (!td->td_transferfunction[0] &&
!TIFFDefaultTransferFunction(td)) { !TIFFDefaultTransferFunction(tif, td))
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "No space for \"TransferFunction\" tag"); {
TIFFErrorExtR(tif, tif->tif_name,
"No space for \"TransferFunction\" tag");
return (0); return (0);
} }
*va_arg(ap, const uint16 **) = td->td_transferfunction[0]; *va_arg(ap, const uint16_t **) = td->td_transferfunction[0];
if (td->td_samplesperpixel - td->td_extrasamples > 1) { 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]; *va_arg(ap, const uint16_t **) = td->td_transferfunction[1];
*va_arg(ap, const uint16_t **) = td->td_transferfunction[2];
} }
return (1); return (1);
case TIFFTAG_REFERENCEBLACKWHITE: case TIFFTAG_REFERENCEBLACKWHITE:
if (!td->td_refblackwhite && !TIFFDefaultRefBlackWhite(td)) if (!td->td_refblackwhite && !TIFFDefaultRefBlackWhite(tif, td))
return (0); return (0);
*va_arg(ap, const float **) = td->td_refblackwhite; *va_arg(ap, const float **) = td->td_refblackwhite;
return (1); return (1);
@ -340,8 +374,7 @@ TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap)
* 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;
@ -352,24 +385,28 @@ TIFFGetFieldDefaulted(TIFF* tif, uint32 tag, ...)
return (ok); return (ok);
} }
struct _Int64Parts { struct _Int64Parts
int32 low, high; {
int32_t low, high;
}; };
typedef union { typedef union
{
struct _Int64Parts part; struct _Int64Parts part;
int64 value; 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; return (float)i.value;
} else { }
else
{
long double df; long double df;
df = (long double)i.value; df = (long double)i.value;
df += 18446744073709551616.0; /* adding 2**64 */ df += 18446744073709551616.0; /* adding 2**64 */
@ -377,15 +414,17 @@ _TIFFUInt64ToFloat(uint64 ui64)
} }
} }
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; return (double)i.value;
} else { }
else
{
long double df; long double df;
df = (long double)i.value; df = (long double)i.value;
df += 18446744073709551616.0; /* adding 2**64 */ df += 18446744073709551616.0; /* adding 2**64 */
@ -402,18 +441,18 @@ float _TIFFClampDoubleToFloat( double val )
return (float)val; return (float)val;
} }
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) 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:
*/

84
3rdparty/libtiff/tif_close.c vendored
View File

@ -41,8 +41,7 @@
* @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).
@ -52,8 +51,7 @@ TIFFCleanup(TIFF* 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.
@ -63,44 +61,74 @@ TIFFCleanup(TIFF* tif)
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]; TIFFField *fld = tif->tif_fields[i];
if (fld->field_name != NULL)
{
if (fld->field_bit == FIELD_CUSTOM && if (fld->field_bit == FIELD_CUSTOM &&
strncmp("Tag ", fld->field_name, 4) == 0) { /* caution: tif_fields[i] must not be the beginning of a
_TIFFfree(fld->field_name); * fields-array. Otherwise the following tags are also freed
_TIFFfree(fld); * with the first free().
*/
TIFFFieldIsAnonymous(fld))
{
_TIFFfreeExt(tif, fld->field_name);
_TIFFfreeExt(tif, fld);
}
} }
} }
_TIFFfree(tif->tif_fields); _TIFFfreeExt(tif, tif->tif_fields);
} }
if (tif->tif_nfieldscompat > 0) { if (tif->tif_nfieldscompat > 0)
uint32 i; {
uint32_t i;
for (i = 0; i < tif->tif_nfieldscompat; i++) { for (i = 0; i < tif->tif_nfieldscompat; i++)
{
if (tif->tif_fieldscompat[i].allocated_size) if (tif->tif_fieldscompat[i].allocated_size)
_TIFFfree(tif->tif_fieldscompat[i].fields); _TIFFfreeExt(tif, tif->tif_fieldscompat[i].fields);
} }
_TIFFfree(tif->tif_fieldscompat); _TIFFfreeExt(tif, tif->tif_fieldscompat);
} }
_TIFFfree(tif); _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;
}
} }
/************************************************************************/ /************************************************************************/
@ -117,8 +145,9 @@ TIFFCleanup(TIFF* tif)
* @param tif A TIFF pointer. * @param tif A TIFF pointer.
*/ */
void void TIFFClose(TIFF *tif)
TIFFClose(TIFF* tif) {
if (tif != NULL)
{ {
TIFFCloseProc closeproc = tif->tif_closeproc; TIFFCloseProc closeproc = tif->tif_closeproc;
thandle_t fd = tif->tif_clientdata; thandle_t fd = tif->tif_clientdata;
@ -126,13 +155,4 @@ TIFFClose(TIFF* tif)
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:
*/

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

@ -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,11 +83,7 @@ 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
TIFFCodec _TIFFBuiltinCODECS[] = {
#endif
{"None", COMPRESSION_NONE, TIFFInitDumpMode}, {"None", COMPRESSION_NONE, TIFFInitDumpMode},
{"LZW", COMPRESSION_LZW, TIFFInitLZW}, {"LZW", COMPRESSION_LZW, TIFFInitLZW},
{"PackBits", COMPRESSION_PACKBITS, TIFFInitPackBits}, {"PackBits", COMPRESSION_PACKBITS, TIFFInitPackBits},
@ -105,24 +104,23 @@ TIFFCodec _TIFFBuiltinCODECS[] = {
{"LZMA", COMPRESSION_LZMA, TIFFInitLZMA}, {"LZMA", COMPRESSION_LZMA, TIFFInitLZMA},
{"ZSTD", COMPRESSION_ZSTD, TIFFInitZSTD}, {"ZSTD", COMPRESSION_ZSTD, TIFFInitZSTD},
{"WEBP", COMPRESSION_WEBP, TIFFInitWebP}, {"WEBP", COMPRESSION_WEBP, TIFFInitWebP},
{ NULL, 0, NULL } {"LERC", COMPRESSION_LERC, TIFFInitLERC},
}; {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);
TIFFErrorExtR(tif, tif->tif_name,
"%s compression support is not configured", "%s compression support is not configured",
c ? c->name : compression_code); c ? c->name : compression_code);
return (0); return (0);
} }
static int static int NotConfigured(TIFF *tif, int scheme)
NotConfigured(TIFF* tif, int scheme)
{ {
(void)scheme; (void)scheme;
@ -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) { if (codec->init == NULL)
{
return 0; return 0;
} }
if(codec->init != NotConfigured){ if (codec->init != NotConfigured)
{
return 1; return 1;
} }
return 0; return 0;
} }
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

131
3rdparty/libtiff/tif_color.c vendored
View File

@ -40,41 +40,54 @@
/* /*
* 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);
}
/*
* 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; float cby, tmp;
if( L < 8.856F ) { if (L < 8.856F)
{
*Y = (L * cielab->Y0) / 903.292F; *Y = (L * cielab->Y0) / 903.292F;
cby = 7.787F * (*Y / cielab->Y0) + 16.0F / 116.0F; cby = 7.787F * (*Y / cielab->Y0) + 16.0F / 116.0F;
} else { }
else
{
cby = (L + 16.0F) / 116.0F; cby = (L + 16.0F) / 116.0F;
*Y = cielab->Y0 * cby * cby * cby; *Y = cielab->Y0 * cby * cby * cby;
} }
tmp = (float)a / 500.0F + cby; tmp = (float)a / 256.0F / 500.0F + cby;
if (tmp < 0.2069F) if (tmp < 0.2069F)
*X = cielab->X0 * (tmp - 0.13793F) / 7.787F; *X = cielab->X0 * (tmp - 0.13793F) / 7.787F;
else else
*X = cielab->X0 * tmp * tmp * tmp; *X = cielab->X0 * tmp * tmp * tmp;
tmp = cby - (float)b / 200.0F; tmp = cby - (float)b / 256.0F / 200.0F;
if (tmp < 0.2069F) if (tmp < 0.2069F)
*Z = cielab->Z0 * (tmp - 0.13793F) / 7.787F; *Z = cielab->Z0 * (tmp - 0.13793F) / 7.787F;
else else
*Z = cielab->Z0 * tmp * tmp * tmp; *Z = cielab->Z0 * tmp * tmp * tmp;
} }
#define RINT(R) ((uint32)((R)>0?((R)+0.5):((R)-0.5))) #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;
@ -119,9 +132,8 @@ TIFFXYZToRGB(TIFFCIELabToRGB *cielab, float X, float Y, float Z,
* 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;
@ -134,27 +146,30 @@ TIFFCIELabToRGBInit(TIFFCIELabToRGB* cielab,
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 */
@ -171,17 +186,20 @@ TIFFCIELabToRGBInit(TIFFCIELabToRGB* cielab,
* 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)) / \
(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)) #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);
@ -190,8 +208,8 @@ TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32 Y, int32 Cb, int32 Cr,
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);
@ -230,8 +248,7 @@ 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;
@ -240,8 +257,9 @@ TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, float *luma, float *refBlackWhite)
#define LumaGreen luma[1] #define LumaGreen luma[1]
#define LumaBlue luma[2] #define LumaBlue luma[2]
clamptab = (TIFFRGBValue*)( clamptab =
(uint8*) ycbcr+TIFFroundup_32(sizeof (TIFFYCbCrToRGB), sizeof (long))); (TIFFRGBValue *)((uint8_t *)ycbcr +
TIFFroundup_32(sizeof(TIFFYCbCrToRGB), sizeof(long)));
_TIFFmemset(clamptab, 0, 256); /* v < 0 => 0 */ _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++)
@ -249,14 +267,19 @@ TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, float *luma, float *refBlackWhite)
_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;
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; int x;
#undef LumaBlue #undef LumaBlue
@ -270,20 +293,21 @@ TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, float *luma, float *refBlackWhite)
* tag) so there is some range shifting to do here when * tag) so there is some range shifting to do here when
* constructing tables indexed by the raw pixel data. * constructing tables indexed by the raw pixel data.
*/ */
for (i = 0, x = -128; i < 256; i++, x++) { for (i = 0, x = -128; i < 256; i++, x++)
int32 Cr = (int32)CLAMPw(Code2V(x, refBlackWhite[4] - 128.0F, {
int32_t Cr = (int32_t)CLAMPw(Code2V(x, refBlackWhite[4] - 128.0F,
refBlackWhite[5] - 128.0F, 127), refBlackWhite[5] - 128.0F, 127),
-128.0F * 32, 128.0F * 32); -128.0F * 32, 128.0F * 32);
int32 Cb = (int32)CLAMPw(Code2V(x, refBlackWhite[2] - 128.0F, int32_t Cb = (int32_t)CLAMPw(Code2V(x, refBlackWhite[2] - 128.0F,
refBlackWhite[3] - 128.0F, 127), refBlackWhite[3] - 128.0F, 127),
-128.0F * 32, 128.0F * 32); -128.0F * 32, 128.0F * 32);
ycbcr->Cr_r_tab[i] = (int32)((D1*Cr + ONE_HALF)>>SHIFT); ycbcr->Cr_r_tab[i] = (int32_t)((D1 * Cr + ONE_HALF) >> SHIFT);
ycbcr->Cb_b_tab[i] = (int32)((D3*Cb + ONE_HALF)>>SHIFT); ycbcr->Cb_b_tab[i] = (int32_t)((D3 * Cb + ONE_HALF) >> SHIFT);
ycbcr->Cr_g_tab[i] = D2 * Cr; ycbcr->Cr_g_tab[i] = D2 * Cr;
ycbcr->Cb_g_tab[i] = D4 * Cb + ONE_HALF; ycbcr->Cb_g_tab[i] = D4 * Cb + ONE_HALF;
ycbcr->Y_tab[i] = ycbcr->Y_tab[i] = (int32_t)CLAMPw(
(int32)CLAMPw(Code2V(x + 128, refBlackWhite[0], refBlackWhite[1], 255), Code2V(x + 128, refBlackWhite[0], refBlackWhite[1], 255),
-128.0F * 32, 128.0F * 32); -128.0F * 32, 128.0F * 32);
} }
} }
@ -296,12 +320,3 @@ TIFFYCbCrToRGBInit(TIFFYCbCrToRGB* ycbcr, float *luma, float *refBlackWhite)
#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:
*/

184
3rdparty/libtiff/tif_compress.c vendored
View File

@ -29,109 +29,117 @@
*/ */
#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", {
TIFFErrorExtR(tif, tif->tif_name,
"Compression scheme %" PRIu16
" %s encoding is not implemented",
tif->tif_dir.td_compression, method); tif->tif_dir.td_compression, method);
} }
return (-1); 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;
(void)cc;
(void)s;
return (TIFFNoEncode(tif, "scanline")); 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;
(void)cc;
(void)s;
return (TIFFNoEncode(tif, "strip")); 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;
(void)cc;
(void)s;
return (TIFFNoEncode(tif, "tile")); 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
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, TIFFErrorExtR(tif, tif->tif_name,
"Compression scheme %u %s decoding is not implemented", "Compression scheme %" PRIu16
" %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;
(void)cc;
(void)s;
return (TIFFNoDecode(tif, "scanline")); 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;
(void)cc;
(void)s;
return (TIFFNoDecode(tif, "strip")); 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;
(void)cc;
(void)s;
return (TIFFNoDecode(tif, "tile")); 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;
(void)s;
return (1); return (1);
} }
static int _TIFFtrue(TIFF* tif) { (void) tif; return (1); } static int _TIFFtrue(TIFF *tif)
{
(void)tif;
return (1);
}
static void _TIFFvoid(TIFF *tif) { (void)tif; } static void _TIFFvoid(TIFF *tif) { (void)tif; }
void void _TIFFSetDefaultCompressionState(TIFF *tif)
_TIFFSetDefaultCompressionState(TIFF* tif)
{ {
tif->tif_fixuptags = _TIFFNoFixupTags; tif->tif_fixuptags = _TIFFNoFixupTags;
tif->tif_decodestatus = TRUE; tif->tif_decodestatus = TRUE;
@ -155,10 +163,9 @@ _TIFFSetDefaultCompressionState(TIFF* tif)
tif->tif_flags &= ~(TIFF_NOBITREV | TIFF_NOREADRAW); 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);
/* /*
@ -175,14 +182,14 @@ 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; struct _codec *next;
TIFFCodec *info; 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;
@ -196,22 +203,25 @@ TIFFFindCODEC(uint16 scheme)
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 { }
else
{
TIFFErrorExt(0, "TIFFRegisterCODEC", TIFFErrorExt(0, "TIFFRegisterCODEC",
"No space to register compression scheme %s", name); "No space to register compression scheme %s", name);
return NULL; return NULL;
@ -219,20 +229,21 @@ TIFFRegisterCODEC(uint16 scheme, const char* name, TIFFInitMethod init)
return (cd->info); 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; *pcd = cd->next;
_TIFFfree(cd); _TIFFfreeExt(NULL, cd);
return; return;
} }
TIFFErrorExt(0, "TIFFUnRegisterCODEC", TIFFErrorExt(0, "TIFFUnRegisterCODEC",
"Cannot remove compression scheme %s; not registered", c->name); "Cannot remove compression scheme %s; not registered",
c->name);
} }
/************************************************************************/ /************************************************************************/
@ -247,8 +258,7 @@ TIFFUnRegisterCODEC(TIFFCodec* c)
* 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;
@ -256,23 +266,28 @@ TIFFGetConfiguredCODECs()
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)
{
_TIFFfreeExt(NULL, codecs);
return NULL; return NULL;
} }
codecs = new_codecs; codecs = new_codecs;
_TIFFmemcpy(codecs + i - 1, cd->info, sizeof(TIFFCodec)); _TIFFmemcpy(codecs + i - 1, cd->info, sizeof(TIFFCodec));
i++; i++;
} }
for (c = _TIFFBuiltinCODECS; c->name; c++) { for (c = _TIFFBuiltinCODECS; c->name; c++)
if (TIFFIsCODECConfigured(c->scheme)) { {
new_codecs = (TIFFCodec *) if (TIFFIsCODECConfigured(c->scheme))
_TIFFrealloc(codecs, i * sizeof(TIFFCodec)); {
if (!new_codecs) { new_codecs = (TIFFCodec *)_TIFFreallocExt(NULL, codecs,
_TIFFfree (codecs); i * sizeof(TIFFCodec));
if (!new_codecs)
{
_TIFFfreeExt(NULL, codecs);
return NULL; return NULL;
} }
codecs = new_codecs; codecs = new_codecs;
@ -281,9 +296,11 @@ TIFFGetConfiguredCODECs()
} }
} }
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)
{
_TIFFfreeExt(NULL, codecs);
return NULL; return NULL;
} }
codecs = new_codecs; codecs = new_codecs;
@ -291,12 +308,3 @@ TIFFGetConfiguredCODECs()
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

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

File diff suppressed because it is too large Load Diff

169
3rdparty/libtiff/tif_dir.h vendored
View File

@ -32,7 +32,8 @@
* ``Library-private'' Directory-related Definitions. * ``Library-private'' Directory-related Definitions.
*/ */
typedef struct { typedef struct
{
const TIFFField *info; const TIFFField *info;
int count; int count;
void *value; void *value;
@ -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;
uint32_t toff_long;
uint64_t toff_long8;
} tdir_offset; /* either offset or the data itself if fits */ } tdir_offset; /* either offset or the data itself if fits */
uint8 tdir_ignore; /* flag status to ignore tag when parsing tags in tif_dirread.c */ uint8_t tdir_ignore; /* flag status to ignore tag when parsing tags in
tif_dirread.c */
} TIFFDirEntry; } TIFFDirEntry;
/* /*
* Internal format of a TIFF directory entry. * Internal format of a TIFF directory entry.
*/ */
typedef struct { typedef struct
#define FIELD_SETLONGS 4 {
#define FIELDSET_ITEMS 4
/* bit vector of fields that are set */ /* bit vector of fields that are set */
unsigned long td_fieldsset[FIELD_SETLONGS]; 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;
/* /*
@ -174,11 +187,11 @@ typedef struct {
#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
* output file (by definition). The library also has express logic to always * output file (by definition). The library also has express logic to always
@ -189,9 +202,9 @@ typedef struct {
*/ */
#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))
@ -200,7 +213,8 @@ typedef struct {
#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_UNDEFINED = 0,
TIFF_SETGET_ASCII = 1, TIFF_SETGET_ASCII = 1,
TIFF_SETGET_UINT8 = 2, TIFF_SETGET_UINT8 = 2,
@ -256,7 +270,8 @@ typedef enum {
} TIFFSetGetFieldType; } TIFFSetGetFieldType;
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C"
{
#endif #endif
extern const TIFFFieldArray *_TIFFGetFields(void); extern const TIFFFieldArray *_TIFFGetFields(void);
@ -267,51 +282,59 @@ extern void _TIFFPrintFieldInfo(TIFF*, FILE*);
extern int _TIFFFillStriles(TIFF *); extern int _TIFFFillStriles(TIFF *);
typedef enum { typedef enum
{
tfiatImage, tfiatImage,
tfiatExif, tfiatExif,
tfiatGps, /* EXIF-GPS fields array type */ tfiatGps, /* EXIF-GPS fields array type */
tfiatOther tfiatOther
} TIFFFieldArrayType; } 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 */
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 */ TIFFField *fields; /* actual field info */
}; };
struct _TIFFField { struct _TIFFField
uint32 field_tag; /* field's tag */ {
uint32_t field_tag; /* field's tag */
short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */ short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */
short field_writecount; /* write count/TIFF_VARIABLE */ short field_writecount; /* write count/TIFF_VARIABLE */
TIFFDataType field_type; /* type of associated data */ TIFFDataType field_type; /* type of associated data */
uint32 reserved; /* reserved for future extension */ uint32_t
TIFFSetGetFieldType set_field_type; /* type to be passed to TIFFSetField */ field_anonymous; /* if true, this is a unknown / anonymous tag */
TIFFSetGetFieldType get_field_type; /* type to be passed to TIFFGetField */ TIFFSetGetFieldType
set_field_type; /* type to be passed to TIFFSetField */
TIFFSetGetFieldType
get_field_type; /* type to be passed to TIFFGetField */
unsigned short field_bit; /* bit in fieldsset bit vector */ unsigned short field_bit; /* bit in fieldsset bit vector */
unsigned char field_oktochange; /* if true, can change while writing */ unsigned char field_oktochange; /* if true, can change while writing */
unsigned char field_passcount; /* if true, pass dir count on set */ unsigned char field_passcount; /* if true, pass dir count on set */
char *field_name; /* ASCII name */ char *field_name; /* ASCII name */
TIFFFieldArray* field_subfields; /* if field points to child ifds, child ifd field definition array */ 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 TIFFField *_TIFFCreateAnonField(TIFF *, uint32_t, TIFFDataType);
extern int _TIFFCheckFieldIsValidForCodec(TIFF *tif, ttag_t tag); 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:
*/

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

49
3rdparty/libtiff/tif_dumpmode.c vendored
View File

@ -29,8 +29,7 @@
*/ */
#include "tiffiop.h" #include "tiffiop.h"
static int static int DumpFixupTags(TIFF *tif)
DumpFixupTags(TIFF* tif)
{ {
(void)tif; (void)tif;
return (1); return (1);
@ -39,11 +38,11 @@ DumpFixupTags(TIFF* tif)
/* /*
* 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;
@ -62,8 +61,7 @@ DumpModeEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
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);
@ -72,25 +70,17 @@ DumpModeEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s)
/* /*
* 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
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,
(signed long long) tif->tif_rawcc,
(signed long long) cc);
#endif
return (0); return (0);
} }
/* /*
@ -107,8 +97,7 @@ DumpModeDecode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
/* /*
* 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;
@ -118,8 +107,7 @@ DumpModeSeek(TIFF* tif, uint32 nrows)
/* /*
* 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;
@ -132,10 +120,3 @@ TIFFInitDumpMode(TIFF* tif, int scheme)
tif->tif_seek = DumpModeSeek; tif->tif_seek = DumpModeSeek;
return (1); return (1);
} }
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

84
3rdparty/libtiff/tif_error.c vendored
View File

@ -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); va_start(ap, fmt);
(*_TIFFerrorHandler)(module, fmt, ap); (*_TIFFerrorHandler)(module, fmt, ap);
va_end(ap); va_end(ap);
} }
if (_TIFFerrorHandlerExt) { if (_TIFFerrorHandlerExt)
{
va_start(ap, fmt); va_start(ap, fmt);
(*_TIFFerrorHandlerExt)(0, module, fmt, ap); (*_TIFFerrorHandlerExt)(0, module, fmt, ap);
va_end(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); va_start(ap, fmt);
(*_TIFFerrorHandler)(module, fmt, ap); (*_TIFFerrorHandler)(module, fmt, ap);
va_end(ap); va_end(ap);
} }
if (_TIFFerrorHandlerExt) { if (_TIFFerrorHandlerExt)
{
va_start(ap, fmt); va_start(ap, fmt);
(*_TIFFerrorHandlerExt)(fd, module, fmt, ap); (*_TIFFerrorHandlerExt)(fd, module, fmt, ap);
va_end(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);
}
}

16
3rdparty/libtiff/tif_extension.c vendored
View File

@ -39,13 +39,13 @@ int TIFFGetTagListCount( TIFF *tif )
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;
} }
@ -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 =
(TIFFClientInfoLink *)_TIFFmallocExt(tif, sizeof(TIFFClientInfoLink));
assert(psLink != NULL); 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:
*/

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

File diff suppressed because it is too large Load Diff

283
3rdparty/libtiff/tif_fax3.h vendored
View File

@ -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,20 +50,22 @@
* 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
@ -79,12 +81,16 @@ extern void _TIFFFax3fillruns(unsigned char*, uint32*, uint32*, uint32);
#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
*/
typedef struct
{ /* state table entry */
unsigned char State; /* see above */ unsigned char State; /* see above */
unsigned char Width; /* width of code in bits */ unsigned char Width; /* width of code in bits */
uint32 Param; /* unsigned 32-bit run length in bits (holds on 16 bit actually, but cannot be changed. See above warning) */ 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[];
@ -134,34 +140,50 @@ 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 < (n)) \
{ \
if (EndOfData()) \
{ \
if (BitsAvail == 0) /* no valid bits */ \ if (BitsAvail == 0) /* no valid bits */ \
goto eoflab; \ goto eoflab; \
BitsAvail = (n); /* pad with zeros */ \ BitsAvail = (n); /* pad with zeros */ \
} else { \ } \
BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail; \ else \
{ \
BitAcc |= ((uint32_t)bitmap[*cp++]) << BitsAvail; \
BitsAvail += 8; \ BitsAvail += 8; \
} \ } \
} \ } \
} while (0) } 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 < (n)) \
{ \
if (EndOfData()) \
{ \
if (BitsAvail == 0) /* no valid bits */ \ if (BitsAvail == 0) /* no valid bits */ \
goto eoflab; \ goto eoflab; \
BitsAvail = (n); /* pad with zeros */ \ BitsAvail = (n); /* pad with zeros */ \
} else { \ } \
BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail; \ else \
if ((BitsAvail += 8) < (n)) { \ { \
if (EndOfData()) { \ BitAcc |= ((uint32_t)bitmap[*cp++]) << BitsAvail; \
if ((BitsAvail += 8) < (n)) \
{ \
if (EndOfData()) \
{ \
/* NB: we know BitsAvail is non-zero here */ \ /* NB: we know BitsAvail is non-zero here */ \
BitsAvail = (n); /* pad with zeros */ \ BitsAvail = (n); /* pad with zeros */ \
} else { \ } \
BitAcc |= ((uint32) bitmap[*cp++])<<BitsAvail; \ else \
{ \
BitAcc |= ((uint32_t)bitmap[*cp++]) << BitsAvail; \
BitsAvail += 8; \ BitsAvail += 8; \
} \ } \
} \ } \
@ -170,29 +192,22 @@ extern const TIFFFaxTabEnt TIFFFaxBlackTable[];
} while (0) } 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) \
do \
{ \
BitsAvail -= (n); \ BitsAvail -= (n); \
BitAcc >>= (n); \ BitAcc >>= (n); \
} while (0) } 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) \
do \
{ \
int t; \ int t; \
NeedBits8(wid, eoflab); \ NeedBits8(wid, eoflab); \
TabEnt = tab + GetBits(wid); \ TabEnt = tab + GetBits(wid); \
@ -204,7 +219,9 @@ static const char* StateNames[] = {
fflush(stdout); \ fflush(stdout); \
ClrBits(TabEnt->Width); \ ClrBits(TabEnt->Width); \
} while (0) } while (0)
#define LOOKUP16(wid,tab,eoflab) do { \ #define LOOKUP16(wid, tab, eoflab) \
do \
{ \
int t; \ int t; \
NeedBits16(wid, eoflab); \ NeedBits16(wid, eoflab); \
TabEnt = tab + GetBits(wid); \ TabEnt = tab + GetBits(wid); \
@ -217,19 +234,25 @@ static const char* StateNames[] = {
ClrBits(TabEnt->Width); \ ClrBits(TabEnt->Width); \
} while (0) } while (0)
#define SETVALUE(x) do { \ #define SETVALUE(x) \
do \
{ \
*pa++ = RunLength + (x); \ *pa++ = RunLength + (x); \
printf("SETVALUE: %d\t%d\n", RunLength + (x), a0); \ printf("SETVALUE: %d\t%d\n", RunLength + (x), a0); \
a0 += x; \ a0 += x; \
RunLength = 0; \ RunLength = 0; \
} while (0) } while (0)
#else #else
#define LOOKUP8(wid,tab,eoflab) do { \ #define LOOKUP8(wid, tab, eoflab) \
do \
{ \
NeedBits8(wid, eoflab); \ NeedBits8(wid, eoflab); \
TabEnt = tab + GetBits(wid); \ TabEnt = tab + GetBits(wid); \
ClrBits(TabEnt->Width); \ ClrBits(TabEnt->Width); \
} while (0) } while (0)
#define LOOKUP16(wid,tab,eoflab) do { \ #define LOOKUP16(wid, tab, eoflab) \
do \
{ \
NeedBits16(wid, eoflab); \ NeedBits16(wid, eoflab); \
TabEnt = tab + GetBits(wid); \ TabEnt = tab + GetBits(wid); \
ClrBits(TabEnt->Width); \ ClrBits(TabEnt->Width); \
@ -239,10 +262,15 @@ static const char* StateNames[] = {
* 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) \
{ \
TIFFErrorExtR(tif, module, "Buffer overflow at line %u of %s %u", \
sp->line, isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile \
: tif->tif_curstrip); \
return (-1); \ return (-1); \
} \ } \
*pa++ = RunLength + (x); \ *pa++ = RunLength + (x); \
@ -261,16 +289,21 @@ 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 (;;) { \ { \
if (EOLcnt == 0) \
{ \
for (;;) \
{ \
NeedBits16(11, eoflab); \ NeedBits16(11, eoflab); \
if (GetBits(11) == 0) \ if (GetBits(11) == 0) \
break; \ break; \
ClrBits(1); \ ClrBits(1); \
} \ } \
} \ } \
for (;;) { \ for (;;) \
{ \
NeedBits8(8, eoflab); \ NeedBits8(8, eoflab); \
if (GetBits(8)) \ if (GetBits(8)) \
break; \ break; \
@ -287,20 +320,26 @@ static const char* StateNames[] = {
* 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() \
do \
{ \
if (RunLength) \ if (RunLength) \
SETVALUE(0); \ SETVALUE(0); \
if (a0 != lastx) { \ if (a0 != lastx) \
{ \
badlength(a0, lastx); \ badlength(a0, lastx); \
while (a0 > lastx && pa > thisrun) \ while (a0 > lastx && pa > thisrun) \
a0 -= *--pa; \ a0 -= *--pa; \
if (a0 < lastx) { \ if (a0 < lastx) \
{ \
if (a0 < 0) \ if (a0 < 0) \
a0 = 0; \ a0 = 0; \
if ((pa - thisrun) & 1) \ if ((pa - thisrun) & 1) \
SETVALUE(0); \ SETVALUE(0); \
SETVALUE(lastx - a0); \ SETVALUE(lastx - a0); \
} else if (a0 > lastx) { \ } \
else if (a0 > lastx) \
{ \
SETVALUE(lastx); \ SETVALUE(lastx); \
SETVALUE(0); \ SETVALUE(0); \
} \ } \
@ -319,11 +358,16 @@ 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 (;;) { \ { \
for (;;) \
{ \
for (;;) \
{ \
LOOKUP16(12, TIFFFaxWhiteTable, eof1d); \ LOOKUP16(12, TIFFFaxWhiteTable, eof1d); \
switch (TabEnt->State) { \ switch (TabEnt->State) \
{ \
case S_EOL: \ case S_EOL: \
EOLcnt = 1; \ EOLcnt = 1; \
goto done1d; \ goto done1d; \
@ -343,9 +387,11 @@ static const char* StateNames[] = {
doneWhite1d: \ doneWhite1d: \
if (a0 >= lastx) \ if (a0 >= lastx) \
goto done1d; \ goto done1d; \
for (;;) { \ for (;;) \
{ \
LOOKUP16(13, TIFFFaxBlackTable, eof1d); \ LOOKUP16(13, TIFFFaxBlackTable, eof1d); \
switch (TabEnt->State) { \ switch (TabEnt->State) \
{ \
case S_EOL: \ case S_EOL: \
EOLcnt = 1; \ EOLcnt = 1; \
goto done1d; \ goto done1d; \
@ -380,11 +426,18 @@ done1d: \
* 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) \
{ \
if (pb + 1 >= sp->refruns + sp->nruns) \
{ \
TIFFErrorExtR( \
tif, module, "Buffer overflow at line %u of %s %u", \
sp->line, isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \
return (-1); \ return (-1); \
} \ } \
b1 += pb[0] + pb[1]; \ b1 += pb[0] + pb[1]; \
@ -395,20 +448,32 @@ done1d: \
/* /*
* 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); \ { \
if (pa >= thisrun + sp->nruns) \
{ \
TIFFErrorExtR( \
tif, module, "Buffer overflow at line %u of %s %u", \
sp->line, isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \
return (-1); \ return (-1); \
} \ } \
LOOKUP8(7, TIFFFaxMainTable, eof2d); \ LOOKUP8(7, TIFFFaxMainTable, eof2d); \
switch (TabEnt->State) { \ switch (TabEnt->State) \
{ \
case S_Pass: \ case S_Pass: \
CHECK_b1; \ CHECK_b1; \
if( pb + 1 >= sp->refruns + sp->nruns) { \ if (pb + 1 >= sp->refruns + sp->nruns) \
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); \ TIFFErrorExtR(tif, module, \
"Buffer overflow at line %u of %s %u", \
sp->line, \
isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile \
: tif->tif_curstrip); \
return (-1); \ return (-1); \
} \ } \
b1 += *pb++; \ b1 += *pb++; \
@ -417,10 +482,13 @@ done1d: \
b1 += *pb++; \ b1 += *pb++; \
break; \ break; \
case S_Horiz: \ case S_Horiz: \
if ((pa-thisrun)&1) { \ if ((pa - thisrun) & 1) \
for (;;) { /* black first */ \ { \
for (;;) \
{ /* black first */ \
LOOKUP16(13, TIFFFaxBlackTable, eof2d); \ LOOKUP16(13, TIFFFaxBlackTable, eof2d); \
switch (TabEnt->State) { \ switch (TabEnt->State) \
{ \
case S_TermB: \ case S_TermB: \
SETVALUE(TabEnt->Param); \ SETVALUE(TabEnt->Param); \
goto doneWhite2da; \ goto doneWhite2da; \
@ -434,9 +502,11 @@ done1d: \
} \ } \
} \ } \
doneWhite2da:; \ doneWhite2da:; \
for (;;) { /* then white */ \ for (;;) \
{ /* then white */ \
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 doneBlack2da; \ goto doneBlack2da; \
@ -450,10 +520,14 @@ done1d: \
} \ } \
} \ } \
doneBlack2da:; \ doneBlack2da:; \
} else { \ } \
for (;;) { /* white first */ \ else \
{ \
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 doneWhite2db; \
@ -467,9 +541,11 @@ done1d: \
} \ } \
} \ } \
doneWhite2db:; \ doneWhite2db:; \
for (;;) { /* then black */ \ for (;;) \
{ /* then black */ \
LOOKUP16(13, TIFFFaxBlackTable, eof2d); \ LOOKUP16(13, TIFFFaxBlackTable, eof2d); \
switch (TabEnt->State) { \ switch (TabEnt->State) \
{ \
case S_TermB: \ case S_TermB: \
SETVALUE(TabEnt->Param); \ SETVALUE(TabEnt->Param); \
goto doneBlack2db; \ goto doneBlack2db; \
@ -489,9 +565,14 @@ done1d: \
case S_V0: \ case S_V0: \
CHECK_b1; \ CHECK_b1; \
SETVALUE(b1 - a0); \ SETVALUE(b1 - a0); \
if( pb >= sp->refruns + sp->nruns) { \ if (pb >= sp->refruns + sp->nruns) \
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); \ TIFFErrorExtR(tif, module, \
"Buffer overflow at line %u of %s %u", \
sp->line, \
isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile \
: tif->tif_curstrip); \
return (-1); \ return (-1); \
} \ } \
b1 += *pb++; \ b1 += *pb++; \
@ -499,16 +580,22 @@ done1d: \
case S_VR: \ case S_VR: \
CHECK_b1; \ CHECK_b1; \
SETVALUE(b1 - a0 + TabEnt->Param); \ SETVALUE(b1 - a0 + TabEnt->Param); \
if( pb >= sp->refruns + sp->nruns) { \ if (pb >= sp->refruns + sp->nruns) \
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); \ TIFFErrorExtR(tif, module, \
"Buffer overflow at line %u of %s %u", \
sp->line, \
isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile \
: tif->tif_curstrip); \
return (-1); \ return (-1); \
} \ } \
b1 += *pb++; \ b1 += *pb++; \
break; \ break; \
case S_VL: \ case S_VL: \
CHECK_b1; \ CHECK_b1; \
if (b1 < (int) (a0 + TabEnt->Param)) { \ if (b1 < (int)(a0 + TabEnt->Param)) \
{ \
unexpected("VL", a0); \ unexpected("VL", a0); \
goto eol2d; \ goto eol2d; \
} \ } \
@ -543,8 +630,10 @@ done1d: \
goto eoflab; \ goto eoflab; \
} \ } \
} \ } \
if (RunLength) { \ if (RunLength) \
if (RunLength + a0 < lastx) { \ { \
if (RunLength + a0 < lastx) \
{ \
/* expect a final V0 */ \ /* expect a final V0 */ \
NeedBits8(1, eof2d); \ NeedBits8(1, eof2d); \
if (!GetBits(1)) \ if (!GetBits(1)) \
@ -557,11 +646,3 @@ eol2d: \
CLEANUP_RUNS(); \ CLEANUP_RUNS(); \
} while (0) } 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:
*/

53
3rdparty/libtiff/tif_flush.c vendored
View File

@ -27,8 +27,7 @@
*/ */
#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;
@ -41,16 +40,15 @@ TIFFFlush(TIFF* tif)
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);
@ -82,19 +80,17 @@ int TIFFForceStrileArrayWriting(TIFF* 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;
@ -111,7 +107,7 @@ int TIFFForceStrileArrayWriting(TIFF* tif)
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;
@ -122,16 +118,12 @@ int TIFFForceStrileArrayWriting(TIFF* tif)
} }
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 :
TIFFTAG_STRIPBYTECOUNTS,
TIFF_LONG8,
tif->tif_dir.td_nstrips,
tif->tif_dir.td_stripbytecount_p)) tif->tif_dir.td_stripbytecount_p))
{ {
tif->tif_flags &= ~TIFF_DIRTYSTRIP; tif->tif_flags &= ~TIFF_DIRTYSTRIP;
@ -151,24 +143,15 @@ int TIFFForceStrileArrayWriting(TIFF* tif)
* 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; tif->tif_flags &= ~TIFF_POSTENCODE;
if (!(*tif->tif_postencode)(tif)) if (!(*tif->tif_postencode)(tif))
return (0); 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:
*/

2033
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 */

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

@ -39,14 +39,15 @@ 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",
"Multistrip images not supported in decoder");
return 0; 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;
@ -84,9 +85,7 @@ static int JBIGDecode(TIFF* tif, uint8* buffer, tmsize_t size, uint16 s)
* 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
@ -100,15 +99,17 @@ static int JBIGDecode(TIFF* tif, uint8* buffer, tmsize_t size, uint16 s)
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", TIFFErrorExtR(tif, "JBIG",
"Decoded %lu bytes, whereas %lu were requested", "Decoded %lu bytes, whereas %" TIFF_SSIZE_FORMAT
decodedSize, (unsigned long)size); " were requested",
decodedSize, size);
jbg_dec_free(&decoder); jbg_dec_free(&decoder);
return 0; return 0;
} }
@ -126,14 +127,16 @@ 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",
"Multistrip images not supported in encoder");
return 0; 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)
@ -151,8 +154,7 @@ static int JBIGCopyEncodedData(TIFF* tif, unsigned char* pp, size_t cc, uint16 s
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);
} }
@ -173,20 +175,15 @@ static void JBIGOutputBie(unsigned char* buffer, size_t len, void* userData)
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,
&buffer,
JBIGOutputBie,
tif);
/* /*
* jbg_enc_out does the "real" encoding. As data is encoded, * jbg_enc_out does the "real" encoding. As data is encoded,
* JBIGOutputBie is called, which writes the data to the directory. * JBIGOutputBie is called, which writes the data to the directory.
@ -209,6 +206,17 @@ int TIFFInitJBIG(TIFF* tif, int scheme)
*/ */
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;
@ -221,13 +229,3 @@ int TIFFInitJBIG(TIFF* tif, int scheme)
} }
#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:
*/

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

File diff suppressed because it is too large Load Diff

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

@ -1,56 +1,58 @@
#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 FROM_TIF_JPEG_12
#ifdef TIFFInitJPEG
#undef TIFFInitJPEG
#endif
#define TIFFInitJPEG TIFFInitJPEG_12 #define TIFFInitJPEG TIFFInitJPEG_12
#ifdef TIFFJPEGIsFullStripRequired
#undef TIFFJPEGIsFullStripRequired
#endif
#define TIFFJPEGIsFullStripRequired TIFFJPEGIsFullStripRequired_12 #define TIFFJPEGIsFullStripRequired TIFFJPEGIsFullStripRequired_12
int int TIFFInitJPEG_12(TIFF *tif, int scheme);
TIFFInitJPEG_12(TIFF* tif, int scheme);
#if !defined(HAVE_JPEGTURBO_DUAL_MODE_8_12)
#include LIBJPEG_12_PATH #include LIBJPEG_12_PATH
#endif
#include "tif_jpeg.c" #include "tif_jpeg.c"
int TIFFReInitJPEG_12( TIFF *tif, int scheme, int is_encode ) 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;
/*
* 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) if (is_encode)
return JPEGSetupEncode(tif); return JPEGSetupEncode(tif);
@ -59,11 +61,3 @@ int TIFFReInitJPEG_12( TIFF *tif, int scheme, int is_encode )
} }
#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

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

File diff suppressed because it is too large Load Diff

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

@ -33,15 +33,16 @@
* 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; TIFFPredictorState predict;
lzma_stream stream; lzma_stream stream;
lzma_filter filters[LZMA_FILTERS_MAX + 1]; lzma_filter filters[LZMA_FILTERS_MAX + 1];
@ -61,13 +62,13 @@ typedef struct {
#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: case LZMA_OK:
return "operation completed successfully"; return "operation completed successfully";
case LZMA_STREAM_END: case LZMA_STREAM_END:
@ -97,22 +98,21 @@ LZMAStrerror(lzma_ret ret)
} }
} }
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 we were last encoding, terminate this mode */
if (sp->state & LSTATE_INIT_ENCODE) { if (sp->state & LSTATE_INIT_ENCODE)
{
lzma_end(&sp->stream); lzma_end(&sp->stream);
sp->state = 0; sp->state = 0;
} }
@ -124,8 +124,7 @@ LZMASetupDecode(TIFF* tif)
/* /*
* 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);
@ -139,8 +138,9 @@ LZMAPreDecode(TIFF* tif, uint16 s)
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, {
TIFFErrorExtR(tif, module,
"Liblzma cannot deal with buffers this size"); "Liblzma cannot deal with buffers this size");
return 0; return 0;
} }
@ -150,17 +150,16 @@ LZMAPreDecode(TIFF* tif, uint16 s)
* 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);
@ -174,13 +173,15 @@ LZMADecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
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, {
TIFFErrorExtR(tif, module,
"Liblzma cannot deal with buffers this size"); "Liblzma cannot deal with buffers this size");
return 0; return 0;
} }
do { do
{
/* /*
* Save the current stream state to properly recover from the * Save the current stream state to properly recover from the
* decoding errors later. * decoding errors later.
@ -191,11 +192,13 @@ LZMADecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
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)
{
TIFFErrorExtR(tif, module,
"Error initializing the stream decoder, %s", "Error initializing the stream decoder, %s",
LZMAStrerror(r)); LZMAStrerror(r));
break; break;
@ -204,33 +207,36 @@ LZMADecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
sp->stream.avail_in = avail_in; sp->stream.avail_in = avail_in;
continue; continue;
} }
if (ret != LZMA_OK) { if (ret != LZMA_OK)
TIFFErrorExt(tif->tif_clientdata, module, {
"Decoding error at scanline %lu, %s", TIFFErrorExtR(tif, module,
(unsigned long) tif->tif_row, LZMAStrerror(ret)); "Decoding error at scanline %" PRIu32 ", %s",
tif->tif_row, LZMAStrerror(ret));
break; break;
} }
} while (sp->stream.avail_out > 0); } while (sp->stream.avail_out > 0);
if (sp->stream.avail_out != 0) { if (sp->stream.avail_out != 0)
TIFFErrorExt(tif->tif_clientdata, module, {
"Not enough data at scanline %lu (short %lu bytes)", TIFFErrorExtR(tif, module,
(unsigned long) tif->tif_row, (unsigned long) sp->stream.avail_out); "Not enough data at scanline %" PRIu32
" (short %" TIFF_SIZE_FORMAT " bytes)",
tif->tif_row, sp->stream.avail_out);
return 0; 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); lzma_end(&sp->stream);
sp->state = 0; sp->state = 0;
} }
@ -242,8 +248,7 @@ LZMASetupEncode(TIFF* tif)
/* /*
* 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);
@ -256,15 +261,17 @@ LZMAPreEncode(TIFF* tif, uint16 s)
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, {
TIFFErrorExtR(tif, module,
"Liblzma cannot deal with buffers this size"); "Liblzma cannot deal with buffers this size");
return 0; return 0;
} }
ret = lzma_stream_encoder(&sp->stream, sp->filters, sp->check); ret = lzma_stream_encoder(&sp->stream, sp->filters, sp->check);
if (ret != LZMA_OK) { if (ret != LZMA_OK)
TIFFErrorExt(tif->tif_clientdata, module, {
"Error in lzma_stream_encoder(): %s", LZMAStrerror(ret)); TIFFErrorExtR(tif, module, "Error in lzma_stream_encoder(): %s",
LZMAStrerror(ret));
return 0; return 0;
} }
return 1; return 1;
@ -273,8 +280,7 @@ LZMAPreEncode(TIFF* tif, uint16 s)
/* /*
* 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);
@ -285,25 +291,32 @@ LZMAEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
(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, {
TIFFErrorExtR(tif, module,
"Liblzma cannot deal with buffers this size"); "Liblzma cannot deal with buffers this size");
return 0; return 0;
} }
do { do
{
lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN); lzma_ret ret = lzma_code(&sp->stream, LZMA_RUN);
if (ret != LZMA_OK) { if (ret != LZMA_OK)
TIFFErrorExt(tif->tif_clientdata, module, {
"Encoding error at scanline %lu, %s", TIFFErrorExtR(tif, module,
(unsigned long) tif->tif_row, LZMAStrerror(ret)); "Encoding error at scanline %" PRIu32 ", %s",
tif->tif_row, LZMAStrerror(ret));
return 0; return 0;
} }
if (sp->stream.avail_out == 0) { if (sp->stream.avail_out == 0)
{
tif->tif_rawcc = tif->tif_rawdatasize; tif->tif_rawcc = tif->tif_rawdatasize;
if (!TIFFFlushData1(tif)) if (!TIFFFlushData1(tif))
return 0; return 0;
sp->stream.next_out = tif->tif_rawdata; 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 */ 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); } while (sp->stream.avail_in > 0);
return 1; return 1;
@ -313,30 +326,36 @@ LZMAEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
* 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); ret = lzma_code(&sp->stream, LZMA_FINISH);
switch (ret) { switch (ret)
{
case LZMA_STREAM_END: case LZMA_STREAM_END:
case LZMA_OK: case LZMA_OK:
if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) { if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
{
tif->tif_rawcc = tif->tif_rawcc =
tif->tif_rawdatasize - sp->stream.avail_out; tif->tif_rawdatasize - sp->stream.avail_out;
if (!TIFFFlushData1(tif)) if (!TIFFFlushData1(tif))
return 0; return 0;
sp->stream.next_out = tif->tif_rawdata; 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 ZIPPreEncode */ sp->stream.avail_out =
(size_t)
tif->tif_rawdatasize; /* this is a safe typecast, as
check is made already in
ZIPPreEncode */
} }
break; break;
default: default:
TIFFErrorExt(tif->tif_clientdata, module, "Liblzma error: %s", TIFFErrorExtR(tif, module, "Liblzma error: %s",
LZMAStrerror(ret)); LZMAStrerror(ret));
return 0; return 0;
} }
@ -344,8 +363,7 @@ LZMAPostEncode(TIFF* tif)
return 1; return 1;
} }
static void static void LZMACleanup(TIFF *tif)
LZMACleanup(TIFF* tif)
{ {
LZMAState *sp = LState(tif); LZMAState *sp = LState(tif);
@ -356,33 +374,34 @@ LZMACleanup(TIFF* 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); lzma_end(&sp->stream);
sp->state = 0; sp->state = 0;
} }
_TIFFfree(sp); _TIFFfreeExt(tif, sp);
tif->tif_data = NULL; 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: case TIFFTAG_LZMAPRESET:
sp->preset = (int)va_arg(ap, int); sp->preset = (int)va_arg(ap, int);
lzma_lzma_preset(&sp->opt_lzma, sp->preset); lzma_lzma_preset(&sp->opt_lzma, sp->preset);
if (sp->state & LSTATE_INIT_ENCODE) { if (sp->state & LSTATE_INIT_ENCODE)
lzma_ret ret = lzma_stream_encoder(&sp->stream, {
sp->filters, lzma_ret ret =
sp->check); lzma_stream_encoder(&sp->stream, sp->filters, sp->check);
if (ret != LZMA_OK) { if (ret != LZMA_OK)
TIFFErrorExt(tif->tif_clientdata, module, {
"Liblzma error: %s", TIFFErrorExtR(tif, module, "Liblzma error: %s",
LZMAStrerror(ret)); LZMAStrerror(ret));
} }
} }
@ -393,12 +412,12 @@ LZMAVSetField(TIFF* tif, uint32 tag, va_list 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: case TIFFTAG_LZMAPRESET:
*va_arg(ap, int *) = sp->preset; *va_arg(ap, int *) = sp->preset;
break; break;
@ -409,12 +428,12 @@ LZMAVGetField(TIFF* tif, uint32 tag, va_list ap)
} }
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;
@ -426,16 +445,16 @@ TIFFInitLZMA(TIFF* tif, int scheme)
/* /*
* 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);
@ -460,8 +479,9 @@ TIFFInitLZMA(TIFF* tif, int scheme)
* 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
: tif->tif_dir.td_bitspersample / 8;
sp->filters[0].id = LZMA_FILTER_DELTA; sp->filters[0].id = LZMA_FILTER_DELTA;
sp->filters[0].options = &sp->opt_delta; sp->filters[0].options = &sp->opt_delta;
@ -494,10 +514,7 @@ TIFFInitLZMA(TIFF* tif, int scheme)
(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: */

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

File diff suppressed because it is too large Load Diff

85
3rdparty/libtiff/tif_next.c vendored
View File

@ -30,12 +30,23 @@
* 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; \
} \ } \
} }
@ -43,13 +54,12 @@
#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;
@ -66,13 +76,15 @@ NeXTDecode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
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++; n = *bp++;
cc--; cc--;
switch (n) { switch (n)
{
case LITERALROW: case LITERALROW:
/* /*
* The entire scanline is given as literal values. * The entire scanline is given as literal values.
@ -83,7 +95,8 @@ NeXTDecode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
bp += scanline; bp += scanline;
cc -= scanline; cc -= scanline;
break; break;
case LITERALSPAN: { case LITERALSPAN:
{
tmsize_t off; tmsize_t off;
/* /*
* The scanline has a literal span that begins at some * The scanline has a literal span that begins at some
@ -100,10 +113,11 @@ NeXTDecode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
cc -= 4 + n; cc -= 4 + n;
break; break;
} }
default: { default:
uint32 npixels = 0, grey; {
uint32_t npixels = 0, grey;
tmsize_t op_offset = 0; tmsize_t op_offset = 0;
uint32 imagewidth = tif->tif_dir.td_imagewidth; uint32_t imagewidth = tif->tif_dir.td_imagewidth;
if (isTiled(tif)) if (isTiled(tif))
imagewidth = tif->tif_dir.td_tilewidth; imagewidth = tif->tif_dir.td_tilewidth;
@ -114,21 +128,25 @@ NeXTDecode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
* <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); {
grey = (uint32_t)((n >> 6) & 0x3);
n &= 0x3f; n &= 0x3f;
/* /*
* Ensure the run does not exceed the scanline * Ensure the run does not exceed the scanline
* bounds, potentially resulting in a security * bounds, potentially resulting in a security
* issue. * issue.
*/ */
while (n-- > 0 && npixels < imagewidth && op_offset < scanline) while (n-- > 0 && npixels < imagewidth &&
op_offset < scanline)
SETPIXEL(op, grey); SETPIXEL(op, grey);
if (npixels >= imagewidth) if (npixels >= imagewidth)
break; break;
if (op_offset >= scanline ) { if (op_offset >= scanline)
TIFFErrorExt(tif->tif_clientdata, module, "Invalid data for scanline %ld", {
(long) tif->tif_row); TIFFErrorExtR(tif, module,
"Invalid data for scanline %" PRIu32,
tif->tif_row);
return (0); return (0);
} }
if (cc == 0) if (cc == 0)
@ -140,17 +158,16 @@ NeXTDecode(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
} }
} }
} }
tif->tif_rawcp = (uint8*) bp; tif->tif_rawcp = (uint8_t *)bp;
tif->tif_rawcc = cc; tif->tif_rawcc = cc;
return (1); 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;
@ -158,15 +175,14 @@ NeXTPreDecode(TIFF* tif, uint16 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;
@ -176,12 +192,3 @@ TIFFInitNeXT(TIFF* tif, int scheme)
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:
*/

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

File diff suppressed because it is too large Load Diff

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

@ -26,29 +26,33 @@
* TIFF Library. * TIFF Library.
*/ */
#include "tiffiop.h" #include "tiffiop.h"
#include <limits.h>
/* /*
* Dummy functions to fill the omitted client procedures. * Dummy functions to fill the omitted client procedures.
*/ */
static int static int _tiffDummyMapProc(thandle_t fd, void **pbase, toff_t *psize)
_tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
{ {
(void) fd; (void) pbase; (void) psize; (void)fd;
(void)pbase;
(void)psize;
return (0); return (0);
} }
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) base; (void) size; (void)fd;
(void)base;
(void)size;
} }
int int _TIFFgetMode(TIFFOpenOptions *opts, thandle_t clientdata, const char *mode,
_TIFFgetMode(const char* mode, const char* module) const char *module)
{ {
int m = -1; int m = -1;
switch (mode[0]) { switch (mode[0])
{
case 'r': case 'r':
m = O_RDONLY; m = O_RDONLY;
if (mode[1] == '+') if (mode[1] == '+')
@ -61,46 +65,146 @@ _TIFFgetMode(const char* mode, const char* module)
m |= O_TRUNC; m |= O_TRUNC;
break; break;
default: default:
TIFFErrorExt(0, module, "\"%s\": Bad mode", mode); _TIFFErrorEarly(opts, clientdata, module, "\"%s\": Bad mode", mode);
break; break;
} }
return (m); return (m);
} }
TIFF* TIFFOpenOptions *TIFFOpenOptionsAlloc()
TIFFClientOpen(
const char* name, const char* mode,
thandle_t clientdata,
TIFFReadWriteProc readproc,
TIFFReadWriteProc writeproc,
TIFFSeekProc seekproc,
TIFFCloseProc closeproc,
TIFFSizeProc sizeproc,
TIFFMapFileProc mapproc,
TIFFUnmapFileProc unmapproc
)
{ {
static const char module[] = "TIFFClientOpen"; TIFFOpenOptions *opts =
(TIFFOpenOptions *)_TIFFcalloc(1, sizeof(TIFFOpenOptions));
return opts;
}
void TIFFOpenOptionsFree(TIFFOpenOptions *opts) { _TIFFfree(opts); }
/** Define a limit in bytes for a single memory allocation done by libtiff.
* If max_single_mem_alloc is set to 0, no other limit that the underlying
* _TIFFmalloc() will be applied, which is the default.
*/
void TIFFOpenOptionsSetMaxSingleMemAlloc(TIFFOpenOptions *opts,
tmsize_t max_single_mem_alloc)
{
opts->max_single_mem_alloc = max_single_mem_alloc;
}
void TIFFOpenOptionsSetErrorHandlerExtR(TIFFOpenOptions *opts,
TIFFErrorHandlerExtR handler,
void *errorhandler_user_data)
{
opts->errorhandler = handler;
opts->errorhandler_user_data = errorhandler_user_data;
}
void TIFFOpenOptionsSetWarningHandlerExtR(TIFFOpenOptions *opts,
TIFFErrorHandlerExtR handler,
void *warnhandler_user_data)
{
opts->warnhandler = handler;
opts->warnhandler_user_data = warnhandler_user_data;
}
static void _TIFFEmitErrorAboveMaxSingleMemAlloc(TIFF *tif,
const char *pszFunction,
tmsize_t s)
{
TIFFErrorExtR(tif, pszFunction,
"Memory allocation of %" PRIu64
" bytes is beyond the %" PRIu64
" byte limit defined in open options",
(uint64_t)s, (uint64_t)tif->tif_max_single_mem_alloc);
}
/** malloc() version that takes into account memory-specific open options */
void *_TIFFmallocExt(TIFF *tif, tmsize_t s)
{
if (tif != NULL && tif->tif_max_single_mem_alloc > 0 &&
s > tif->tif_max_single_mem_alloc)
{
_TIFFEmitErrorAboveMaxSingleMemAlloc(tif, "_TIFFmallocExt", s);
return NULL;
}
return _TIFFmalloc(s);
}
/** calloc() version that takes into account memory-specific open options */
void *_TIFFcallocExt(TIFF *tif, tmsize_t nmemb, tmsize_t siz)
{
if (tif != NULL && tif->tif_max_single_mem_alloc > 0)
{
if (nmemb <= 0 || siz <= 0 || nmemb > TIFF_TMSIZE_T_MAX / siz)
return NULL;
if (nmemb * siz > tif->tif_max_single_mem_alloc)
{
_TIFFEmitErrorAboveMaxSingleMemAlloc(tif, "_TIFFcallocExt",
nmemb * siz);
return NULL;
}
}
return _TIFFcalloc(nmemb, siz);
}
/** realloc() version that takes into account memory-specific open options */
void *_TIFFreallocExt(TIFF *tif, void *p, tmsize_t s)
{
if (tif != NULL && tif->tif_max_single_mem_alloc > 0 &&
s > tif->tif_max_single_mem_alloc)
{
_TIFFEmitErrorAboveMaxSingleMemAlloc(tif, "_TIFFreallocExt", s);
return NULL;
}
return _TIFFrealloc(p, s);
}
/** free() version that takes into account memory-specific open options */
void _TIFFfreeExt(TIFF *tif, void *p)
{
(void)tif;
_TIFFfree(p);
}
TIFF *TIFFClientOpen(const char *name, const char *mode, thandle_t clientdata,
TIFFReadWriteProc readproc, TIFFReadWriteProc writeproc,
TIFFSeekProc seekproc, TIFFCloseProc closeproc,
TIFFSizeProc sizeproc, TIFFMapFileProc mapproc,
TIFFUnmapFileProc unmapproc)
{
return TIFFClientOpenExt(name, mode, clientdata, readproc, writeproc,
seekproc, closeproc, sizeproc, mapproc, unmapproc,
NULL);
}
TIFF *TIFFClientOpenExt(const char *name, const char *mode,
thandle_t clientdata, TIFFReadWriteProc readproc,
TIFFReadWriteProc writeproc, TIFFSeekProc seekproc,
TIFFCloseProc closeproc, TIFFSizeProc sizeproc,
TIFFMapFileProc mapproc, TIFFUnmapFileProc unmapproc,
TIFFOpenOptions *opts)
{
static const char module[] = "TIFFClientOpenExt";
TIFF *tif; TIFF *tif;
int m; int m;
const char *cp; const char *cp;
/* The following are configuration checks. They should be redundant, but should not /* The following are configuration checks. They should be redundant, but
* compile to any actual code in an optimised release build anyway. If any of them * should not compile to any actual code in an optimised release build
* fail, (makefile-based or other) configuration is not correct */ * anyway. If any of them fail, (makefile-based or other) configuration is
assert(sizeof(uint8)==1); * not correct */
assert(sizeof(int8)==1); assert(sizeof(uint8_t) == 1);
assert(sizeof(uint16)==2); assert(sizeof(int8_t) == 1);
assert(sizeof(int16)==2); assert(sizeof(uint16_t) == 2);
assert(sizeof(uint32)==4); assert(sizeof(int16_t) == 2);
assert(sizeof(int32)==4); assert(sizeof(uint32_t) == 4);
assert(sizeof(uint64)==8); assert(sizeof(int32_t) == 4);
assert(sizeof(int64)==8); assert(sizeof(uint64_t) == 8);
assert(sizeof(tmsize_t)==sizeof(void*)); assert(sizeof(int64_t) == 8);
{ {
union{ union
uint8 a8[2]; {
uint16 a16; uint8_t a8[2];
uint16_t a16;
} n; } n;
n.a8[0] = 1; n.a8[0] = 1;
n.a8[1] = 0; n.a8[1] = 0;
@ -112,42 +216,61 @@ TIFFClientOpen(
#endif #endif
} }
m = _TIFFgetMode(mode, module); m = _TIFFgetMode(opts, clientdata, mode, module);
if (m == -1) if (m == -1)
goto bad2; goto bad2;
tif = (TIFF *)_TIFFmalloc((tmsize_t)(sizeof (TIFF) + strlen(name) + 1)); tmsize_t size_to_alloc = (tmsize_t)(sizeof(TIFF) + strlen(name) + 1);
if (tif == NULL) { if (opts && opts->max_single_mem_alloc > 0 &&
TIFFErrorExt(clientdata, module, "%s: Out of memory (TIFF structure)", name); size_to_alloc > opts->max_single_mem_alloc)
{
_TIFFErrorEarly(opts, clientdata, module,
"%s: Memory allocation of %" PRIu64
" bytes is beyond the %" PRIu64
" byte limit defined in open options",
name, (uint64_t)size_to_alloc,
(uint64_t)opts->max_single_mem_alloc);
goto bad2;
}
tif = (TIFF *)_TIFFmallocExt(NULL, size_to_alloc);
if (tif == NULL)
{
_TIFFErrorEarly(opts, clientdata, module,
"%s: Out of memory (TIFF structure)", name);
goto bad2; goto bad2;
} }
_TIFFmemset(tif, 0, sizeof(*tif)); _TIFFmemset(tif, 0, sizeof(*tif));
tif->tif_name = (char *)tif + sizeof(TIFF); tif->tif_name = (char *)tif + sizeof(TIFF);
strcpy(tif->tif_name, name); strcpy(tif->tif_name, name);
tif->tif_mode = m & ~(O_CREAT | O_TRUNC); tif->tif_mode = m & ~(O_CREAT | O_TRUNC);
tif->tif_curdir = (uint16) -1; /* non-existent directory */ tif->tif_curdir = TIFF_NON_EXISTENT_DIR_NUMBER; /* non-existent directory */
tif->tif_curoff = 0; tif->tif_curoff = 0;
tif->tif_curstrip = (uint32) -1; /* invalid strip */ tif->tif_curstrip = (uint32_t)-1; /* invalid strip */
tif->tif_row = (uint32) -1; /* read/write pre-increment */ tif->tif_row = (uint32_t)-1; /* read/write pre-increment */
tif->tif_clientdata = clientdata; tif->tif_clientdata = clientdata;
if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc) {
TIFFErrorExt(clientdata, module,
"One of the client procedures is NULL pointer.");
_TIFFfree(tif);
goto bad2;
}
tif->tif_readproc = readproc; tif->tif_readproc = readproc;
tif->tif_writeproc = writeproc; tif->tif_writeproc = writeproc;
tif->tif_seekproc = seekproc; tif->tif_seekproc = seekproc;
tif->tif_closeproc = closeproc; tif->tif_closeproc = closeproc;
tif->tif_sizeproc = sizeproc; tif->tif_sizeproc = sizeproc;
if (mapproc) tif->tif_mapproc = mapproc ? mapproc : _tiffDummyMapProc;
tif->tif_mapproc = mapproc; tif->tif_unmapproc = unmapproc ? unmapproc : _tiffDummyUnmapProc;
else if (opts)
tif->tif_mapproc = _tiffDummyMapProc; {
if (unmapproc) tif->tif_errorhandler = opts->errorhandler;
tif->tif_unmapproc = unmapproc; tif->tif_errorhandler_user_data = opts->errorhandler_user_data;
else tif->tif_warnhandler = opts->warnhandler;
tif->tif_unmapproc = _tiffDummyUnmapProc; tif->tif_warnhandler_user_data = opts->warnhandler_user_data;
tif->tif_max_single_mem_alloc = opts->max_single_mem_alloc;
}
if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc)
{
TIFFErrorExtR(tif, module,
"One of the client procedures is NULL pointer.");
_TIFFfreeExt(NULL, tif);
goto bad2;
}
_TIFFSetDefaultCompressionState(tif); /* setup default state */ _TIFFSetDefaultCompressionState(tif); /* setup default state */
/* /*
* Default is to return data MSB2LSB and enable the * Default is to return data MSB2LSB and enable the
@ -184,7 +307,8 @@ TIFFClientOpen(
* '4' ClassicTIFF for creating a file (default) * '4' ClassicTIFF for creating a file (default)
* '8' BigTIFF for creating a file * '8' BigTIFF for creating a file
* 'D' enable use of deferred strip/tile offset/bytecount array loading. * 'D' enable use of deferred strip/tile offset/bytecount array loading.
* 'O' on-demand loading of values instead of whole array loading (implies D) * 'O' on-demand loading of values instead of whole array loading (implies
* D)
* *
* The use of the 'l' and 'b' flags is strongly discouraged. * The use of the 'l' and 'b' flags is strongly discouraged.
* These flags are provided solely because numerous vendors, * These flags are provided solely because numerous vendors,
@ -218,7 +342,8 @@ TIFFClientOpen(
* for example, to get the unadulterated TIFF tag information. * for example, to get the unadulterated TIFF tag information.
*/ */
for (cp = mode; *cp; cp++) for (cp = mode; *cp; cp++)
switch (*cp) { switch (*cp)
{
case 'b': case 'b':
#ifndef WORDS_BIGENDIAN #ifndef WORDS_BIGENDIAN
if (m & O_CREAT) if (m & O_CREAT)
@ -232,16 +357,20 @@ TIFFClientOpen(
#endif #endif
break; break;
case 'B': case 'B':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | tif->tif_flags =
FILLORDER_MSB2LSB; (tif->tif_flags & ~TIFF_FILLORDER) | FILLORDER_MSB2LSB;
break; break;
case 'L': case 'L':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | tif->tif_flags =
FILLORDER_LSB2MSB; (tif->tif_flags & ~TIFF_FILLORDER) | FILLORDER_LSB2MSB;
break; break;
case 'H': case 'H':
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) | TIFFWarningExtR(tif, name,
HOST_FILLORDER; "H(ost) mode is deprecated. Since "
"libtiff 4.5.1, it is an alias of 'B' / "
"FILLORDER_MSB2LSB.");
tif->tif_flags =
(tif->tif_flags & ~TIFF_FILLORDER) | FILLORDER_MSB2LSB;
break; break;
case 'M': case 'M':
if (m == O_RDONLY) if (m == O_RDONLY)
@ -271,7 +400,8 @@ TIFFClientOpen(
break; break;
case 'O': case 'O':
if (m == O_RDONLY) if (m == O_RDONLY)
tif->tif_flags |= (TIFF_LAZYSTRILELOAD | TIFF_DEFERSTRILELOAD); tif->tif_flags |=
(TIFF_LAZYSTRILELOAD | TIFF_DEFERSTRILELOAD);
break; break;
} }
@ -286,21 +416,22 @@ TIFFClientOpen(
* Read in TIFF header. * Read in TIFF header.
*/ */
if ((m & O_TRUNC) || if ((m & O_TRUNC) ||
!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeaderClassic))) { !ReadOK(tif, &tif->tif_header, sizeof(TIFFHeaderClassic)))
if (tif->tif_mode == O_RDONLY) { {
TIFFErrorExt(tif->tif_clientdata, name, if (tif->tif_mode == O_RDONLY)
"Cannot read TIFF header"); {
TIFFErrorExtR(tif, name, "Cannot read TIFF header");
goto bad; goto bad;
} }
/* /*
* Setup header and write. * Setup header and write.
*/ */
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
tif->tif_header.common.tiff_magic = (tif->tif_flags & TIFF_SWAB) tif->tif_header.common.tiff_magic =
? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN; (tif->tif_flags & TIFF_SWAB) ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
#else #else
tif->tif_header.common.tiff_magic = (tif->tif_flags & TIFF_SWAB) tif->tif_header.common.tiff_magic =
? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN; (tif->tif_flags & TIFF_SWAB) ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
#endif #endif
if (!(tif->tif_flags & TIFF_BIGTIFF)) if (!(tif->tif_flags & TIFF_BIGTIFF))
{ {
@ -331,19 +462,22 @@ TIFFClientOpen(
* on Solaris. * on Solaris.
*/ */
TIFFSeekFile(tif, 0, SEEK_SET); TIFFSeekFile(tif, 0, SEEK_SET);
if (!WriteOK(tif, &tif->tif_header, (tmsize_t)(tif->tif_header_size))) { if (!WriteOK(tif, &tif->tif_header, (tmsize_t)(tif->tif_header_size)))
TIFFErrorExt(tif->tif_clientdata, name, {
"Error writing TIFF header"); TIFFErrorExtR(tif, name, "Error writing TIFF header");
goto bad; goto bad;
} }
/* /*
* Setup the byte order handling. * Setup the byte order handling.
*/ */
if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) { if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN)
{
#ifndef WORDS_BIGENDIAN #ifndef WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB; tif->tif_flags |= TIFF_SWAB;
#endif #endif
} else { }
else
{
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB; tif->tif_flags |= TIFF_SWAB;
#endif #endif
@ -354,9 +488,8 @@ TIFFClientOpen(
if (!TIFFDefaultDirectory(tif)) if (!TIFFDefaultDirectory(tif))
goto bad; goto bad;
tif->tif_diroff = 0; tif->tif_diroff = 0;
tif->tif_dirlist = NULL; tif->tif_lastdiroff = 0;
tif->tif_dirlistsize = 0; tif->tif_setdirectory_force_absolute = FALSE;
tif->tif_dirnumber = 0;
return (tif); return (tif);
} }
/* /*
@ -371,23 +504,30 @@ TIFFClientOpen(
#else #else
tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN
#endif #endif
) { )
TIFFErrorExt(tif->tif_clientdata, name, {
"Not a TIFF or MDI file, bad magic number %d (0x%x)", TIFFErrorExtR(tif, name,
"Not a TIFF or MDI file, bad magic number %" PRIu16
" (0x%" PRIx16 ")",
#else #else
) { )
TIFFErrorExt(tif->tif_clientdata, name, {
"Not a TIFF file, bad magic number %d (0x%x)", TIFFErrorExtR(tif, name,
"Not a TIFF file, bad magic number %" PRIu16
" (0x%" PRIx16 ")",
#endif #endif
tif->tif_header.common.tiff_magic, tif->tif_header.common.tiff_magic,
tif->tif_header.common.tiff_magic); tif->tif_header.common.tiff_magic);
goto bad; goto bad;
} }
if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) { if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN)
{
#ifndef WORDS_BIGENDIAN #ifndef WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB; tif->tif_flags |= TIFF_SWAB;
#endif #endif
} else { }
else
{
#ifdef WORDS_BIGENDIAN #ifdef WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB; tif->tif_flags |= TIFF_SWAB;
#endif #endif
@ -395,9 +535,11 @@ TIFFClientOpen(
if (tif->tif_flags & TIFF_SWAB) if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&tif->tif_header.common.tiff_version); TIFFSwabShort(&tif->tif_header.common.tiff_version);
if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC) && if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC) &&
(tif->tif_header.common.tiff_version != TIFF_VERSION_BIG)) { (tif->tif_header.common.tiff_version != TIFF_VERSION_BIG))
TIFFErrorExt(tif->tif_clientdata, name, {
"Not a TIFF file, bad version number %d (0x%x)", TIFFErrorExtR(tif, name,
"Not a TIFF file, bad version number %" PRIu16
" (0x%" PRIx16 ")",
tif->tif_header.common.tiff_version, tif->tif_header.common.tiff_version,
tif->tif_header.common.tiff_version); tif->tif_header.common.tiff_version);
goto bad; goto bad;
@ -410,10 +552,11 @@ TIFFClientOpen(
} }
else else
{ {
if (!ReadOK(tif, ((uint8*)(&tif->tif_header) + sizeof(TIFFHeaderClassic)), (sizeof(TIFFHeaderBig)-sizeof(TIFFHeaderClassic)))) if (!ReadOK(tif,
((uint8_t *)(&tif->tif_header) + sizeof(TIFFHeaderClassic)),
(sizeof(TIFFHeaderBig) - sizeof(TIFFHeaderClassic))))
{ {
TIFFErrorExt(tif->tif_clientdata, name, TIFFErrorExtR(tif, name, "Cannot read TIFF header");
"Cannot read TIFF header");
goto bad; goto bad;
} }
if (tif->tif_flags & TIFF_SWAB) if (tif->tif_flags & TIFF_SWAB)
@ -423,16 +566,18 @@ TIFFClientOpen(
} }
if (tif->tif_header.big.tiff_offsetsize != 8) if (tif->tif_header.big.tiff_offsetsize != 8)
{ {
TIFFErrorExt(tif->tif_clientdata, name, TIFFErrorExtR(tif, name,
"Not a TIFF file, bad BigTIFF offsetsize %d (0x%x)", "Not a TIFF file, bad BigTIFF offsetsize %" PRIu16
" (0x%" PRIx16 ")",
tif->tif_header.big.tiff_offsetsize, tif->tif_header.big.tiff_offsetsize,
tif->tif_header.big.tiff_offsetsize); tif->tif_header.big.tiff_offsetsize);
goto bad; goto bad;
} }
if (tif->tif_header.big.tiff_unused != 0) if (tif->tif_header.big.tiff_unused != 0)
{ {
TIFFErrorExt(tif->tif_clientdata, name, TIFFErrorExtR(tif, name,
"Not a TIFF file, bad BigTIFF unused %d (0x%x)", "Not a TIFF file, bad BigTIFF unused %" PRIu16
" (0x%" PRIx16 ")",
tif->tif_header.big.tiff_unused, tif->tif_header.big.tiff_unused,
tif->tif_header.big.tiff_unused); tif->tif_header.big.tiff_unused);
goto bad; goto bad;
@ -446,7 +591,8 @@ TIFFClientOpen(
tif->tif_rawdataoff = 0; tif->tif_rawdataoff = 0;
tif->tif_rawdataloaded = 0; tif->tif_rawdataloaded = 0;
switch (mode[0]) { switch (mode[0])
{
case 'r': case 'r':
if (!(tif->tif_flags & TIFF_BIGTIFF)) if (!(tif->tif_flags & TIFF_BIGTIFF))
tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff; tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff;
@ -469,10 +615,10 @@ TIFFClientOpen(
tif->tif_flags &= ~TIFF_MAPPED; tif->tif_flags &= ~TIFF_MAPPED;
} }
/* /*
* Sometimes we do not want to read the first directory (for example, * Sometimes we do not want to read the first directory (for
* it may be broken) and want to proceed to other directories. I this * example, it may be broken) and want to proceed to other
* case we use the TIFF_HEADERONLY flag to open file and return * directories. I this case we use the TIFF_HEADERONLY flag to open
* immediately after reading TIFF header. * file and return immediately after reading TIFF header.
*/ */
if (tif->tif_flags & TIFF_HEADERONLY) if (tif->tif_flags & TIFF_HEADERONLY)
return (tif); return (tif);
@ -480,9 +626,8 @@ TIFFClientOpen(
/* /*
* Setup initial directory. * Setup initial directory.
*/ */
if (TIFFReadDirectory(tif)) { if (TIFFReadDirectory(tif))
tif->tif_rawcc = (tmsize_t)-1; {
tif->tif_flags |= TIFF_BUFFERSETUP;
return (tif); return (tif);
} }
break; break;
@ -510,17 +655,12 @@ bad2:
/* /*
* Return open file's name. * Return open file's name.
*/ */
const char * const char *TIFFFileName(TIFF *tif) { return (tif->tif_name); }
TIFFFileName(TIFF* tif)
{
return (tif->tif_name);
}
/* /*
* Set the file name. * Set the file name.
*/ */
const char * const char *TIFFSetFileName(TIFF *tif, const char *name)
TIFFSetFileName(TIFF* tif, const char *name)
{ {
const char *old_name = tif->tif_name; const char *old_name = tif->tif_name;
tif->tif_name = (char *)name; tif->tif_name = (char *)name;
@ -530,17 +670,12 @@ TIFFSetFileName(TIFF* tif, const char *name)
/* /*
* Return open file's I/O descriptor. * Return open file's I/O descriptor.
*/ */
int int TIFFFileno(TIFF *tif) { return (tif->tif_fd); }
TIFFFileno(TIFF* tif)
{
return (tif->tif_fd);
}
/* /*
* Set open file's I/O descriptor, and return previous value. * Set open file's I/O descriptor, and return previous value.
*/ */
int int TIFFSetFileno(TIFF *tif, int fd)
TIFFSetFileno(TIFF* tif, int fd)
{ {
int old_fd = tif->tif_fd; int old_fd = tif->tif_fd;
tif->tif_fd = fd; tif->tif_fd = fd;
@ -550,17 +685,12 @@ TIFFSetFileno(TIFF* tif, int fd)
/* /*
* Return open file's clientdata. * Return open file's clientdata.
*/ */
thandle_t thandle_t TIFFClientdata(TIFF *tif) { return (tif->tif_clientdata); }
TIFFClientdata(TIFF* tif)
{
return (tif->tif_clientdata);
}
/* /*
* Set open file's clientdata, and return previous value. * Set open file's clientdata, and return previous value.
*/ */
thandle_t thandle_t TIFFSetClientdata(TIFF *tif, thandle_t newvalue)
TIFFSetClientdata(TIFF* tif, thandle_t newvalue)
{ {
thandle_t m = tif->tif_clientdata; thandle_t m = tif->tif_clientdata;
tif->tif_clientdata = newvalue; tif->tif_clientdata = newvalue;
@ -570,17 +700,12 @@ TIFFSetClientdata(TIFF* tif, thandle_t newvalue)
/* /*
* Return read/write mode. * Return read/write mode.
*/ */
int int TIFFGetMode(TIFF *tif) { return (tif->tif_mode); }
TIFFGetMode(TIFF* tif)
{
return (tif->tif_mode);
}
/* /*
* Return read/write mode. * Return read/write mode.
*/ */
int int TIFFSetMode(TIFF *tif, int mode)
TIFFSetMode(TIFF* tif, int mode)
{ {
int old_mode = tif->tif_mode; int old_mode = tif->tif_mode;
tif->tif_mode = mode; tif->tif_mode = mode;
@ -591,152 +716,93 @@ TIFFSetMode(TIFF* tif, int mode)
* Return nonzero if file is organized in * Return nonzero if file is organized in
* tiles; zero if organized as strips. * tiles; zero if organized as strips.
*/ */
int int TIFFIsTiled(TIFF *tif) { return (isTiled(tif)); }
TIFFIsTiled(TIFF* tif)
{
return (isTiled(tif));
}
/* /*
* Return current row being read/written. * Return current row being read/written.
*/ */
uint32 uint32_t TIFFCurrentRow(TIFF *tif) { return (tif->tif_row); }
TIFFCurrentRow(TIFF* tif)
{
return (tif->tif_row);
}
/* /*
* Return index of the current directory. * Return index of the current directory.
*/ */
uint16 tdir_t TIFFCurrentDirectory(TIFF *tif) { return (tif->tif_curdir); }
TIFFCurrentDirectory(TIFF* tif)
{
return (tif->tif_curdir);
}
/* /*
* Return current strip. * Return current strip.
*/ */
uint32 uint32_t TIFFCurrentStrip(TIFF *tif) { return (tif->tif_curstrip); }
TIFFCurrentStrip(TIFF* tif)
{
return (tif->tif_curstrip);
}
/* /*
* Return current tile. * Return current tile.
*/ */
uint32 uint32_t TIFFCurrentTile(TIFF *tif) { return (tif->tif_curtile); }
TIFFCurrentTile(TIFF* tif)
{
return (tif->tif_curtile);
}
/* /*
* Return nonzero if the file has byte-swapped data. * Return nonzero if the file has byte-swapped data.
*/ */
int int TIFFIsByteSwapped(TIFF *tif) { return ((tif->tif_flags & TIFF_SWAB) != 0); }
TIFFIsByteSwapped(TIFF* tif)
{
return ((tif->tif_flags & TIFF_SWAB) != 0);
}
/* /*
* Return nonzero if the data is returned up-sampled. * Return nonzero if the data is returned up-sampled.
*/ */
int int TIFFIsUpSampled(TIFF *tif) { return (isUpSampled(tif)); }
TIFFIsUpSampled(TIFF* tif)
{
return (isUpSampled(tif));
}
/* /*
* Return nonzero if the data is returned in MSB-to-LSB bit order. * Return nonzero if the data is returned in MSB-to-LSB bit order.
*/ */
int int TIFFIsMSB2LSB(TIFF *tif) { return (isFillOrder(tif, FILLORDER_MSB2LSB)); }
TIFFIsMSB2LSB(TIFF* tif)
{
return (isFillOrder(tif, FILLORDER_MSB2LSB));
}
/* /*
* Return nonzero if given file was written in big-endian order. * Return nonzero if given file was written in big-endian order.
*/ */
int int TIFFIsBigEndian(TIFF *tif)
TIFFIsBigEndian(TIFF* tif)
{ {
return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN); return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN);
} }
/*
* Return nonzero if given file is BigTIFF style.
*/
int TIFFIsBigTIFF(TIFF *tif)
{
return (tif->tif_header.common.tiff_version == TIFF_VERSION_BIG);
}
/* /*
* Return pointer to file read method. * Return pointer to file read method.
*/ */
TIFFReadWriteProc TIFFReadWriteProc TIFFGetReadProc(TIFF *tif) { return (tif->tif_readproc); }
TIFFGetReadProc(TIFF* tif)
{
return (tif->tif_readproc);
}
/* /*
* Return pointer to file write method. * Return pointer to file write method.
*/ */
TIFFReadWriteProc TIFFReadWriteProc TIFFGetWriteProc(TIFF *tif) { return (tif->tif_writeproc); }
TIFFGetWriteProc(TIFF* tif)
{
return (tif->tif_writeproc);
}
/* /*
* Return pointer to file seek method. * Return pointer to file seek method.
*/ */
TIFFSeekProc TIFFSeekProc TIFFGetSeekProc(TIFF *tif) { return (tif->tif_seekproc); }
TIFFGetSeekProc(TIFF* tif)
{
return (tif->tif_seekproc);
}
/* /*
* Return pointer to file close method. * Return pointer to file close method.
*/ */
TIFFCloseProc TIFFCloseProc TIFFGetCloseProc(TIFF *tif) { return (tif->tif_closeproc); }
TIFFGetCloseProc(TIFF* tif)
{
return (tif->tif_closeproc);
}
/* /*
* Return pointer to file size requesting method. * Return pointer to file size requesting method.
*/ */
TIFFSizeProc TIFFSizeProc TIFFGetSizeProc(TIFF *tif) { return (tif->tif_sizeproc); }
TIFFGetSizeProc(TIFF* tif)
{
return (tif->tif_sizeproc);
}
/* /*
* Return pointer to memory mapping method. * Return pointer to memory mapping method.
*/ */
TIFFMapFileProc TIFFMapFileProc TIFFGetMapFileProc(TIFF *tif) { return (tif->tif_mapproc); }
TIFFGetMapFileProc(TIFF* tif)
{
return (tif->tif_mapproc);
}
/* /*
* Return pointer to memory unmapping method. * Return pointer to memory unmapping method.
*/ */
TIFFUnmapFileProc TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF *tif)
TIFFGetUnmapFileProc(TIFF* tif)
{ {
return (tif->tif_unmapproc); return (tif->tif_unmapproc);
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

192
3rdparty/libtiff/tif_packbits.c vendored
View File

@ -31,12 +31,11 @@
*/ */
#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);
/* /*
@ -49,34 +48,39 @@ PackBitsPreEncode(TIFF* tif, uint16 s)
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.
*/ */
@ -86,14 +90,16 @@ PackBitsEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
for (; cc > 0 && b == *bp; cc--, bp++) for (; cc > 0 && b == *bp; cc--, bp++)
n++; n++;
again: again:
if (op + 2 >= ep) { /* insure space for new data */ if (op + 2 >= ep)
{ /* insure space for new data */
/* /*
* Be careful about writing the last * Be careful about writing the last
* literal. Must write up to that point * literal. Must write up to that point
* and then copy the remainder to the * and then copy the remainder to the
* front of the buffer. * front of the buffer.
*/ */
if (state == LITERAL || state == LITERAL_RUN) { if (state == LITERAL || state == LITERAL_RUN)
{
slop = (long)(op - lastliteral); slop = (long)(op - lastliteral);
tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp); tif->tif_rawcc += (tmsize_t)(lastliteral - tif->tif_rawcp);
if (!TIFFFlushData1(tif)) if (!TIFFFlushData1(tif))
@ -102,63 +108,78 @@ PackBitsEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
while (slop-- > 0) while (slop-- > 0)
*op++ = *lastliteral++; *op++ = *lastliteral++;
lastliteral = tif->tif_rawcp; lastliteral = tif->tif_rawcp;
} else { }
else
{
tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp); tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
if (!TIFFFlushData1(tif)) if (!TIFFFlushData1(tif))
return (0); return (0);
op = tif->tif_rawcp; op = tif->tif_rawcp;
} }
} }
switch (state) { switch (state)
{
case BASE: /* initial state, set run/literal */ case BASE: /* initial state, set run/literal */
if (n > 1) { if (n > 1)
{
state = RUN; state = RUN;
if (n > 128) { if (n > 128)
*op++ = (uint8) -127; {
*op++ = (uint8) b; *op++ = (uint8_t)-127;
*op++ = (uint8_t)b;
n -= 128; n -= 128;
goto again; goto again;
} }
*op++ = (uint8)(-(n-1)); *op++ = (uint8_t)(-(n - 1));
*op++ = (uint8) b; *op++ = (uint8_t)b;
} else { }
else
{
lastliteral = op; lastliteral = op;
*op++ = 0; *op++ = 0;
*op++ = (uint8) b; *op++ = (uint8_t)b;
state = LITERAL; state = LITERAL;
} }
break; break;
case LITERAL: /* last object was literal string */ case LITERAL: /* last object was literal string */
if (n > 1) { if (n > 1)
{
state = LITERAL_RUN; state = LITERAL_RUN;
if (n > 128) { if (n > 128)
*op++ = (uint8) -127; {
*op++ = (uint8) b; *op++ = (uint8_t)-127;
*op++ = (uint8_t)b;
n -= 128; n -= 128;
goto again; goto again;
} }
*op++ = (uint8)(-(n-1)); /* encode run */ *op++ = (uint8_t)(-(n - 1)); /* encode run */
*op++ = (uint8) b; *op++ = (uint8_t)b;
} else { /* extend literal */ }
else
{ /* extend literal */
if (++(*lastliteral) == 127) if (++(*lastliteral) == 127)
state = BASE; state = BASE;
*op++ = (uint8) b; *op++ = (uint8_t)b;
} }
break; break;
case RUN: /* last object was run */ case RUN: /* last object was run */
if (n > 1) { if (n > 1)
if (n > 128) { {
*op++ = (uint8) -127; if (n > 128)
*op++ = (uint8) b; {
*op++ = (uint8_t)-127;
*op++ = (uint8_t)b;
n -= 128; n -= 128;
goto again; goto again;
} }
*op++ = (uint8)(-(n-1)); *op++ = (uint8_t)(-(n - 1));
*op++ = (uint8) b; *op++ = (uint8_t)b;
} else { }
else
{
lastliteral = op; lastliteral = op;
*op++ = 0; *op++ = 0;
*op++ = (uint8) b; *op++ = (uint8_t)b;
state = LITERAL; state = LITERAL;
} }
break; break;
@ -169,12 +190,12 @@ PackBitsEncode(TIFF* tif, uint8* buf, tmsize_t cc, uint16 s)
* case we convert literal-run-literal * case we convert literal-run-literal
* to a single literal. * to a single literal.
*/ */
if (n == 1 && op[-2] == (uint8) -1 && if (n == 1 && op[-2] == (uint8_t)-1 && *lastliteral < 126)
*lastliteral < 126) { {
state = (((*lastliteral) += 2) == 127 ? state = (((*lastliteral) += 2) == 127 ? BASE : LITERAL);
BASE : LITERAL);
op[-2] = op[-1]; /* replicate */ op[-2] = op[-1]; /* replicate */
} else }
else
state = RUN; state = RUN;
goto again; goto again;
} }
@ -191,12 +212,12 @@ 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) if (cc < chunk)
@ -210,41 +231,38 @@ PackBitsEncodeChunk(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
return (1); 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++; n = (long)*bp++;
cc--; cc--;
/* if (n < 0)
* Watch out for compilers that { /* replicate next byte -n+1 times */
* don't sign extend chars...
*/
if (n >= 128)
n -= 256;
if (n < 0) { /* replicate next byte -n+1 times */
if (n == -128) /* nop */ if (n == -128) /* nop */
continue; continue;
n = -n + 1; n = -n + 1;
if (occ < (tmsize_t)n) if (occ < (tmsize_t)n)
{ {
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)); " bytes to avoid buffer overrun",
(tmsize_t)n - occ);
n = (long)occ; n = (long)occ;
} }
if (cc == 0) if (cc == 0)
{ {
TIFFWarningExt(tif->tif_clientdata, module, TIFFWarningExtR(
tif, module,
"Terminating PackBitsDecode due to lack of data."); "Terminating PackBitsDecode due to lack of data.");
break; break;
} }
@ -252,39 +270,44 @@ PackBitsDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
b = *bp++; b = *bp++;
cc--; cc--;
while (n-- > 0) while (n-- > 0)
*op++ = (uint8) b; *op++ = (uint8_t)b;
} else { /* copy next n+1 bytes literally */ }
else
{ /* 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",
(tmsize_t)n - occ + 1);
n = (long)occ - 1; n = (long)occ - 1;
} }
if (cc < (tmsize_t)(n + 1)) if (cc < (tmsize_t)(n + 1))
{ {
TIFFWarningExt(tif->tif_clientdata, module, TIFFWarningExtR(
tif, module,
"Terminating PackBitsDecode due to lack of data."); "Terminating PackBitsDecode due to lack of data.");
break; break;
} }
_TIFFmemcpy(op, bp, ++n); _TIFFmemcpy(op, bp, ++n);
op += n; occ -= n; op += n;
bp += n; cc -= n; occ -= n;
bp += n;
cc -= n;
} }
} }
tif->tif_rawcp = (uint8*) bp; tif->tif_rawcp = (uint8_t *)bp;
tif->tif_rawcc = cc; tif->tif_rawcc = cc;
if (occ > 0) { if (occ > 0)
TIFFErrorExt(tif->tif_clientdata, module, {
"Not enough data for scanline %lu", TIFFErrorExtR(tif, module, "Not enough data for scanline %" PRIu32,
(unsigned long) tif->tif_row); tif->tif_row);
return (0); return (0);
} }
return (1); 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;
@ -298,12 +321,3 @@ TIFFInitPackBits(TIFF* tif, int scheme)
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:
*/

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

17
3rdparty/libtiff/tif_predict.h vendored
View File

@ -32,14 +32,15 @@
* ``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 */ int predictor; /* predictor tag value */
tmsize_t stride; /* sample stride over data */ tmsize_t stride; /* sample stride over data */
tmsize_t rowsize; /* tile/strip row size */ tmsize_t rowsize; /* tile/strip row size */
@ -62,7 +63,8 @@ typedef struct {
} 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 *);
@ -70,12 +72,3 @@ extern int TIFFPredictorCleanup(TIFF*);
} }
#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:
*/

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

@ -32,8 +32,7 @@
#include <ctype.h> #include <ctype.h>
static void static void _TIFFprintAsciiBounded(FILE *fd, const char *cp, size_t max_chars);
_TIFFprintAsciiBounded(FILE* fd, const char* cp, size_t max_chars);
static const char *const photoNames[] = { static const char *const photoNames[] = {
"min-is-white", /* PHOTOMETRIC_MINISWHITE */ "min-is-white", /* PHOTOMETRIC_MINISWHITE */
@ -63,69 +62,81 @@ static const char * const orientNames[] = {
}; };
#define NORIENTNAMES (sizeof(orientNames) / sizeof(orientNames[0])) #define NORIENTNAMES (sizeof(orientNames) / sizeof(orientNames[0]))
static void static const struct tagname
_TIFFPrintField(FILE* fd, const TIFFField *fip,
uint32 value_count, void *raw_data)
{ {
uint32 j; uint16_t tag;
const char *name;
} tagnames[] = {
{TIFFTAG_GDAL_METADATA, "GDAL Metadata"},
{TIFFTAG_GDAL_NODATA, "GDAL NoDataValue"},
};
#define NTAGS (sizeof(tagnames) / sizeof(tagnames[0]))
fprintf(fd, " %s: ", fip->field_name); static void _TIFFPrintField(FILE *fd, const TIFFField *fip,
uint32_t value_count, void *raw_data)
{
uint32_t j;
for(j = 0; j < value_count; j++) { /* Print a user-friendly name for tags of relatively common use, but */
/* which aren't registered by libtiff itself. */
const char *field_name = fip->field_name;
if (TIFFFieldIsAnonymous(fip))
{
for (size_t i = 0; i < NTAGS; ++i)
{
if (fip->field_tag == tagnames[i].tag)
{
field_name = tagnames[i].name;
break;
}
}
}
fprintf(fd, " %s: ", field_name);
for (j = 0; j < value_count; j++)
{
if (fip->field_type == TIFF_BYTE) if (fip->field_type == TIFF_BYTE)
fprintf(fd, "%u", ((uint8 *) raw_data)[j]); fprintf(fd, "%" PRIu8, ((uint8_t *)raw_data)[j]);
else if (fip->field_type == TIFF_UNDEFINED) else if (fip->field_type == TIFF_UNDEFINED)
fprintf(fd, "0x%x", fprintf(fd, "0x%" PRIx8, ((uint8_t *)raw_data)[j]);
(unsigned int) ((unsigned char *) raw_data)[j]);
else if (fip->field_type == TIFF_SBYTE) else if (fip->field_type == TIFF_SBYTE)
fprintf(fd, "%d", ((int8 *) raw_data)[j]); fprintf(fd, "%" PRId8, ((int8_t *)raw_data)[j]);
else if (fip->field_type == TIFF_SHORT) else if (fip->field_type == TIFF_SHORT)
fprintf(fd, "%u", ((uint16 *) raw_data)[j]); fprintf(fd, "%" PRIu16, ((uint16_t *)raw_data)[j]);
else if (fip->field_type == TIFF_SSHORT) else if (fip->field_type == TIFF_SSHORT)
fprintf(fd, "%d", ((int16 *) raw_data)[j]); fprintf(fd, "%" PRId16, ((int16_t *)raw_data)[j]);
else if (fip->field_type == TIFF_LONG) else if (fip->field_type == TIFF_LONG)
fprintf(fd, "%lu", fprintf(fd, "%" PRIu32, ((uint32_t *)raw_data)[j]);
(unsigned long)((uint32 *) raw_data)[j]);
else if (fip->field_type == TIFF_SLONG) else if (fip->field_type == TIFF_SLONG)
fprintf(fd, "%ld", (long)((int32 *) raw_data)[j]); fprintf(fd, "%" PRId32, ((int32_t *)raw_data)[j]);
else if (fip->field_type == TIFF_IFD) else if (fip->field_type == TIFF_IFD)
fprintf(fd, "0x%lx", fprintf(fd, "0x%" PRIx32, ((uint32_t *)raw_data)[j]);
(unsigned long)((uint32 *) raw_data)[j]); else if (fip->field_type == TIFF_RATIONAL ||
else if(fip->field_type == TIFF_RATIONAL fip->field_type == TIFF_SRATIONAL)
|| fip->field_type == TIFF_SRATIONAL {
|| fip->field_type == TIFF_FLOAT) int tv_size = TIFFFieldSetGetSize(fip);
if (tv_size == 8)
fprintf(fd, "%lf", ((double *)raw_data)[j]);
else
fprintf(fd, "%f", ((float *)raw_data)[j]); fprintf(fd, "%f", ((float *)raw_data)[j]);
else if(fip->field_type == TIFF_LONG8) }
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
fprintf(fd, "%I64u",
(unsigned __int64)((uint64 *) raw_data)[j]);
#else
fprintf(fd, "%llu",
(unsigned long long)((uint64 *) raw_data)[j]);
#endif
else if(fip->field_type == TIFF_SLONG8)
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
fprintf(fd, "%I64d", (__int64)((int64 *) raw_data)[j]);
#else
fprintf(fd, "%lld", (long long)((int64 *) raw_data)[j]);
#endif
else if(fip->field_type == TIFF_IFD8)
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
fprintf(fd, "0x%I64x",
(unsigned __int64)((uint64 *) raw_data)[j]);
#else
fprintf(fd, "0x%llx",
(unsigned long long)((uint64 *) raw_data)[j]);
#endif
else if (fip->field_type == TIFF_FLOAT) else if (fip->field_type == TIFF_FLOAT)
fprintf(fd, "%f", ((float *)raw_data)[j]); fprintf(fd, "%f", ((float *)raw_data)[j]);
else if (fip->field_type == TIFF_LONG8)
fprintf(fd, "%" PRIu64, ((uint64_t *)raw_data)[j]);
else if (fip->field_type == TIFF_SLONG8)
fprintf(fd, "%" PRId64, ((int64_t *)raw_data)[j]);
else if (fip->field_type == TIFF_IFD8)
fprintf(fd, "0x%" PRIx64, ((uint64_t *)raw_data)[j]);
else if (fip->field_type == TIFF_DOUBLE) else if (fip->field_type == TIFF_DOUBLE)
fprintf(fd, "%f", ((double *) raw_data)[j]); fprintf(fd, "%lf", ((double *)raw_data)[j]);
else if(fip->field_type == TIFF_ASCII) { else if (fip->field_type == TIFF_ASCII)
{
fprintf(fd, "%s", (char *)raw_data); fprintf(fd, "%s", (char *)raw_data);
break; break;
} }
else { else
{
fprintf(fd, "<unsupported data type in TIFFPrint>"); fprintf(fd, "<unsupported data type in TIFFPrint>");
break; break;
} }
@ -137,30 +148,33 @@ _TIFFPrintField(FILE* fd, const TIFFField *fip,
fprintf(fd, "\n"); fprintf(fd, "\n");
} }
static int static int _TIFFPrettyPrintField(TIFF *tif, const TIFFField *fip, FILE *fd,
_TIFFPrettyPrintField(TIFF* tif, const TIFFField *fip, FILE* fd, uint32 tag, uint32_t tag, uint32_t value_count,
uint32 value_count, void *raw_data) void *raw_data)
{ {
(void)tif; (void)tif;
/* do not try to pretty print auto-defined fields */ /* do not try to pretty print auto-defined fields */
if (strncmp(fip->field_name,"Tag ", 4) == 0) { if (TIFFFieldIsAnonymous(fip))
{
return 0; return 0;
} }
switch (tag) switch (tag)
{ {
case TIFFTAG_INKSET: case TIFFTAG_INKSET:
if (value_count == 2 && fip->field_type == TIFF_SHORT) { if (value_count == 2 && fip->field_type == TIFF_SHORT)
{
fprintf(fd, " Ink Set: "); fprintf(fd, " Ink Set: ");
switch (*((uint16*)raw_data)) { switch (*((uint16_t *)raw_data))
{
case INKSET_CMYK: case INKSET_CMYK:
fprintf(fd, "CMYK\n"); fprintf(fd, "CMYK\n");
break; break;
default: default:
fprintf(fd, "%u (0x%x)\n", fprintf(fd, "%" PRIu16 " (0x%" PRIx16 ")\n",
*((uint16*)raw_data), *((uint16_t *)raw_data),
*((uint16*)raw_data)); *((uint16_t *)raw_data));
break; break;
} }
return 1; return 1;
@ -168,24 +182,26 @@ _TIFFPrettyPrintField(TIFF* tif, const TIFFField *fip, FILE* fd, uint32 tag,
return 0; return 0;
case TIFFTAG_DOTRANGE: case TIFFTAG_DOTRANGE:
if (value_count == 2 && fip->field_type == TIFF_SHORT) { if (value_count == 2 && fip->field_type == TIFF_SHORT)
fprintf(fd, " Dot Range: %u-%u\n", {
((uint16*)raw_data)[0], ((uint16*)raw_data)[1]); fprintf(fd, " Dot Range: %" PRIu16 "-%" PRIu16 "\n",
((uint16_t *)raw_data)[0], ((uint16_t *)raw_data)[1]);
return 1; return 1;
} }
return 0; return 0;
case TIFFTAG_WHITEPOINT: case TIFFTAG_WHITEPOINT:
if (value_count == 2 && fip->field_type == TIFF_RATIONAL) { if (value_count == 2 && fip->field_type == TIFF_RATIONAL)
fprintf(fd, " White Point: %g-%g\n", {
((float *)raw_data)[0], ((float *)raw_data)[1]); fprintf(fd, " White Point: %g-%g\n", ((float *)raw_data)[0],
((float *)raw_data)[1]);
return 1; return 1;
} }
return 0; return 0;
case TIFFTAG_XMLPACKET: case TIFFTAG_XMLPACKET:
{ {
uint32 i; uint32_t i;
fprintf(fd, " XMLPacket (XMP Metadata):\n"); fprintf(fd, " XMLPacket (XMP Metadata):\n");
for (i = 0; i < value_count; i++) for (i = 0; i < value_count; i++)
@ -194,29 +210,24 @@ _TIFFPrettyPrintField(TIFF* tif, const TIFFField *fip, FILE* fd, uint32 tag,
return 1; return 1;
} }
case TIFFTAG_RICHTIFFIPTC: case TIFFTAG_RICHTIFFIPTC:
/* fprintf(fd, " RichTIFFIPTC Data: <present>, %" PRIu32 " bytes\n",
* XXX: for some weird reason RichTIFFIPTC tag value_count);
* defined as array of LONG values.
*/
fprintf(fd,
" RichTIFFIPTC Data: <present>, %lu bytes\n",
(unsigned long) value_count * 4);
return 1; return 1;
case TIFFTAG_PHOTOSHOP: case TIFFTAG_PHOTOSHOP:
fprintf(fd, " Photoshop Data: <present>, %lu bytes\n", fprintf(fd, " Photoshop Data: <present>, %" PRIu32 " bytes\n",
(unsigned long) value_count); value_count);
return 1; return 1;
case TIFFTAG_ICCPROFILE: case TIFFTAG_ICCPROFILE:
fprintf(fd, " ICC Profile: <present>, %lu bytes\n", fprintf(fd, " ICC Profile: <present>, %" PRIu32 " bytes\n",
(unsigned long) value_count); value_count);
return 1; return 1;
case TIFFTAG_STONITS: case TIFFTAG_STONITS:
if (value_count == 1 && fip->field_type == TIFF_DOUBLE) { if (value_count == 1 && fip->field_type == TIFF_DOUBLE)
fprintf(fd, {
" Sample to Nits conversion factor: %.4e\n", fprintf(fd, " Sample to Nits conversion factor: %.4e\n",
*((double *)raw_data)); *((double *)raw_data));
return 1; return 1;
} }
@ -230,59 +241,57 @@ _TIFFPrettyPrintField(TIFF* tif, const TIFFField *fip, FILE* fd, uint32 tag,
* Print the contents of the current directory * Print the contents of the current directory
* to the specified stdio file stream. * to the specified stdio file stream.
*/ */
void void TIFFPrintDirectory(TIFF *tif, FILE *fd, long flags)
TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
char *sep; char *sep;
long l, n; long l, n;
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) fprintf(fd, "TIFF Directory at offset 0x%" PRIx64 " (%" PRIu64 ")\n",
fprintf(fd, "TIFF Directory at offset 0x%I64x (%I64u)\n", tif->tif_diroff, tif->tif_diroff);
(unsigned __int64) tif->tif_diroff, if (TIFFFieldSet(tif, FIELD_SUBFILETYPE))
(unsigned __int64) tif->tif_diroff); {
#else
fprintf(fd, "TIFF Directory at offset 0x%llx (%llu)\n",
(unsigned long long) tif->tif_diroff,
(unsigned long long) tif->tif_diroff);
#endif
if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) {
fprintf(fd, " Subfile Type:"); fprintf(fd, " Subfile Type:");
sep = " "; sep = " ";
if (td->td_subfiletype & FILETYPE_REDUCEDIMAGE) { if (td->td_subfiletype & FILETYPE_REDUCEDIMAGE)
{
fprintf(fd, "%sreduced-resolution image", sep); fprintf(fd, "%sreduced-resolution image", sep);
sep = "/"; sep = "/";
} }
if (td->td_subfiletype & FILETYPE_PAGE) { if (td->td_subfiletype & FILETYPE_PAGE)
{
fprintf(fd, "%smulti-page document", sep); fprintf(fd, "%smulti-page document", sep);
sep = "/"; sep = "/";
} }
if (td->td_subfiletype & FILETYPE_MASK) if (td->td_subfiletype & FILETYPE_MASK)
fprintf(fd, "%stransparency mask", sep); fprintf(fd, "%stransparency mask", sep);
fprintf(fd, " (%lu = 0x%lx)\n", fprintf(fd, " (%" PRIu32 " = 0x%" PRIx32 ")\n", td->td_subfiletype,
(unsigned long) td->td_subfiletype, (long) td->td_subfiletype); td->td_subfiletype);
} }
if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) { if (TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS))
fprintf(fd, " Image Width: %lu Image Length: %lu", {
(unsigned long) td->td_imagewidth, (unsigned long) td->td_imagelength); fprintf(fd, " Image Width: %" PRIu32 " Image Length: %" PRIu32,
td->td_imagewidth, td->td_imagelength);
if (TIFFFieldSet(tif, FIELD_IMAGEDEPTH)) if (TIFFFieldSet(tif, FIELD_IMAGEDEPTH))
fprintf(fd, " Image Depth: %lu", fprintf(fd, " Image Depth: %" PRIu32, td->td_imagedepth);
(unsigned long) td->td_imagedepth);
fprintf(fd, "\n"); fprintf(fd, "\n");
} }
if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)) { if (TIFFFieldSet(tif, FIELD_TILEDIMENSIONS))
fprintf(fd, " Tile Width: %lu Tile Length: %lu", {
(unsigned long) td->td_tilewidth, (unsigned long) td->td_tilelength); fprintf(fd, " Tile Width: %" PRIu32 " Tile Length: %" PRIu32,
td->td_tilewidth, td->td_tilelength);
if (TIFFFieldSet(tif, FIELD_TILEDEPTH)) if (TIFFFieldSet(tif, FIELD_TILEDEPTH))
fprintf(fd, " Tile Depth: %lu", fprintf(fd, " Tile Depth: %" PRIu32, td->td_tiledepth);
(unsigned long) td->td_tiledepth);
fprintf(fd, "\n"); fprintf(fd, "\n");
} }
if (TIFFFieldSet(tif,FIELD_RESOLUTION)) { if (TIFFFieldSet(tif, FIELD_RESOLUTION))
fprintf(fd, " Resolution: %g, %g", {
td->td_xresolution, td->td_yresolution); fprintf(fd, " Resolution: %g, %g", td->td_xresolution,
if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)) { td->td_yresolution);
switch (td->td_resolutionunit) { if (TIFFFieldSet(tif, FIELD_RESOLUTIONUNIT))
{
switch (td->td_resolutionunit)
{
case RESUNIT_NONE: case RESUNIT_NONE:
fprintf(fd, " (unitless)"); fprintf(fd, " (unitless)");
break; break;
@ -293,22 +302,22 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
fprintf(fd, " pixels/cm"); fprintf(fd, " pixels/cm");
break; break;
default: default:
fprintf(fd, " (unit %u = 0x%x)", fprintf(fd, " (unit %" PRIu16 " = 0x%" PRIx16 ")",
td->td_resolutionunit, td->td_resolutionunit, td->td_resolutionunit);
td->td_resolutionunit);
break; break;
} }
} }
fprintf(fd, "\n"); fprintf(fd, "\n");
} }
if (TIFFFieldSet(tif, FIELD_POSITION)) if (TIFFFieldSet(tif, FIELD_POSITION))
fprintf(fd, " Position: %g, %g\n", fprintf(fd, " Position: %g, %g\n", td->td_xposition, td->td_yposition);
td->td_xposition, td->td_yposition);
if (TIFFFieldSet(tif, FIELD_BITSPERSAMPLE)) if (TIFFFieldSet(tif, FIELD_BITSPERSAMPLE))
fprintf(fd, " Bits/Sample: %u\n", td->td_bitspersample); fprintf(fd, " Bits/Sample: %" PRIu16 "\n", td->td_bitspersample);
if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)) { if (TIFFFieldSet(tif, FIELD_SAMPLEFORMAT))
{
fprintf(fd, " Sample Format: "); fprintf(fd, " Sample Format: ");
switch (td->td_sampleformat) { switch (td->td_sampleformat)
{
case SAMPLEFORMAT_VOID: case SAMPLEFORMAT_VOID:
fprintf(fd, "void\n"); fprintf(fd, "void\n");
break; break;
@ -328,26 +337,30 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
fprintf(fd, "complex IEEE floating point\n"); fprintf(fd, "complex IEEE floating point\n");
break; break;
default: default:
fprintf(fd, "%u (0x%x)\n", fprintf(fd, "%" PRIu16 " (0x%" PRIx16 ")\n",
td->td_sampleformat, td->td_sampleformat); td->td_sampleformat, td->td_sampleformat);
break; break;
} }
} }
if (TIFFFieldSet(tif,FIELD_COMPRESSION)) { if (TIFFFieldSet(tif, FIELD_COMPRESSION))
{
const TIFFCodec *c = TIFFFindCODEC(td->td_compression); const TIFFCodec *c = TIFFFindCODEC(td->td_compression);
fprintf(fd, " Compression Scheme: "); fprintf(fd, " Compression Scheme: ");
if (c) if (c)
fprintf(fd, "%s\n", c->name); fprintf(fd, "%s\n", c->name);
else else
fprintf(fd, "%u (0x%x)\n", fprintf(fd, "%" PRIu16 " (0x%" PRIx16 ")\n", td->td_compression,
td->td_compression, td->td_compression); td->td_compression);
} }
if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) { if (TIFFFieldSet(tif, FIELD_PHOTOMETRIC))
{
fprintf(fd, " Photometric Interpretation: "); fprintf(fd, " Photometric Interpretation: ");
if (td->td_photometric < NPHOTONAMES) if (td->td_photometric < NPHOTONAMES)
fprintf(fd, "%s\n", photoNames[td->td_photometric]); fprintf(fd, "%s\n", photoNames[td->td_photometric]);
else { else
switch (td->td_photometric) { {
switch (td->td_photometric)
{
case PHOTOMETRIC_LOGL: case PHOTOMETRIC_LOGL:
fprintf(fd, "CIE Log2(L)\n"); fprintf(fd, "CIE Log2(L)\n");
break; break;
@ -355,18 +368,21 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
fprintf(fd, "CIE Log2(L) (u',v')\n"); fprintf(fd, "CIE Log2(L) (u',v')\n");
break; break;
default: default:
fprintf(fd, "%u (0x%x)\n", fprintf(fd, "%" PRIu16 " (0x%" PRIx16 ")\n",
td->td_photometric, td->td_photometric); td->td_photometric, td->td_photometric);
break; break;
} }
} }
} }
if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES) && td->td_extrasamples) { if (TIFFFieldSet(tif, FIELD_EXTRASAMPLES) && td->td_extrasamples)
uint16 i; {
fprintf(fd, " Extra Samples: %u<", td->td_extrasamples); uint16_t i;
fprintf(fd, " Extra Samples: %" PRIu16 "<", td->td_extrasamples);
sep = ""; sep = "";
for (i = 0; i < td->td_extrasamples; i++) { for (i = 0; i < td->td_extrasamples; i++)
switch (td->td_sampleinfo[i]) { {
switch (td->td_sampleinfo[i])
{
case EXTRASAMPLE_UNSPECIFIED: case EXTRASAMPLE_UNSPECIFIED:
fprintf(fd, "%sunspecified", sep); fprintf(fd, "%sunspecified", sep);
break; break;
@ -377,7 +393,7 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
fprintf(fd, "%sunassoc-alpha", sep); fprintf(fd, "%sunassoc-alpha", sep);
break; break;
default: default:
fprintf(fd, "%s%u (0x%x)", sep, fprintf(fd, "%s%" PRIu16 " (0x%" PRIx16 ")", sep,
td->td_sampleinfo[i], td->td_sampleinfo[i]); td->td_sampleinfo[i], td->td_sampleinfo[i]);
break; break;
} }
@ -385,26 +401,33 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
} }
fprintf(fd, ">\n"); fprintf(fd, ">\n");
} }
if (TIFFFieldSet(tif,FIELD_INKNAMES)) { if (TIFFFieldSet(tif, FIELD_INKNAMES))
{
char *cp; char *cp;
uint16 i; uint16_t i;
fprintf(fd, " Ink Names: "); fprintf(fd, " Ink Names: ");
i = td->td_samplesperpixel; i = td->td_samplesperpixel;
sep = ""; sep = "";
for (cp = td->td_inknames; for (cp = td->td_inknames;
i > 0 && cp < td->td_inknames + td->td_inknameslen; i > 0 && cp < td->td_inknames + td->td_inknameslen;
cp = strchr(cp,'\0')+1, i--) { cp = strchr(cp, '\0') + 1, i--)
size_t max_chars = {
td->td_inknameslen - (cp - td->td_inknames); size_t max_chars = td->td_inknameslen - (cp - td->td_inknames);
fputs(sep, fd); fputs(sep, fd);
_TIFFprintAsciiBounded(fd, cp, max_chars); _TIFFprintAsciiBounded(fd, cp, max_chars);
sep = ", "; sep = ", ";
} }
fputs("\n", fd); fputs("\n", fd);
} }
if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)) { if (TIFFFieldSet(tif, FIELD_NUMBEROFINKS))
{
fprintf(fd, " NumberOfInks: %d\n", td->td_numberofinks);
}
if (TIFFFieldSet(tif, FIELD_THRESHHOLDING))
{
fprintf(fd, " Thresholding: "); fprintf(fd, " Thresholding: ");
switch (td->td_threshholding) { switch (td->td_threshholding)
{
case THRESHHOLD_BILEVEL: case THRESHHOLD_BILEVEL:
fprintf(fd, "bilevel art scan\n"); fprintf(fd, "bilevel art scan\n");
break; break;
@ -415,14 +438,16 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
fprintf(fd, "error diffused\n"); fprintf(fd, "error diffused\n");
break; break;
default: default:
fprintf(fd, "%u (0x%x)\n", fprintf(fd, "%" PRIu16 " (0x%" PRIx16 ")\n",
td->td_threshholding, td->td_threshholding); td->td_threshholding, td->td_threshholding);
break; break;
} }
} }
if (TIFFFieldSet(tif,FIELD_FILLORDER)) { if (TIFFFieldSet(tif, FIELD_FILLORDER))
{
fprintf(fd, " FillOrder: "); fprintf(fd, " FillOrder: ");
switch (td->td_fillorder) { switch (td->td_fillorder)
{
case FILLORDER_MSB2LSB: case FILLORDER_MSB2LSB:
fprintf(fd, "msb-to-lsb\n"); fprintf(fd, "msb-to-lsb\n");
break; break;
@ -430,19 +455,21 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
fprintf(fd, "lsb-to-msb\n"); fprintf(fd, "lsb-to-msb\n");
break; break;
default: default:
fprintf(fd, "%u (0x%x)\n", fprintf(fd, "%" PRIu16 " (0x%" PRIx16 ")\n", td->td_fillorder,
td->td_fillorder, td->td_fillorder); td->td_fillorder);
break; break;
} }
} }
if (TIFFFieldSet(tif, FIELD_YCBCRSUBSAMPLING)) if (TIFFFieldSet(tif, FIELD_YCBCRSUBSAMPLING))
{ {
fprintf(fd, " YCbCr Subsampling: %u, %u\n", fprintf(fd, " YCbCr Subsampling: %" PRIu16 ", %" PRIu16 "\n",
td->td_ycbcrsubsampling[0], td->td_ycbcrsubsampling[1]); td->td_ycbcrsubsampling[0], td->td_ycbcrsubsampling[1]);
} }
if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) { if (TIFFFieldSet(tif, FIELD_YCBCRPOSITIONING))
{
fprintf(fd, " YCbCr Positioning: "); fprintf(fd, " YCbCr Positioning: ");
switch (td->td_ycbcrpositioning) { switch (td->td_ycbcrpositioning)
{
case YCBCRPOSITION_CENTERED: case YCBCRPOSITION_CENTERED:
fprintf(fd, "centered\n"); fprintf(fd, "centered\n");
break; break;
@ -450,54 +477,62 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
fprintf(fd, "cosited\n"); fprintf(fd, "cosited\n");
break; break;
default: default:
fprintf(fd, "%u (0x%x)\n", fprintf(fd, "%" PRIu16 " (0x%" PRIx16 ")\n",
td->td_ycbcrpositioning, td->td_ycbcrpositioning); td->td_ycbcrpositioning, td->td_ycbcrpositioning);
break; break;
} }
} }
if (TIFFFieldSet(tif, FIELD_HALFTONEHINTS)) if (TIFFFieldSet(tif, FIELD_HALFTONEHINTS))
fprintf(fd, " Halftone Hints: light %u dark %u\n", fprintf(fd, " Halftone Hints: light %" PRIu16 " dark %" PRIu16 "\n",
td->td_halftonehints[0], td->td_halftonehints[1]); td->td_halftonehints[0], td->td_halftonehints[1]);
if (TIFFFieldSet(tif,FIELD_ORIENTATION)) { if (TIFFFieldSet(tif, FIELD_ORIENTATION))
{
fprintf(fd, " Orientation: "); fprintf(fd, " Orientation: ");
if (td->td_orientation < NORIENTNAMES) if (td->td_orientation < NORIENTNAMES)
fprintf(fd, "%s\n", orientNames[td->td_orientation]); fprintf(fd, "%s\n", orientNames[td->td_orientation]);
else else
fprintf(fd, "%u (0x%x)\n", fprintf(fd, "%" PRIu16 " (0x%" PRIx16 ")\n", td->td_orientation,
td->td_orientation, td->td_orientation); td->td_orientation);
} }
if (TIFFFieldSet(tif, FIELD_SAMPLESPERPIXEL)) if (TIFFFieldSet(tif, FIELD_SAMPLESPERPIXEL))
fprintf(fd, " Samples/Pixel: %u\n", td->td_samplesperpixel); fprintf(fd, " Samples/Pixel: %" PRIx16 "\n", td->td_samplesperpixel);
if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)) { if (TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))
{
fprintf(fd, " Rows/Strip: "); fprintf(fd, " Rows/Strip: ");
if (td->td_rowsperstrip == (uint32) -1) if (td->td_rowsperstrip == (uint32_t)-1)
fprintf(fd, "(infinite)\n"); fprintf(fd, "(infinite)\n");
else else
fprintf(fd, "%lu\n", (unsigned long) td->td_rowsperstrip); fprintf(fd, "%" PRIu32 "\n", td->td_rowsperstrip);
} }
if (TIFFFieldSet(tif, FIELD_MINSAMPLEVALUE)) if (TIFFFieldSet(tif, FIELD_MINSAMPLEVALUE))
fprintf(fd, " Min Sample Value: %u\n", td->td_minsamplevalue); fprintf(fd, " Min Sample Value: %" PRIu16 "\n", td->td_minsamplevalue);
if (TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE)) if (TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE))
fprintf(fd, " Max Sample Value: %u\n", td->td_maxsamplevalue); fprintf(fd, " Max Sample Value: %" PRIu16 "\n", td->td_maxsamplevalue);
if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE)) { if (TIFFFieldSet(tif, FIELD_SMINSAMPLEVALUE))
{
int i; int i;
int count = (tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplesperpixel : 1; int count =
(tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplesperpixel : 1;
fprintf(fd, " SMin Sample Value:"); fprintf(fd, " SMin Sample Value:");
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
fprintf(fd, " %g", td->td_sminsamplevalue[i]); fprintf(fd, " %g", td->td_sminsamplevalue[i]);
fprintf(fd, "\n"); fprintf(fd, "\n");
} }
if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE)) { if (TIFFFieldSet(tif, FIELD_SMAXSAMPLEVALUE))
{
int i; int i;
int count = (tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplesperpixel : 1; int count =
(tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplesperpixel : 1;
fprintf(fd, " SMax Sample Value:"); fprintf(fd, " SMax Sample Value:");
for (i = 0; i < count; ++i) for (i = 0; i < count; ++i)
fprintf(fd, " %g", td->td_smaxsamplevalue[i]); fprintf(fd, " %g", td->td_smaxsamplevalue[i]);
fprintf(fd, "\n"); fprintf(fd, "\n");
} }
if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) { if (TIFFFieldSet(tif, FIELD_PLANARCONFIG))
{
fprintf(fd, " Planar Configuration: "); fprintf(fd, " Planar Configuration: ");
switch (td->td_planarconfig) { switch (td->td_planarconfig)
{
case PLANARCONFIG_CONTIG: case PLANARCONFIG_CONTIG:
fprintf(fd, "single image plane\n"); fprintf(fd, "single image plane\n");
break; break;
@ -505,29 +540,31 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
fprintf(fd, "separate image planes\n"); fprintf(fd, "separate image planes\n");
break; break;
default: default:
fprintf(fd, "%u (0x%x)\n", fprintf(fd, "%" PRIu16 " (0x%" PRIx16 ")\n",
td->td_planarconfig, td->td_planarconfig); td->td_planarconfig, td->td_planarconfig);
break; break;
} }
} }
if (TIFFFieldSet(tif, FIELD_PAGENUMBER)) if (TIFFFieldSet(tif, FIELD_PAGENUMBER))
fprintf(fd, " Page Number: %u-%u\n", fprintf(fd, " Page Number: %" PRIu16 "-%" PRIu16 "\n",
td->td_pagenumber[0], td->td_pagenumber[1]); td->td_pagenumber[0], td->td_pagenumber[1]);
if (TIFFFieldSet(tif,FIELD_COLORMAP)) { if (TIFFFieldSet(tif, FIELD_COLORMAP))
{
fprintf(fd, " Color Map: "); fprintf(fd, " Color Map: ");
if (flags & TIFFPRINT_COLORMAP) { if (flags & TIFFPRINT_COLORMAP)
{
fprintf(fd, "\n"); fprintf(fd, "\n");
n = 1L << td->td_bitspersample; n = 1L << td->td_bitspersample;
for (l = 0; l < n; l++) for (l = 0; l < n; l++)
fprintf(fd, " %5ld: %5u %5u %5u\n", fprintf(fd, " %5ld: %5" PRIu16 " %5" PRIu16 " %5" PRIu16 "\n",
l, l, td->td_colormap[0][l], td->td_colormap[1][l],
td->td_colormap[0][l],
td->td_colormap[1][l],
td->td_colormap[2][l]); td->td_colormap[2][l]);
} else }
else
fprintf(fd, "(present)\n"); fprintf(fd, "(present)\n");
} }
if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) { if (TIFFFieldSet(tif, FIELD_REFBLACKWHITE))
{
int i; int i;
fprintf(fd, " Reference Black/White:\n"); fprintf(fd, " Reference Black/White:\n");
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
@ -535,34 +572,34 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
td->td_refblackwhite[2 * i + 0], td->td_refblackwhite[2 * i + 0],
td->td_refblackwhite[2 * i + 1]); td->td_refblackwhite[2 * i + 1]);
} }
if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) { if (TIFFFieldSet(tif, FIELD_TRANSFERFUNCTION))
{
fprintf(fd, " Transfer Function: "); fprintf(fd, " Transfer Function: ");
if (flags & TIFFPRINT_CURVES) { if (flags & TIFFPRINT_CURVES)
{
fprintf(fd, "\n"); fprintf(fd, "\n");
n = 1L << td->td_bitspersample; n = 1L << td->td_bitspersample;
for (l = 0; l < n; l++) { for (l = 0; l < n; l++)
uint16 i; {
fprintf(fd, " %2ld: %5u", uint16_t i;
l, td->td_transferfunction[0][l]); fprintf(fd, " %2ld: %5" PRIu16, l,
for (i = 1; i < td->td_samplesperpixel - td->td_extrasamples && i < 3; i++) td->td_transferfunction[0][l]);
fprintf(fd, " %5u", for (i = 1;
td->td_transferfunction[i][l]); i < td->td_samplesperpixel - td->td_extrasamples && i < 3;
i++)
fprintf(fd, " %5" PRIu16, td->td_transferfunction[i][l]);
fputc('\n', fd); fputc('\n', fd);
} }
} else }
else
fprintf(fd, "(present)\n"); fprintf(fd, "(present)\n");
} }
if (TIFFFieldSet(tif, FIELD_SUBIFD) && (td->td_subifd)) { if (TIFFFieldSet(tif, FIELD_SUBIFD) && (td->td_subifd))
uint16 i; {
uint16_t i;
fprintf(fd, " SubIFD Offsets:"); fprintf(fd, " SubIFD Offsets:");
for (i = 0; i < td->td_nsubifd; i++) for (i = 0; i < td->td_nsubifd; i++)
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) fprintf(fd, " %5" PRIu64, td->td_subifd[i]);
fprintf(fd, " %5I64u",
(unsigned __int64) td->td_subifd[i]);
#else
fprintf(fd, " %5llu",
(unsigned long long) td->td_subifd[i]);
#endif
fputc('\n', fd); fputc('\n', fd);
} }
@ -574,62 +611,79 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
short count; short count;
count = (short)TIFFGetTagListCount(tif); count = (short)TIFFGetTagListCount(tif);
for(i = 0; i < count; i++) { for (i = 0; i < count; i++)
uint32 tag = TIFFGetTagListEntry(tif, i); {
uint32_t tag = TIFFGetTagListEntry(tif, i);
const TIFFField *fip; const TIFFField *fip;
uint32 value_count; uint32_t value_count;
int mem_alloc = 0; int mem_alloc = 0;
void *raw_data; void *raw_data = NULL;
uint16_t dotrange[2]; /* must be kept in that scope and not moved in
the below TIFFTAG_DOTRANGE specific case */
fip = TIFFFieldWithTag(tif, tag); fip = TIFFFieldWithTag(tif, tag);
if (fip == NULL) if (fip == NULL)
continue; continue;
if(fip->field_passcount) { if (fip->field_passcount)
if (fip->field_readcount == TIFF_VARIABLE2 ) { {
if (fip->field_readcount == TIFF_VARIABLE2)
{
if (TIFFGetField(tif, tag, &value_count, &raw_data) != 1) if (TIFFGetField(tif, tag, &value_count, &raw_data) != 1)
continue; continue;
} else if (fip->field_readcount == TIFF_VARIABLE ) { }
uint16 small_value_count; else if (fip->field_readcount == TIFF_VARIABLE)
if(TIFFGetField(tif, tag, &small_value_count, &raw_data) != 1) {
uint16_t small_value_count;
if (TIFFGetField(tif, tag, &small_value_count, &raw_data) !=
1)
continue; continue;
value_count = small_value_count; value_count = small_value_count;
} else { }
assert (fip->field_readcount == TIFF_VARIABLE else
|| fip->field_readcount == TIFF_VARIABLE2); {
assert(fip->field_readcount == TIFF_VARIABLE ||
fip->field_readcount == TIFF_VARIABLE2);
continue; continue;
} }
} else { }
if (fip->field_readcount == TIFF_VARIABLE else
|| fip->field_readcount == TIFF_VARIABLE2) {
if (fip->field_readcount == TIFF_VARIABLE ||
fip->field_readcount == TIFF_VARIABLE2)
value_count = 1; value_count = 1;
else if (fip->field_readcount == TIFF_SPP) else if (fip->field_readcount == TIFF_SPP)
value_count = td->td_samplesperpixel; value_count = td->td_samplesperpixel;
else else
value_count = fip->field_readcount; value_count = fip->field_readcount;
if (fip->field_tag == TIFFTAG_DOTRANGE if (fip->field_tag == TIFFTAG_DOTRANGE &&
&& strcmp(fip->field_name,"DotRange") == 0) { strcmp(fip->field_name, "DotRange") == 0)
{
/* TODO: This is an evil exception and should not have been /* TODO: This is an evil exception and should not have been
handled this way ... likely best if we move it into handled this way ... likely best if we move it into
the directory structure with an explicit field in the directory structure with an explicit field in
libtiff 4.1 and assign it a FIELD_ value */ libtiff 4.1 and assign it a FIELD_ value */
static uint16 dotrange[2];
raw_data = dotrange; raw_data = dotrange;
TIFFGetField(tif, tag, dotrange + 0, dotrange + 1); TIFFGetField(tif, tag, dotrange + 0, dotrange + 1);
} else if (fip->field_type == TIFF_ASCII }
|| fip->field_readcount == TIFF_VARIABLE else if (fip->field_type == TIFF_ASCII ||
|| fip->field_readcount == TIFF_VARIABLE2 fip->field_readcount == TIFF_VARIABLE ||
|| fip->field_readcount == TIFF_SPP fip->field_readcount == TIFF_VARIABLE2 ||
|| value_count > 1) { fip->field_readcount == TIFF_SPP || value_count > 1)
{
if (TIFFGetField(tif, tag, &raw_data) != 1) if (TIFFGetField(tif, tag, &raw_data) != 1)
continue; continue;
} else { }
raw_data = _TIFFmalloc( else
_TIFFDataSize(fip->field_type) {
* value_count); /*--: Rational2Double: For Rationals evaluate
* "set_field_type" to determine internal storage size. */
int tv_size = TIFFFieldSetGetSize(fip);
raw_data = _TIFFmallocExt(tif, tv_size * value_count);
mem_alloc = 1; mem_alloc = 1;
if(TIFFGetField(tif, tag, raw_data) != 1) { if (TIFFGetField(tif, tag, raw_data) != 1)
_TIFFfree(raw_data); {
_TIFFfreeExt(tif, raw_data);
continue; continue;
} }
} }
@ -641,52 +695,45 @@ TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
* _TIFFPrettyPrintField() fall down and print it as * _TIFFPrettyPrintField() fall down and print it as
* any other tag. * any other tag.
*/ */
if (!_TIFFPrettyPrintField(tif, fip, fd, tag, value_count, raw_data)) if (raw_data != NULL &&
!_TIFFPrettyPrintField(tif, fip, fd, tag, value_count,
raw_data))
_TIFFPrintField(fd, fip, value_count, raw_data); _TIFFPrintField(fd, fip, value_count, raw_data);
if (mem_alloc) if (mem_alloc)
_TIFFfree(raw_data); _TIFFfreeExt(tif, raw_data);
} }
} }
if (tif->tif_tagmethods.printdir) if (tif->tif_tagmethods.printdir)
(*tif->tif_tagmethods.printdir)(tif, fd, flags); (*tif->tif_tagmethods.printdir)(tif, fd, flags);
if ((flags & TIFFPRINT_STRIPS) && if ((flags & TIFFPRINT_STRIPS) && TIFFFieldSet(tif, FIELD_STRIPOFFSETS))
TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) { {
uint32 s; uint32_t s;
fprintf(fd, " %lu %s:\n", fprintf(fd, " %" PRIu32 " %s:\n", td->td_nstrips,
(unsigned long) td->td_nstrips,
isTiled(tif) ? "Tiles" : "Strips"); isTiled(tif) ? "Tiles" : "Strips");
for (s = 0; s < td->td_nstrips; s++) for (s = 0; s < td->td_nstrips; s++)
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) fprintf(fd, " %3" PRIu32 ": [%8" PRIu64 ", %8" PRIu64 "]\n", s,
fprintf(fd, " %3lu: [%8I64u, %8I64u]\n", TIFFGetStrileOffset(tif, s),
(unsigned long) s, TIFFGetStrileByteCount(tif, s));
(unsigned __int64) TIFFGetStrileOffset(tif, s),
(unsigned __int64) TIFFGetStrileByteCount(tif, s));
#else
fprintf(fd, " %3lu: [%8llu, %8llu]\n",
(unsigned long) s,
(unsigned long long) TIFFGetStrileOffset(tif, s),
(unsigned long long) TIFFGetStrileByteCount(tif, s));
#endif
} }
} }
void void _TIFFprintAscii(FILE *fd, const char *cp)
_TIFFprintAscii(FILE* fd, const char* cp)
{ {
_TIFFprintAsciiBounded(fd, cp, strlen(cp)); _TIFFprintAsciiBounded(fd, cp, strlen(cp));
} }
static void static void _TIFFprintAsciiBounded(FILE *fd, const char *cp, size_t max_chars)
_TIFFprintAsciiBounded(FILE* fd, const char* cp, size_t max_chars) {
for (; max_chars > 0 && *cp != '\0'; cp++, max_chars--)
{ {
for (; max_chars > 0 && *cp != '\0'; cp++, max_chars--) {
const char *tp; const char *tp;
if (isprint((int)*cp)) { if (isprint((int)*cp))
{
fputc(*cp, fd); fputc(*cp, fd);
continue; continue;
} }
@ -700,19 +747,9 @@ _TIFFprintAsciiBounded(FILE* fd, const char* cp, size_t max_chars)
} }
} }
void void _TIFFprintAsciiTag(FILE *fd, const char *name, const char *value)
_TIFFprintAsciiTag(FILE* fd, const char* name, const char* value)
{ {
fprintf(fd, " %s: \"", name); fprintf(fd, " %s: \"", name);
_TIFFprintAscii(fd, value); _TIFFprintAscii(fd, value);
fprintf(fd, "\"\n"); fprintf(fd, "\"\n");
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

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

File diff suppressed because it is too large Load Diff

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

@ -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,16 +74,17 @@ 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 _tiffosReadProc(thandle_t, void *, tmsize_t);
static tmsize_t _tiffisReadProc(thandle_t fd, void *buf, tmsize_t size); 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 _tiffosWriteProc(thandle_t fd, void *buf, tmsize_t size);
static tmsize_t _tiffisWriteProc(thandle_t, void *, tmsize_t); static tmsize_t _tiffisWriteProc(thandle_t, void *, tmsize_t);
static uint64 _tiffosSeekProc(thandle_t fd, uint64 off, int whence); static uint64_t _tiffosSeekProc(thandle_t fd, uint64_t off, int whence);
static uint64 _tiffisSeekProc(thandle_t fd, uint64 off, int whence); static uint64_t _tiffisSeekProc(thandle_t fd, uint64_t off, int whence);
static uint64 _tiffosSizeProc(thandle_t fd); static uint64_t _tiffosSizeProc(thandle_t fd);
static uint64 _tiffisSizeProc(thandle_t fd); static uint64_t _tiffisSizeProc(thandle_t fd);
static int _tiffosCloseProc(thandle_t fd); static int _tiffosCloseProc(thandle_t fd);
static int _tiffisCloseProc(thandle_t fd); static int _tiffisCloseProc(thandle_t fd);
static int _tiffDummyMapProc(thandle_t, void **base, toff_t *size); static int _tiffDummyMapProc(thandle_t, void **base, toff_t *size);
@ -104,14 +103,9 @@ struct tiffos_data
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);
@ -125,8 +119,7 @@ _tiffisReadProc(thandle_t fd, void* buf, tmsize_t 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;
@ -142,32 +135,29 @@ _tiffosWriteProc(thandle_t fd, void* buf, tmsize_t 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 // Compute 64-bit offset
uint64 new_offset = static_cast<uint64>(data->start_pos) + off; 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); os->seekp(offset, ios::beg);
break; break;
@ -176,8 +166,8 @@ _tiffosSeekProc(thandle_t fd, uint64 off, int whence)
{ {
// 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::cur); os->seekp(offset, ios::cur);
break; break;
@ -186,8 +176,8 @@ _tiffosSeekProc(thandle_t fd, uint64 off, int whence)
{ {
// 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::end);
break; break;
@ -198,18 +188,16 @@ _tiffosSeekProc(thandle_t fd, uint64 off, int whence)
// stream. ofstream doesn't have a problem with this but // stream. ofstream doesn't have a problem with this but
// ostrstream/ostringstream does. In that situation, add intermediate // ostrstream/ostringstream does. In that situation, add intermediate
// '\0' characters. // '\0' characters.
if( os->fail() ) { if (os->fail())
#ifdef __VMS {
int old_state;
#else
ios::iostate old_state; ios::iostate old_state;
#endif
ios::pos_type origin; ios::pos_type origin;
old_state = os->rdstate(); old_state = os->rdstate();
// reset the fail bit or else tellp() won't work below // reset the fail bit or else tellp() won't work below
os->clear(os->rdstate() & ~ios::failbit); os->clear(os->rdstate() & ~ios::failbit);
switch( whence ) { switch (whence)
{
case SEEK_SET: case SEEK_SET:
default: default:
origin = data->start_pos; origin = data->start_pos;
@ -226,41 +214,46 @@ _tiffosSeekProc(thandle_t fd, uint64 off, int whence)
os->clear(old_state); os->clear(old_state);
// only do something if desired seek position is valid // only do something if desired seek position is valid
if( (static_cast<uint64>(origin) + off) > static_cast<uint64>(data->start_pos) ) { if ((static_cast<uint64_t>(origin) + off) >
uint64 num_fill; static_cast<uint64_t>(data->start_pos))
{
uint64_t num_fill;
// clear the fail bit // clear the fail bit
os->clear(os->rdstate() & ~ios::failbit); os->clear(os->rdstate() & ~ios::failbit);
// extend the stream to the expected size // extend the stream to the expected size
os->seekp(0, ios::end); os->seekp(0, ios::end);
num_fill = (static_cast<uint64>(origin)) + off - os->tellp(); num_fill = (static_cast<uint64_t>(origin)) + off - os->tellp();
for( uint64 i = 0; i < num_fill; i++ ) for (uint64_t i = 0; i < num_fill; i++)
os->put('\0'); os->put('\0');
// retry the seek // retry the seek
os->seekp(static_cast<ios::off_type>(static_cast<uint64>(origin) + off), ios::beg); os->seekp(static_cast<ios::off_type>(
static_cast<uint64_t>(origin) + off),
ios::beg);
} }
} }
return static_cast<uint64>(os->tellp()); return static_cast<uint64_t>(os->tellp());
} }
static uint64 static uint64_t _tiffisSeekProc(thandle_t fd, uint64_t off, int whence)
_tiffisSeekProc(thandle_t fd, uint64 off, int whence)
{ {
tiffis_data *data = reinterpret_cast<tiffis_data *>(fd); tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
switch(whence) { switch (whence)
{
case SEEK_SET: case SEEK_SET:
{ {
// Compute 64-bit offset // Compute 64-bit offset
uint64 new_offset = static_cast<uint64>(data->start_pos) + off; 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);
data->stream->seekg(offset, ios::beg); data->stream->seekg(offset, ios::beg);
break; break;
@ -269,8 +262,8 @@ _tiffisSeekProc(thandle_t fd, uint64 off, int whence)
{ {
// 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);
data->stream->seekg(offset, ios::cur); data->stream->seekg(offset, ios::cur);
break; break;
@ -279,19 +272,18 @@ _tiffisSeekProc(thandle_t fd, uint64 off, int whence)
{ {
// 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);
data->stream->seekg(offset, ios::end); data->stream->seekg(offset, ios::end);
break; break;
} }
} }
return (uint64) (data->stream->tellg() - data->start_pos); return (uint64_t)(data->stream->tellg() - data->start_pos);
} }
static uint64 static uint64_t _tiffosSizeProc(thandle_t fd)
_tiffosSizeProc(thandle_t fd)
{ {
tiffos_data *data = reinterpret_cast<tiffos_data *>(fd); tiffos_data *data = reinterpret_cast<tiffos_data *>(fd);
ostream *os = data->stream; ostream *os = data->stream;
@ -302,11 +294,10 @@ _tiffosSizeProc(thandle_t fd)
len = os->tellp(); len = os->tellp();
os->seekp(pos); os->seekp(pos);
return (uint64) len; return (uint64_t)len;
} }
static uint64 static uint64_t _tiffisSizeProc(thandle_t fd)
_tiffisSizeProc(thandle_t fd)
{ {
tiffis_data *data = reinterpret_cast<tiffis_data *>(fd); tiffis_data *data = reinterpret_cast<tiffis_data *>(fd);
ios::pos_type pos = data->stream->tellg(); ios::pos_type pos = data->stream->tellg();
@ -316,35 +307,31 @@ _tiffisSizeProc(thandle_t fd)
len = data->stream->tellg(); len = data->stream->tellg();
data->stream->seekg(pos); data->stream->seekg(pos);
return (uint64) len; return (uint64_t)len;
} }
static int static int _tiffosCloseProc(thandle_t fd)
_tiffosCloseProc(thandle_t fd)
{ {
// Our stream was not allocated by us, so it shouldn't be closed by us. // Our stream was not allocated by us, so it shouldn't be closed by us.
delete reinterpret_cast<tiffos_data *>(fd); delete reinterpret_cast<tiffos_data *>(fd);
return 0; return 0;
} }
static int static int _tiffisCloseProc(thandle_t fd)
_tiffisCloseProc(thandle_t fd)
{ {
// Our stream was not allocated by us, so it shouldn't be closed by us. // Our stream was not allocated by us, so it shouldn't be closed by us.
delete reinterpret_cast<tiffis_data *>(fd); delete reinterpret_cast<tiffis_data *>(fd);
return 0; return 0;
} }
static int static int _tiffDummyMapProc(thandle_t, void **base, toff_t *size)
_tiffDummyMapProc(thandle_t , void** base, toff_t* size )
{ {
(void)base; (void)base;
(void)size; (void)size;
return (0); return (0);
} }
static void static void _tiffDummyUnmapProc(thandle_t, void *base, toff_t size)
_tiffDummyUnmapProc(thandle_t , void* base, toff_t size )
{ {
(void)base; (void)base;
(void)size; (void)size;
@ -353,44 +340,38 @@ _tiffDummyUnmapProc(thandle_t , void* base, toff_t size )
/* /*
* Open a TIFF file descriptor for read/writing. * Open a TIFF file descriptor for read/writing.
*/ */
static TIFF* static TIFF *_tiffStreamOpen(const char *name, const char *mode, void *fd)
_tiffStreamOpen(const char* name, const char* mode, void *fd)
{ {
TIFF *tif; TIFF *tif;
if( strchr(mode, 'w') ) { if (strchr(mode, 'w'))
{
tiffos_data *data = new tiffos_data; tiffos_data *data = new tiffos_data;
data->stream = reinterpret_cast<ostream *>(fd); data->stream = reinterpret_cast<ostream *>(fd);
data->start_pos = data->stream->tellp(); data->start_pos = data->stream->tellp();
// Open for writing. // Open for writing.
tif = TIFFClientOpen(name, mode, tif = TIFFClientOpen(
reinterpret_cast<thandle_t>(data), name, mode, reinterpret_cast<thandle_t>(data), _tiffosReadProc,
_tiffosReadProc, _tiffosWriteProc, _tiffosSeekProc, _tiffosCloseProc,
_tiffosWriteProc, _tiffosSizeProc, _tiffDummyMapProc, _tiffDummyUnmapProc);
_tiffosSeekProc, if (!tif)
_tiffosCloseProc, {
_tiffosSizeProc,
_tiffDummyMapProc,
_tiffDummyUnmapProc);
if (!tif) {
delete data; delete data;
} }
} else { }
else
{
tiffis_data *data = new tiffis_data; tiffis_data *data = new tiffis_data;
data->stream = reinterpret_cast<istream *>(fd); data->stream = reinterpret_cast<istream *>(fd);
data->start_pos = data->stream->tellg(); data->start_pos = data->stream->tellg();
// Open for reading. // Open for reading.
tif = TIFFClientOpen(name, mode, tif = TIFFClientOpen(
reinterpret_cast<thandle_t>(data), name, mode, reinterpret_cast<thandle_t>(data), _tiffisReadProc,
_tiffisReadProc, _tiffisWriteProc, _tiffisSeekProc, _tiffisCloseProc,
_tiffisWriteProc, _tiffisSizeProc, _tiffDummyMapProc, _tiffDummyUnmapProc);
_tiffisSeekProc, if (!tif)
_tiffisCloseProc, {
_tiffisSizeProc,
_tiffDummyMapProc,
_tiffDummyUnmapProc);
if (!tif) {
delete data; delete data;
} }
} }
@ -400,14 +381,14 @@ _tiffStreamOpen(const char* name, const char* mode, void *fd)
} /* 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 << '\0';
os->seekp(0); os->seekp(0);
} }
@ -416,19 +397,8 @@ TIFFStreamOpen(const char* name, ostream *os)
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:
*/

247
3rdparty/libtiff/tif_strip.c vendored
View File

@ -32,22 +32,23 @@
/* /*
* 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",
(unsigned long)sample,
(unsigned long)td->td_samplesperpixel);
return (0); return (0);
} }
strip += (uint32)sample*td->td_stripsperimage; strip += (uint32_t)sample * td->td_stripsperimage;
} }
return (strip); return (strip);
} }
@ -55,16 +56,17 @@ TIFFComputeStrip(TIFF* tif, uint32 row, uint16 sample)
/* /*
* 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
: TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip));
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
nstrips = _TIFFMultiply32(tif, nstrips, (uint32)td->td_samplesperpixel, nstrips =
_TIFFMultiply32(tif, nstrips, (uint32_t)td->td_samplesperpixel,
"TIFFNumberOfStrips"); "TIFFNumberOfStrips");
return (nstrips); return (nstrips);
} }
@ -72,16 +74,14 @@ TIFFNumberOfStrips(TIFF* tif)
/* /*
* 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
@ -91,44 +91,46 @@ TIFFVStripSize64(TIFF* tif, uint32 nrows)
* horizontal/vertical subsampling area include * horizontal/vertical subsampling area include
* YCbCr data for the extended image. * YCbCr data for the extended image.
*/ */
uint16 ycbcrsubsampling[2]; uint16_t ycbcrsubsampling[2];
uint16 samplingblock_samples; uint16_t samplingblock_samples;
uint32 samplingblocks_hor; uint32_t samplingblocks_hor;
uint32 samplingblocks_ver; uint32_t samplingblocks_ver;
uint64 samplingrow_samples; uint64_t samplingrow_samples;
uint64 samplingrow_size; uint64_t samplingrow_size;
if (td->td_samplesperpixel != 3) if (td->td_samplesperpixel != 3)
{ {
TIFFErrorExt(tif->tif_clientdata,module, TIFFErrorExtR(tif, module, "Invalid td_samplesperpixel value");
"Invalid td_samplesperpixel value");
return 0; return 0;
} }
TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0, TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
ycbcrsubsampling+1); ycbcrsubsampling + 0, ycbcrsubsampling + 1);
if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4) if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4)) ycbcrsubsampling[0] != 4) ||
(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
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],
ycbcrsubsampling[1] );
return 0; return 0;
} }
samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2; samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
samplingblocks_hor=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,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));
return (
_TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
} }
else else
return (_TIFFMultiply64(tif, nrows, TIFFScanlineSize64(tif), module)); 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);
} }
@ -136,45 +138,35 @@ TIFFVStripSize(TIFF* tif, uint32 nrows)
/* /*
* 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;
} }
} }
@ -189,20 +181,18 @@ 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,32 +203,31 @@ 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_t)s < 1)
{ {
if ((int32) s < 1) {
/* /*
* If RowsPerStrip is unspecified, try to break the * If RowsPerStrip is unspecified, try to break the
* image up into strips that are approximately * image up into strips that are approximately
* STRIP_SIZE_DEFAULT bytes long. * STRIP_SIZE_DEFAULT bytes long.
*/ */
uint64 scanlinesize; uint64_t scanlinesize;
uint64 rows; uint64_t rows;
scanlinesize = TIFFScanlineSize64(tif); scanlinesize = TIFFScanlineSize64(tif);
if (scanlinesize == 0) if (scanlinesize == 0)
scanlinesize = 1; scanlinesize = 1;
rows=(uint64)STRIP_SIZE_DEFAULT/scanlinesize; rows = (uint64_t)STRIP_SIZE_DEFAULT / scanlinesize;
if (rows == 0) if (rows == 0)
rows = 1; rows = 1;
else if (rows > 0xFFFFFFFF) else if (rows > 0xFFFFFFFF)
rows = 0xFFFFFFFF; rows = 0xFFFFFFFF;
s=(uint32)rows; s = (uint32_t)rows;
} }
return (s); return (s);
} }
@ -253,68 +242,77 @@ _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_t ycbcrsubsampling[2];
uint16 samplingblock_samples; uint16_t samplingblock_samples;
uint32 samplingblocks_hor; uint32_t samplingblocks_hor;
uint64 samplingrow_samples; uint64_t samplingrow_samples;
uint64 samplingrow_size; uint64_t samplingrow_size;
if (td->td_samplesperpixel != 3) if (td->td_samplesperpixel != 3)
{ {
TIFFErrorExt(tif->tif_clientdata,module, TIFFErrorExtR(tif, module, "Invalid td_samplesperpixel value");
"Invalid td_samplesperpixel value");
return 0; return 0;
} }
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, TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling");
"Invalid YCbCr subsampling");
return 0; return 0;
} }
samplingblock_samples = ycbcrsubsampling[0]*ycbcrsubsampling[1]+2; samplingblock_samples =
samplingblocks_hor = TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]); ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
samplingrow_samples = _TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module); samplingblocks_hor =
samplingrow_size = TIFFhowmany_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module),8); 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]); scanline_size = (samplingrow_size / ycbcrsubsampling[1]);
} }
else else
{ {
uint64 scanline_samples; uint64_t scanline_samples;
scanline_samples=_TIFFMultiply64(tif,td->td_imagewidth,td->td_samplesperpixel,module); scanline_samples = _TIFFMultiply64(tif, td->td_imagewidth,
scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,scanline_samples,td->td_bitspersample,module),8); td->td_samplesperpixel, module);
scanline_size =
TIFFhowmany_64(_TIFFMultiply64(tif, scanline_samples,
td->td_bitspersample, module),
8);
} }
} }
else else
{ {
scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,td->td_imagewidth,td->td_bitspersample,module),8); scanline_size =
TIFFhowmany_64(_TIFFMultiply64(tif, td->td_imagewidth,
td->td_bitspersample, module),
8);
} }
if (scanline_size == 0) if (scanline_size == 0)
{ {
TIFFErrorExt(tif->tif_clientdata,module,"Computed scanline size is zero"); TIFFErrorExtR(tif, module, "Computed scanline size is zero");
return 0; return 0;
} }
return (scanline_size); 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)
{
scanline =
_TIFFMultiply64(tif, scanline, td->td_samplesperpixel, module);
return (TIFFhowmany8_64(scanline)); return (TIFFhowmany8_64(scanline));
} else }
else
return (_TIFFMultiply64(tif, TIFFhowmany8_64(scanline), return (_TIFFMultiply64(tif, TIFFhowmany8_64(scanline),
td->td_samplesperpixel, module)); 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:
*/

301
3rdparty/libtiff/tif_swab.c vendored
View File

@ -30,167 +30,216 @@
#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; cp = (unsigned char *)wp;
t = cp[1]; cp[1] = cp[0]; cp[0] = t; t = cp[1];
cp[1] = cp[0];
cp[0] = t;
wp++; 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; cp = (unsigned char *)tp;
t = cp[2]; cp[2] = cp[0]; cp[0] = t; t = cp[2];
cp[2] = cp[0];
cp[0] = t;
tp += 3; 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; cp = (unsigned char *)lp;
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;
lp++; 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; cp = (unsigned char *)lp;
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;
lp++; 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; cp = (unsigned char *)fp;
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;
fp++; 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; cp = (unsigned char *)dp;
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;
dp++; dp++;
} }
} }
@ -206,84 +255,62 @@ 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[0] = TIFFBitRevTable[cp[0]];
cp[1] = TIFFBitRevTable[cp[1]]; cp[1] = TIFFBitRevTable[cp[1]];
cp[2] = TIFFBitRevTable[cp[2]]; cp[2] = TIFFBitRevTable[cp[2]];
@ -294,17 +321,9 @@ TIFFReverseBits(uint8* cp, tmsize_t n)
cp[7] = TIFFBitRevTable[cp[7]]; cp[7] = TIFFBitRevTable[cp[7]];
cp += 8; cp += 8;
} }
while (n-- > 0) { while (n-- > 0)
{
*cp = TIFFBitRevTable[*cp]; *cp = TIFFBitRevTable[*cp];
cp++; cp++;
} }
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

98
3rdparty/libtiff/tif_thunder.c vendored
View File

@ -54,36 +54,35 @@
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; \ lastpixel = (v)&0xf; \
if (npixels < maxpixels) \ if (npixels < maxpixels) \
{ \ { \
if (npixels++ & 1) \ if (npixels++ & 1) \
*op++ |= lastpixel; \ *op++ |= lastpixel; \
else \ else \
op[0] = (uint8) (lastpixel << 4); \ op[0] = (uint8_t)(lastpixel << 4); \
} \ } \
} }
static int static int ThunderSetupDecode(TIFF *tif)
ThunderSetupDecode(TIFF* tif)
{ {
static const char module[] = "ThunderSetupDecode"; static const char module[] = "ThunderSetupDecode";
if (tif->tif_dir.td_bitspersample != 4) if (tif->tif_dir.td_bitspersample != 4)
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module,
"Wrong bitspersample value (%d), Thunder decoder only supports 4bits per sample.", "Wrong bitspersample value (%d), Thunder decoder only "
"supports 4bits per sample.",
(int)tif->tif_dir.td_bitspersample); (int)tif->tif_dir.td_bitspersample);
return 0; return 0;
} }
return (1); return (1);
} }
static int static int ThunderDecode(TIFF *tif, uint8_t *op, tmsize_t maxpixels)
ThunderDecode(TIFF* tif, uint8* op, tmsize_t maxpixels)
{ {
static const char module[] = "ThunderDecode"; static const char module[] = "ThunderDecode";
register unsigned char *bp; register unsigned char *bp;
@ -95,26 +94,33 @@ ThunderDecode(TIFF* tif, uint8* op, tmsize_t maxpixels)
cc = tif->tif_rawcc; cc = tif->tif_rawcc;
lastpixel = 0; lastpixel = 0;
npixels = 0; npixels = 0;
while (cc > 0 && npixels < maxpixels) { while (cc > 0 && npixels < maxpixels)
{
int n, delta; int n, delta;
n = *bp++; n = *bp++;
cc--; cc--;
switch (n & THUNDER_CODE) { switch (n & THUNDER_CODE)
{
case THUNDER_RUN: /* pixel run */ case THUNDER_RUN: /* pixel run */
/* /*
* Replicate the last pixel n times, * Replicate the last pixel n times,
* where n is the lower-order 6 bits. * where n is the lower-order 6 bits.
*/ */
if (npixels & 1) { if (npixels & 1)
{
op[0] |= lastpixel; op[0] |= lastpixel;
lastpixel = *op++; npixels++; n--; lastpixel = *op++;
} else npixels++;
n--;
}
else
lastpixel |= lastpixel << 4; lastpixel |= lastpixel << 4;
npixels += n; npixels += n;
if (npixels < maxpixels) { if (npixels < maxpixels)
{
for (; n > 0; n -= 2) for (; n > 0; n -= 2)
*op++ = (uint8) lastpixel; *op++ = (uint8_t)lastpixel;
} }
if (n == -1) if (n == -1)
*--op &= 0xf0; *--op &= 0xf0;
@ -122,60 +128,56 @@ ThunderDecode(TIFF* tif, uint8* op, tmsize_t maxpixels)
break; break;
case THUNDER_2BITDELTAS: /* 2-bit deltas */ case THUNDER_2BITDELTAS: /* 2-bit deltas */
if ((delta = ((n >> 4) & 3)) != DELTA2_SKIP) if ((delta = ((n >> 4) & 3)) != DELTA2_SKIP)
SETPIXEL(op, (unsigned)((int)lastpixel + twobitdeltas[delta])); SETPIXEL(op,
(unsigned)((int)lastpixel + twobitdeltas[delta]));
if ((delta = ((n >> 2) & 3)) != DELTA2_SKIP) if ((delta = ((n >> 2) & 3)) != DELTA2_SKIP)
SETPIXEL(op, (unsigned)((int)lastpixel + twobitdeltas[delta])); SETPIXEL(op,
(unsigned)((int)lastpixel + twobitdeltas[delta]));
if ((delta = (n & 3)) != DELTA2_SKIP) if ((delta = (n & 3)) != DELTA2_SKIP)
SETPIXEL(op, (unsigned)((int)lastpixel + twobitdeltas[delta])); SETPIXEL(op,
(unsigned)((int)lastpixel + twobitdeltas[delta]));
break; break;
case THUNDER_3BITDELTAS: /* 3-bit deltas */ case THUNDER_3BITDELTAS: /* 3-bit deltas */
if ((delta = ((n >> 3) & 7)) != DELTA3_SKIP) if ((delta = ((n >> 3) & 7)) != DELTA3_SKIP)
SETPIXEL(op, (unsigned)((int)lastpixel + threebitdeltas[delta])); SETPIXEL(
op, (unsigned)((int)lastpixel + threebitdeltas[delta]));
if ((delta = (n & 7)) != DELTA3_SKIP) if ((delta = (n & 7)) != DELTA3_SKIP)
SETPIXEL(op, (unsigned)((int)lastpixel + threebitdeltas[delta])); SETPIXEL(
op, (unsigned)((int)lastpixel + threebitdeltas[delta]));
break; break;
case THUNDER_RAW: /* raw data */ case THUNDER_RAW: /* raw data */
SETPIXEL(op, n); SETPIXEL(op, n);
break; break;
} }
} }
tif->tif_rawcp = (uint8*) bp; tif->tif_rawcp = (uint8_t *)bp;
tif->tif_rawcc = cc; tif->tif_rawcc = cc;
if (npixels != maxpixels) { if (npixels != maxpixels)
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__)) {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module,
"%s data at scanline %lu (%I64u != %I64u)", "%s data at scanline %lu (%" PRIu64 " != %" PRIu64 ")",
npixels < maxpixels ? "Not enough" : "Too much", npixels < maxpixels ? "Not enough" : "Too much",
(unsigned long) tif->tif_row, (unsigned long)tif->tif_row, (uint64_t)npixels,
(unsigned __int64) npixels, (uint64_t)maxpixels);
(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 (0);
} }
return (1); return (1);
} }
static int static int ThunderDecodeRow(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
ThunderDecodeRow(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
{ {
static const char module[] = "ThunderDecodeRow"; static const char module[] = "ThunderDecodeRow";
uint8* row = buf; uint8_t *row = buf;
(void)s; (void)s;
if (occ % tif->tif_scanlinesize) if (occ % tif->tif_scanlinesize)
{ {
TIFFErrorExt(tif->tif_clientdata, module, "Fractional scanlines cannot be read"); TIFFErrorExtR(tif, module, "Fractional scanlines cannot be read");
return (0); return (0);
} }
while (occ > 0) { while (occ > 0)
{
if (!ThunderDecode(tif, row, tif->tif_dir.td_imagewidth)) if (!ThunderDecode(tif, row, tif->tif_dir.td_imagewidth))
return (0); return (0);
occ -= tif->tif_scanlinesize; occ -= tif->tif_scanlinesize;
@ -184,8 +186,7 @@ ThunderDecodeRow(TIFF* tif, uint8* buf, tmsize_t occ, uint16 s)
return (1); return (1);
} }
int int TIFFInitThunderScan(TIFF *tif, int scheme)
TIFFInitThunderScan(TIFF* tif, int scheme)
{ {
(void)scheme; (void)scheme;
@ -195,12 +196,3 @@ TIFFInitThunderScan(TIFF* tif, int scheme)
return (1); 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:
*/

189
3rdparty/libtiff/tif_tile.c vendored
View File

@ -32,33 +32,32 @@
/* /*
* 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) +
x/dx;
else else
tile = (xpt * ypt) * (z / dz) + xpt * (y / dy) + x / dx; tile = (xpt * ypt) * (z / dz) + xpt * (y / dy) + x / dx;
} }
@ -69,36 +68,33 @@ TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
* 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, {
"%lu: Row out of range, max %lu", TIFFErrorExtR(tif, tif->tif_name, "%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, {
"%lu: Depth out of range, max %lu", TIFFErrorExtR(tif, tif->tif_name, "%lu: Depth out of range, max %lu",
(unsigned long) z, (unsigned long)z, (unsigned long)(td->td_imagedepth - 1));
(unsigned long) (td->td_imagedepth - 1));
return (0); return (0);
} }
if (td->td_planarconfig == PLANARCONFIG_SEPARATE && if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
s >= td->td_samplesperpixel) { s >= td->td_samplesperpixel)
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, {
"%lu: Sample out of range, max %lu", TIFFErrorExtR(tif, tif->tif_name, "%lu: Sample out of range, max %lu",
(unsigned long)s, (unsigned long)s,
(unsigned long)(td->td_samplesperpixel - 1)); (unsigned long)(td->td_samplesperpixel - 1));
return (0); return (0);
@ -109,23 +105,26 @@ TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s)
/* /*
* 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)
? 0
: _TIFFMultiply32(
tif,
_TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
TIFFhowmany_32(td->td_imagelength, dy), TIFFhowmany_32(td->td_imagelength, dy),
"TIFFNumberOfTiles"), "TIFFNumberOfTiles"),
TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles"); TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
@ -138,22 +137,21 @@ TIFFNumberOfTiles(TIFF* tif)
/* /*
* 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)
{ {
TIFFErrorExt(tif->tif_clientdata,module,"Tile length is zero"); TIFFErrorExtR(tif, module, "Tile length is zero");
return 0; return 0;
} }
if (td->td_tilewidth == 0) if (td->td_tilewidth == 0)
{ {
TIFFErrorExt(tif->tif_clientdata,module,"Tile width is zero"); TIFFErrorExtR(tif, module, "Tile width is zero");
return (0); return (0);
} }
rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth, rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
@ -162,7 +160,7 @@ TIFFTileRowSize64(TIFF* tif)
{ {
if (td->td_samplesperpixel == 0) if (td->td_samplesperpixel == 0)
{ {
TIFFErrorExt(tif->tif_clientdata,module,"Samples per pixel is zero"); TIFFErrorExtR(tif, module, "Samples per pixel is zero");
return 0; return 0;
} }
rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel, rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
@ -171,16 +169,15 @@ TIFFTileRowSize64(TIFF* tif)
tilerowsize = TIFFhowmany8_64(rowsize); tilerowsize = TIFFhowmany8_64(rowsize);
if (tilerowsize == 0) if (tilerowsize == 0)
{ {
TIFFErrorExt(tif->tif_clientdata,module,"Computed tile row size is zero"); TIFFErrorExtR(tif, module, "Computed tile row size is zero");
return 0; return 0;
} }
return (tilerowsize); 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);
} }
@ -188,8 +185,7 @@ TIFFTileRowSize(TIFF* tif)
/* /*
* 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;
@ -198,8 +194,7 @@ TIFFVTileSize64(TIFF* tif, uint32 nrows)
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
@ -209,38 +204,41 @@ TIFFVTileSize64(TIFF* tif, uint32 nrows)
* horizontal/vertical subsampling area include * horizontal/vertical subsampling area include
* YCbCr data for the extended image. * YCbCr data for the extended image.
*/ */
uint16 ycbcrsubsampling[2]; uint16_t ycbcrsubsampling[2];
uint16 samplingblock_samples; uint16_t samplingblock_samples;
uint32 samplingblocks_hor; uint32_t samplingblocks_hor;
uint32 samplingblocks_ver; uint32_t samplingblocks_ver;
uint64 samplingrow_samples; uint64_t samplingrow_samples;
uint64 samplingrow_size; uint64_t samplingrow_size;
TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0, TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
ycbcrsubsampling+1); ycbcrsubsampling + 0, ycbcrsubsampling + 1);
if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4) if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4)) ycbcrsubsampling[0] != 4) ||
(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
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],
ycbcrsubsampling[1] );
return 0; return 0;
} }
samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2; samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampling[0]); samplingblocks_hor =
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));
return (
_TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
} }
else else
return (_TIFFMultiply64(tif, nrows, TIFFTileRowSize64(tif), module)); 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);
} }
@ -248,16 +246,14 @@ TIFFVTileSize(TIFF* tif, uint32 nrows)
/* /*
* 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,19 +264,17 @@ 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)
@ -288,12 +282,3 @@ _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th)
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:
*/

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

@ -53,18 +53,15 @@
#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;
@ -91,8 +88,7 @@ _tiffReadProc(thandle_t fd, void* buf, tmsize_t size)
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;
@ -120,30 +116,27 @@ _tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)
/* 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;
@ -151,23 +144,24 @@ _tiffSizeProc(thandle_t 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; fd_as_handle_union_t fdh;
fdh.h = fd; fdh.h = fd;
*pbase = (void*) *pbase =
mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, fdh.fd, 0); (void *)mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, fdh.fd, 0);
if (*pbase != (void*) -1) { if (*pbase != (void *)-1)
{
*psize = (tmsize_t)sizem; *psize = (tmsize_t)sizem;
return (1); return (1);
} }
@ -175,42 +169,46 @@ _tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
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;
(void)pbase;
(void)psize;
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) 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) {
return TIFFFdOpenExt(fd, name, mode, NULL);
}
TIFF *TIFFFdOpenExt(int fd, const char *name, const char *mode,
TIFFOpenOptions *opts)
{ {
TIFF *tif; TIFF *tif;
fd_as_handle_union_t fdh; fd_as_handle_union_t fdh;
fdh.fd = fd; fdh.fd = fd;
tif = TIFFClientOpen(name, mode, tif = TIFFClientOpenExt(name, mode, fdh.h, _tiffReadProc, _tiffWriteProc,
fdh.h,
_tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
_tiffMapProc, _tiffUnmapProc); _tiffMapProc, _tiffUnmapProc, opts);
if (tif) if (tif)
tif->tif_fd = fd; tif->tif_fd = fd;
return (tif); return (tif);
@ -219,14 +217,18 @@ TIFFFdOpen(int fd, 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) {
return TIFFOpenExt(name, mode, NULL);
}
TIFF *TIFFOpenExt(const char *name, const char *mode, TIFFOpenOptions *opts)
{ {
static const char module[] = "TIFFOpen"; static const char module[] = "TIFFOpen";
int m, fd; int m, fd;
TIFF *tif; TIFF *tif;
m = _TIFFgetMode(mode, module); m = _TIFFgetMode(opts, NULL, mode, module);
if (m == -1) if (m == -1)
return ((TIFF *)0); return ((TIFF *)0);
@ -236,16 +238,21 @@ TIFFOpen(const char* name, const char* mode)
#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));
}
else
{
_TIFFErrorEarly(opts, NULL, module, "%s: Cannot open", name);
} }
return ((TIFF *)0); 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;
@ -256,8 +263,11 @@ 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) {
return TIFFOpenWExt(name, mode, NULL);
}
TIFF *TIFFOpenWExt(const wchar_t *name, const char *mode, TIFFOpenOptions *opts)
{ {
static const char module[] = "TIFFOpenW"; static const char module[] = "TIFFOpenW";
int m, fd; int m, fd;
@ -265,7 +275,7 @@ TIFFOpenW(const wchar_t* name, const char* mode)
char *mbname; char *mbname;
TIFF *tif; TIFF *tif;
m = _TIFFgetMode(mode, module); m = _TIFFgetMode(opts, NULL, mode, module);
if (m == -1) if (m == -1)
return ((TIFF *)0); return ((TIFF *)0);
@ -275,27 +285,30 @@ TIFFOpenW(const wchar_t* name, const char* mode)
#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); {
_TIFFErrorEarly(opts, NULL, module, "%ls: Cannot open", name);
return ((TIFF *)0); 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); mbname = _TIFFmalloc(mbsize);
if (!mbname) { if (!mbname)
TIFFErrorExt(0, module, {
_TIFFErrorEarly(
opts, NULL, module,
"Can't allocate space for filename conversion buffer"); "Can't allocate space for filename conversion buffer");
return ((TIFF *)0); 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);
@ -305,8 +318,7 @@ TIFFOpenW(const wchar_t* name, const char* mode)
} }
#endif #endif
void* void *_TIFFmalloc(tmsize_t s)
_TIFFmalloc(tmsize_t s)
{ {
if (s == 0) if (s == 0)
return ((void *)NULL); return ((void *)NULL);
@ -322,38 +334,23 @@ void* _TIFFcalloc(tmsize_t nmemb, tmsize_t siz)
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)
{
free(p);
}
void* void *_TIFFrealloc(void *p, tmsize_t s) { return (realloc(p, (size_t)s)); }
_TIFFrealloc(void* p, tmsize_t s)
{
return (realloc(p, (size_t) s));
}
void void _TIFFmemset(void *p, int v, tmsize_t c) { memset(p, v, (size_t)c); }
_TIFFmemset(void* p, int v, tmsize_t c)
{
memset(p, v, (size_t) c);
}
void void _TIFFmemcpy(void *d, const void *s, tmsize_t c)
_TIFFmemcpy(void* d, const void* s, tmsize_t c)
{ {
memcpy(d, s, (size_t)c); memcpy(d, s, (size_t)c);
} }
int int _TIFFmemcmp(const void *p1, const void *p2, tmsize_t c)
_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
{ {
return (memcmp(p1, p2, (size_t)c)); return (memcmp(p1, p2, (size_t)c));
} }
static void static void unixWarningHandler(const char *module, const char *fmt, va_list ap)
unixWarningHandler(const char* module, const char* fmt, va_list ap)
{ {
if (module != NULL) if (module != NULL)
fprintf(stderr, "%s: ", module); fprintf(stderr, "%s: ", module);
@ -363,8 +360,7 @@ unixWarningHandler(const char* module, const char* fmt, va_list ap)
} }
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);
@ -372,13 +368,3 @@ unixErrorHandler(const char* module, const char* fmt, va_list 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:
*/

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

@ -25,15 +25,4 @@
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:
*/

58
3rdparty/libtiff/tif_warning.c vendored
View File

@ -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); va_start(ap, fmt);
(*_TIFFwarningHandler)(module, fmt, ap); (*_TIFFwarningHandler)(module, fmt, ap);
va_end(ap); va_end(ap);
} }
if (_TIFFwarningHandlerExt) { if (_TIFFwarningHandlerExt)
{
va_start(ap, fmt); va_start(ap, fmt);
(*_TIFFwarningHandlerExt)(0, module, fmt, ap); (*_TIFFwarningHandlerExt)(0, module, fmt, ap);
va_end(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); va_start(ap, fmt);
(*_TIFFwarningHandler)(module, fmt, ap); (*_TIFFwarningHandler)(module, fmt, ap);
va_end(ap); va_end(ap);
} }
if (_TIFFwarningHandlerExt) { if (_TIFFwarningHandlerExt)
{
va_start(ap, fmt); va_start(ap, fmt);
(*_TIFFwarningHandlerExt)(fd, module, fmt, ap); (*_TIFFwarningHandlerExt)(fd, module, fmt, ap);
va_end(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);
}
}

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

@ -34,6 +34,7 @@
#include "webp/decode.h" #include "webp/decode.h"
#include "webp/encode.h" #include "webp/encode.h"
#include <stdbool.h>
#include <stdio.h> #include <stdio.h>
#define LSTATE_INIT_DECODE 0x01 #define LSTATE_INIT_DECODE 0x01
@ -42,14 +43,17 @@
* State block for each open TIFF * State block for each open TIFF
* file using WEBP compression/decompression. * file using WEBP compression/decompression.
*/ */
typedef struct { typedef struct
uint16 nSamples; /* number of samples per pixel */ {
uint16_t nSamples; /* number of samples per pixel */
int lossless; /* lossy/lossless compression */ int lossless; /* lossy/lossless compression */
int lossless_exact; /* lossless exact mode. If TRUE, R,G,B values in areas
with alpha = 0 will be preserved */
int quality_level; /* compression level */ int quality_level; /* compression level */
WebPPicture sPicture; /* WebP Picture */ WebPPicture sPicture; /* WebP Picture */
WebPConfig sEncoderConfig; /* WebP encoder config */ WebPConfig sEncoderConfig; /* WebP encoder config */
uint8* pBuffer; /* buffer to hold raw data on encoding */ uint8_t *pBuffer; /* buffer to hold raw data on encoding */
unsigned int buffer_offset; /* current offset into the buffer */ unsigned int buffer_offset; /* current offset into the buffer */
unsigned int buffer_size; unsigned int buffer_size;
@ -67,22 +71,24 @@ typedef struct {
#define DecoderState(tif) LState(tif) #define DecoderState(tif) LState(tif)
#define EncoderState(tif) LState(tif) #define EncoderState(tif) LState(tif)
static int TWebPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s); static int TWebPEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s);
static int TWebPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s); static int TWebPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s);
static static int TWebPDatasetWriter(const uint8_t *data, size_t data_size,
int TWebPDatasetWriter(const uint8_t* data, size_t data_size,
const WebPPicture *const picture) const WebPPicture *const picture)
{ {
static const char module[] = "TWebPDatasetWriter"; static const char module[] = "TWebPDatasetWriter";
TIFF *tif = (TIFF *)(picture->custom_ptr); TIFF *tif = (TIFF *)(picture->custom_ptr);
if ( (tif->tif_rawcc + (tmsize_t)data_size) > tif->tif_rawdatasize ) { if ((tif->tif_rawcc + (tmsize_t)data_size) > tif->tif_rawdatasize)
TIFFErrorExt(tif->tif_clientdata, module, {
"Buffer too small by " TIFF_SIZE_FORMAT " bytes.", TIFFErrorExtR(
tif, module, "Buffer too small by %" TIFF_SIZE_FORMAT " bytes.",
(size_t)(tif->tif_rawcc + data_size - tif->tif_rawdatasize)); (size_t)(tif->tif_rawcc + data_size - tif->tif_rawdatasize));
return 0; return 0;
} else { }
else
{
_TIFFmemcpy(tif->tif_rawcp, data, data_size); _TIFFmemcpy(tif->tif_rawcp, data, data_size);
tif->tif_rawcc += data_size; tif->tif_rawcc += data_size;
tif->tif_rawcp += data_size; tif->tif_rawcp += data_size;
@ -93,8 +99,7 @@ int TWebPDatasetWriter(const uint8_t* data, size_t data_size,
/* /*
* Encode a chunk of pixels. * Encode a chunk of pixels.
*/ */
static int static int TWebPEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
TWebPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{ {
static const char module[] = "TWebPEncode"; static const char module[] = "TWebPEncode";
WebPState *sp = EncoderState(tif); WebPState *sp = EncoderState(tif);
@ -103,55 +108,186 @@ TWebPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
assert(sp != NULL); assert(sp != NULL);
assert(sp->state == LSTATE_INIT_ENCODE); assert(sp->state == LSTATE_INIT_ENCODE);
if( (uint64)sp->buffer_offset + if ((uint64_t)sp->buffer_offset + (uint64_t)cc > sp->buffer_size)
(uint64)cc > sp->buffer_size )
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "Too many bytes to be written");
"Too many bytes to be written");
return 0; return 0;
} }
memcpy(sp->pBuffer + sp->buffer_offset, memcpy(sp->pBuffer + sp->buffer_offset, bp, cc);
bp, cc);
sp->buffer_offset += (unsigned)cc; sp->buffer_offset += (unsigned)cc;
return 1; return 1;
} }
static int static int TWebPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
TWebPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{ {
static const char module[] = "WebPDecode"; static const char module[] = "WebPDecode";
VP8StatusCode status = VP8_STATUS_OK; VP8StatusCode status = VP8_STATUS_OK;
WebPState *sp = DecoderState(tif); WebPState *sp = DecoderState(tif);
uint32_t segment_width, segment_height;
bool decode_whole_strile = false;
(void)s; (void)s;
assert(sp != NULL); assert(sp != NULL);
assert(sp->state == LSTATE_INIT_DECODE); assert(sp->state == LSTATE_INIT_DECODE);
if (sp->psDecoder == NULL)
{
TIFFDirectory *td = &tif->tif_dir;
uint32_t buffer_size;
if (isTiled(tif))
{
segment_width = td->td_tilewidth;
segment_height = td->td_tilelength;
}
else
{
segment_width = td->td_imagewidth;
segment_height = td->td_imagelength - tif->tif_row;
if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip;
}
int webp_width, webp_height;
if (!WebPGetInfo(tif->tif_rawcp,
(uint64_t)tif->tif_rawcc > UINT32_MAX
? UINT32_MAX
: (uint32_t)tif->tif_rawcc,
&webp_width, &webp_height))
{
TIFFErrorExtR(tif, module, "WebPGetInfo() failed");
return 0;
}
if ((uint32_t)webp_width != segment_width ||
(uint32_t)webp_height != segment_height)
{
TIFFErrorExtR(
tif, module, "WebP blob dimension is %dx%d. Expected %ux%u",
webp_width, webp_height, segment_width, segment_height);
return 0;
}
#if WEBP_DECODER_ABI_VERSION >= 0x0002
WebPDecoderConfig config;
if (!WebPInitDecoderConfig(&config))
{
TIFFErrorExtR(tif, module, "WebPInitDecoderConfig() failed");
return 0;
}
const bool bWebPGetFeaturesOK =
WebPGetFeatures(tif->tif_rawcp,
(uint64_t)tif->tif_rawcc > UINT32_MAX
? UINT32_MAX
: (uint32_t)tif->tif_rawcc,
&config.input) == VP8_STATUS_OK;
WebPFreeDecBuffer(&config.output);
if (!bWebPGetFeaturesOK)
{
TIFFErrorExtR(tif, module, "WebPInitDecoderConfig() failed");
return 0;
}
const int webp_bands = config.input.has_alpha ? 4 : 3;
if (webp_bands != sp->nSamples &&
/* We accept the situation where the WebP blob has only 3 bands,
* whereas the raster is 4 bands. This can happen when the alpha
* channel is fully opaque, and WebP decoding works fine in that
* situation.
*/
!(webp_bands == 3 && sp->nSamples == 4))
{
TIFFErrorExtR(tif, module,
"WebP blob band count is %d. Expected %d", webp_bands,
sp->nSamples);
return 0;
}
#endif
buffer_size = segment_width * segment_height * sp->nSamples;
if (occ == (tmsize_t)buffer_size)
{
/* If decoding the whole strip/tile, we can directly use the */
/* output buffer */
decode_whole_strile = true;
}
else if (sp->pBuffer == NULL || buffer_size > sp->buffer_size)
{
if (sp->pBuffer != NULL)
{
_TIFFfreeExt(tif, sp->pBuffer);
sp->pBuffer = NULL;
}
sp->pBuffer = _TIFFmallocExt(tif, buffer_size);
if (!sp->pBuffer)
{
TIFFErrorExtR(tif, module, "Cannot allocate buffer");
return 0;
}
sp->buffer_size = buffer_size;
}
sp->last_y = 0;
WebPInitDecBuffer(&sp->sDecBuffer);
sp->sDecBuffer.is_external_memory = 1;
sp->sDecBuffer.width = segment_width;
sp->sDecBuffer.height = segment_height;
sp->sDecBuffer.u.RGBA.rgba = decode_whole_strile ? op : sp->pBuffer;
sp->sDecBuffer.u.RGBA.stride = segment_width * sp->nSamples;
sp->sDecBuffer.u.RGBA.size = buffer_size;
if (sp->nSamples > 3)
{
sp->sDecBuffer.colorspace = MODE_RGBA;
}
else
{
sp->sDecBuffer.colorspace = MODE_RGB;
}
sp->psDecoder = WebPINewDecoder(&sp->sDecBuffer);
if (sp->psDecoder == NULL)
{
TIFFErrorExtR(tif, module, "Unable to allocate WebP decoder.");
return 0;
}
}
if (occ % sp->sDecBuffer.u.RGBA.stride) if (occ % sp->sDecBuffer.u.RGBA.stride)
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "Fractional scanlines cannot be read");
"Fractional scanlines cannot be read");
return 0; return 0;
} }
status = WebPIAppend(sp->psDecoder, tif->tif_rawcp, tif->tif_rawcc); status = WebPIAppend(sp->psDecoder, tif->tif_rawcp, tif->tif_rawcc);
if (status != VP8_STATUS_OK && status != VP8_STATUS_SUSPENDED) { if (status != VP8_STATUS_OK && status != VP8_STATUS_SUSPENDED)
if (status == VP8_STATUS_INVALID_PARAM) { {
TIFFErrorExt(tif->tif_clientdata, module, if (status == VP8_STATUS_INVALID_PARAM)
"Invalid parameter used."); {
} else if (status == VP8_STATUS_OUT_OF_MEMORY) { TIFFErrorExtR(tif, module, "Invalid parameter used.");
TIFFErrorExt(tif->tif_clientdata, module, }
"Out of memory."); else if (status == VP8_STATUS_OUT_OF_MEMORY)
} else { {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "Out of memory.");
"Unrecognized error."); }
else
{
TIFFErrorExtR(tif, module, "Unrecognized error.");
} }
return 0; return 0;
} else { }
else
{
int current_y, stride; int current_y, stride;
uint8_t *buf; uint8_t *buf;
@ -159,30 +295,58 @@ TWebPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
buf = WebPIDecGetRGB(sp->psDecoder, &current_y, NULL, NULL, &stride); buf = WebPIDecGetRGB(sp->psDecoder, &current_y, NULL, NULL, &stride);
if ((buf != NULL) && if ((buf != NULL) &&
(occ <= stride * (current_y - sp->last_y))) { (occ <= (tmsize_t)stride * (current_y - sp->last_y)))
memcpy(op, {
buf + (sp->last_y * stride), const int numberOfExpectedLines =
occ); (int)(occ / sp->sDecBuffer.u.RGBA.stride);
if (decode_whole_strile)
{
if (current_y != numberOfExpectedLines)
{
TIFFErrorExtR(tif, module,
"Unable to decode WebP data: less lines than "
"expected.");
return 0;
}
}
else
{
memcpy(op, buf + (sp->last_y * stride), occ);
}
tif->tif_rawcp += tif->tif_rawcc; tif->tif_rawcp += tif->tif_rawcc;
tif->tif_rawcc = 0; tif->tif_rawcc = 0;
sp->last_y += occ / sp->sDecBuffer.u.RGBA.stride; sp->last_y += numberOfExpectedLines;
if (decode_whole_strile)
{
/* We can now free the decoder as we're completely done */
if (sp->psDecoder != NULL)
{
WebPIDelete(sp->psDecoder);
WebPFreeDecBuffer(&sp->sDecBuffer);
sp->psDecoder = NULL;
}
}
return 1; return 1;
} else { }
TIFFErrorExt(tif->tif_clientdata, module, "Unable to decode WebP data."); else
{
TIFFErrorExtR(tif, module, "Unable to decode WebP data.");
return 0; return 0;
} }
} }
} }
static int static int TWebPFixupTags(TIFF *tif)
TWebPFixupTags(TIFF* tif)
{ {
(void)tif; (void)tif;
if (tif->tif_dir.td_planarconfig != PLANARCONFIG_CONTIG) { if (tif->tif_dir.td_planarconfig != PLANARCONFIG_CONTIG)
{
static const char module[] = "TWebPFixupTags"; static const char module[] = "TWebPFixupTags";
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module,
"TIFF WEBP requires data to be stored contiguously in RGB e.g. RGBRGBRGB " "TIFF WEBP requires data to be stored contiguously in "
"RGB e.g. RGBRGBRGB "
#if WEBP_ENCODER_ABI_VERSION >= 0x0100 #if WEBP_ENCODER_ABI_VERSION >= 0x0100
"or RGBARGBARGBA" "or RGBARGBARGBA"
#endif #endif
@ -192,12 +356,11 @@ TWebPFixupTags(TIFF* tif)
return 1; return 1;
} }
static int static int TWebPSetupDecode(TIFF *tif)
TWebPSetupDecode(TIFF* tif)
{ {
static const char module[] = "WebPSetupDecode"; static const char module[] = "WebPSetupDecode";
uint16 nBitsPerSample = tif->tif_dir.td_bitspersample; uint16_t nBitsPerSample = tif->tif_dir.td_bitspersample;
uint16 sampleFormat = tif->tif_dir.td_sampleformat; uint16_t sampleFormat = tif->tif_dir.td_sampleformat;
WebPState *sp = DecoderState(tif); WebPState *sp = DecoderState(tif);
assert(sp != NULL); assert(sp != NULL);
@ -211,7 +374,7 @@ TWebPSetupDecode(TIFF* tif)
#endif #endif
) )
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module,
"WEBP driver doesn't support %d bands. Must be 3 (RGB) " "WEBP driver doesn't support %d bands. Must be 3 (RGB) "
#if WEBP_ENCODER_ABI_VERSION >= 0x0100 #if WEBP_ENCODER_ABI_VERSION >= 0x0100
"or 4 (RGBA) " "or 4 (RGBA) "
@ -222,17 +385,19 @@ TWebPSetupDecode(TIFF* tif)
} }
/* check bits per sample and data type */ /* check bits per sample and data type */
if ((nBitsPerSample != 8) && (sampleFormat != 1)) { if ((nBitsPerSample != 8) && (sampleFormat != 1))
TIFFErrorExt(tif->tif_clientdata, module, {
"WEBP driver requires 8 bit unsigned data"); TIFFErrorExtR(tif, module, "WEBP driver requires 8 bit unsigned data");
return 0; return 0;
} }
/* 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)
{
WebPPictureFree(&sp->sPicture); WebPPictureFree(&sp->sPicture);
if (sp->pBuffer != NULL) { if (sp->pBuffer != NULL)
_TIFFfree(sp->pBuffer); {
_TIFFfreeExt(tif, sp->pBuffer);
sp->pBuffer = NULL; sp->pBuffer = NULL;
} }
sp->buffer_offset = 0; sp->buffer_offset = 0;
@ -247,28 +412,31 @@ TWebPSetupDecode(TIFF* tif)
/* /*
* Setup state for decoding a strip. * Setup state for decoding a strip.
*/ */
static int static int TWebPPreDecode(TIFF *tif, uint16_t s)
TWebPPreDecode(TIFF* tif, uint16 s)
{ {
static const char module[] = "TWebPPreDecode"; static const char module[] = "TWebPPreDecode";
uint32 segment_width, segment_height; uint32_t segment_width, segment_height;
WebPState *sp = DecoderState(tif); WebPState *sp = DecoderState(tif);
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
(void)s; (void)s;
assert(sp != NULL); assert(sp != NULL);
if (isTiled(tif)) { if (isTiled(tif))
{
segment_width = td->td_tilewidth; segment_width = td->td_tilewidth;
segment_height = td->td_tilelength; segment_height = td->td_tilelength;
} else { }
else
{
segment_width = td->td_imagewidth; segment_width = td->td_imagewidth;
segment_height = td->td_imagelength - tif->tif_row; segment_height = td->td_imagelength - tif->tif_row;
if (segment_height > td->td_rowsperstrip) if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip; segment_height = td->td_rowsperstrip;
} }
if( segment_width > 16383 || segment_height > 16383 ) { if (segment_width > 16383 || segment_height > 16383)
TIFFErrorExt(tif->tif_clientdata, module, {
TIFFErrorExtR(tif, module,
"WEBP maximum image dimensions are 16383 x 16383."); "WEBP maximum image dimensions are 16383 x 16383.");
return 0; return 0;
} }
@ -276,45 +444,21 @@ TWebPPreDecode(TIFF* tif, uint16 s)
if ((sp->state & LSTATE_INIT_DECODE) == 0) if ((sp->state & LSTATE_INIT_DECODE) == 0)
tif->tif_setupdecode(tif); tif->tif_setupdecode(tif);
if (sp->psDecoder != NULL) { if (sp->psDecoder != NULL)
{
WebPIDelete(sp->psDecoder); WebPIDelete(sp->psDecoder);
WebPFreeDecBuffer(&sp->sDecBuffer); WebPFreeDecBuffer(&sp->sDecBuffer);
sp->psDecoder = NULL; sp->psDecoder = NULL;
} }
sp->last_y = 0;
WebPInitDecBuffer(&sp->sDecBuffer);
sp->sDecBuffer.is_external_memory = 0;
sp->sDecBuffer.width = segment_width;
sp->sDecBuffer.height = segment_height;
sp->sDecBuffer.u.RGBA.stride = segment_width * sp->nSamples;
sp->sDecBuffer.u.RGBA.size = segment_width * sp->nSamples * segment_height;
if (sp->nSamples > 3) {
sp->sDecBuffer.colorspace = MODE_RGBA;
} else {
sp->sDecBuffer.colorspace = MODE_RGB;
}
sp->psDecoder = WebPINewDecoder(&sp->sDecBuffer);
if (sp->psDecoder == NULL) {
TIFFErrorExt(tif->tif_clientdata, module,
"Unable to allocate WebP decoder.");
return 0;
}
return 1; return 1;
} }
static int static int TWebPSetupEncode(TIFF *tif)
TWebPSetupEncode(TIFF* tif)
{ {
static const char module[] = "WebPSetupEncode"; static const char module[] = "WebPSetupEncode";
uint16 nBitsPerSample = tif->tif_dir.td_bitspersample; uint16_t nBitsPerSample = tif->tif_dir.td_bitspersample;
uint16 sampleFormat = tif->tif_dir.td_sampleformat; uint16_t sampleFormat = tif->tif_dir.td_sampleformat;
WebPState *sp = EncoderState(tif); WebPState *sp = EncoderState(tif);
assert(sp != NULL); assert(sp != NULL);
@ -328,7 +472,7 @@ TWebPSetupEncode(TIFF* tif)
#endif #endif
) )
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module,
"WEBP driver doesn't support %d bands. Must be 3 (RGB) " "WEBP driver doesn't support %d bands. Must be 3 (RGB) "
#if WEBP_ENCODER_ABI_VERSION >= 0x0100 #if WEBP_ENCODER_ABI_VERSION >= 0x0100
"or 4 (RGBA) " "or 4 (RGBA) "
@ -339,13 +483,14 @@ TWebPSetupEncode(TIFF* tif)
} }
/* check bits per sample and data type */ /* check bits per sample and data type */
if ((nBitsPerSample != 8) || (sampleFormat != SAMPLEFORMAT_UINT)) { if ((nBitsPerSample != 8) || (sampleFormat != SAMPLEFORMAT_UINT))
TIFFErrorExt(tif->tif_clientdata, module, {
"WEBP driver requires 8 bit unsigned data"); TIFFErrorExtR(tif, module, "WEBP driver requires 8 bit unsigned data");
return 0; return 0;
} }
if (sp->state & LSTATE_INIT_DECODE) { if (sp->state & LSTATE_INIT_DECODE)
{
WebPIDelete(sp->psDecoder); WebPIDelete(sp->psDecoder);
WebPFreeDecBuffer(&sp->sDecBuffer); WebPFreeDecBuffer(&sp->sDecBuffer);
sp->psDecoder = NULL; sp->psDecoder = NULL;
@ -355,16 +500,17 @@ TWebPSetupEncode(TIFF* tif)
sp->state |= LSTATE_INIT_ENCODE; sp->state |= LSTATE_INIT_ENCODE;
if (!WebPPictureInit(&sp->sPicture)) { if (!WebPPictureInit(&sp->sPicture))
TIFFErrorExt(tif->tif_clientdata, module, {
"Error initializing WebP picture."); TIFFErrorExtR(tif, module, "Error initializing WebP picture.");
return 0; return 0;
} }
if (!WebPConfigInitInternal(&sp->sEncoderConfig, WEBP_PRESET_DEFAULT, if (!WebPConfigInitInternal(&sp->sEncoderConfig, WEBP_PRESET_DEFAULT,
(float)sp->quality_level, (float)sp->quality_level,
WEBP_ENCODER_ABI_VERSION)) { WEBP_ENCODER_ABI_VERSION))
TIFFErrorExt(tif->tif_clientdata, module, {
TIFFErrorExtR(tif, module,
"Error creating WebP encoder configuration."); "Error creating WebP encoder configuration.");
return 0; return 0;
} }
@ -372,14 +518,18 @@ TWebPSetupEncode(TIFF* tif)
// WebPConfigInitInternal above sets lossless to false // WebPConfigInitInternal above sets lossless to false
#if WEBP_ENCODER_ABI_VERSION >= 0x0100 #if WEBP_ENCODER_ABI_VERSION >= 0x0100
sp->sEncoderConfig.lossless = sp->lossless; sp->sEncoderConfig.lossless = sp->lossless;
if (sp->lossless) { if (sp->lossless)
{
sp->sPicture.use_argb = 1; sp->sPicture.use_argb = 1;
#if WEBP_ENCODER_ABI_VERSION >= 0x0209
sp->sEncoderConfig.exact = sp->lossless_exact;
#endif
} }
#endif #endif
if (!WebPValidateConfig(&sp->sEncoderConfig)) { if (!WebPValidateConfig(&sp->sEncoderConfig))
TIFFErrorExt(tif->tif_clientdata, module, {
"Error with WebP encoder configuration."); TIFFErrorExtR(tif, module, "Error with WebP encoder configuration.");
return 0; return 0;
} }
@ -389,11 +539,10 @@ TWebPSetupEncode(TIFF* tif)
/* /*
* Reset encoding state at the start of a strip. * Reset encoding state at the start of a strip.
*/ */
static int static int TWebPPreEncode(TIFF *tif, uint16_t s)
TWebPPreEncode(TIFF* tif, uint16 s)
{ {
static const char module[] = "TWebPPreEncode"; static const char module[] = "TWebPPreEncode";
uint32 segment_width, segment_height; uint32_t segment_width, segment_height;
WebPState *sp = EncoderState(tif); WebPState *sp = EncoderState(tif);
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
@ -406,18 +555,22 @@ TWebPPreEncode(TIFF* tif, uint16 s)
/* /*
* Set encoding parameters for this strip/tile. * Set encoding parameters for this strip/tile.
*/ */
if (isTiled(tif)) { if (isTiled(tif))
{
segment_width = td->td_tilewidth; segment_width = td->td_tilewidth;
segment_height = td->td_tilelength; segment_height = td->td_tilelength;
} else { }
else
{
segment_width = td->td_imagewidth; segment_width = td->td_imagewidth;
segment_height = td->td_imagelength - tif->tif_row; segment_height = td->td_imagelength - tif->tif_row;
if (segment_height > td->td_rowsperstrip) if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip; segment_height = td->td_rowsperstrip;
} }
if( segment_width > 16383 || segment_height > 16383 ) { if (segment_width > 16383 || segment_height > 16383)
TIFFErrorExt(tif->tif_clientdata, module, {
TIFFErrorExtR(tif, module,
"WEBP maximum image dimensions are 16383 x 16383."); "WEBP maximum image dimensions are 16383 x 16383.");
return 0; return 0;
} }
@ -426,14 +579,16 @@ TWebPPreEncode(TIFF* tif, uint16 s)
/* given above check and that nSamples <= 4, buffer_size is <= 1 GB */ /* given above check and that nSamples <= 4, buffer_size is <= 1 GB */
sp->buffer_size = segment_width * segment_height * sp->nSamples; sp->buffer_size = segment_width * segment_height * sp->nSamples;
if (sp->pBuffer != NULL) { if (sp->pBuffer != NULL)
_TIFFfree(sp->pBuffer); {
_TIFFfreeExt(tif, sp->pBuffer);
sp->pBuffer = NULL; sp->pBuffer = NULL;
} }
sp->pBuffer = _TIFFmalloc(sp->buffer_size); sp->pBuffer = _TIFFmallocExt(tif, sp->buffer_size);
if( !sp->pBuffer) { if (!sp->pBuffer)
TIFFErrorExt(tif->tif_clientdata, module, "Cannot allocate buffer"); {
TIFFErrorExtR(tif, module, "Cannot allocate buffer");
return 0; return 0;
} }
sp->buffer_offset = 0; sp->buffer_offset = 0;
@ -449,8 +604,7 @@ TWebPPreEncode(TIFF* tif, uint16 s)
/* /*
* Finish off an encoded strip by flushing it. * Finish off an encoded strip by flushing it.
*/ */
static int static int TWebPPostEncode(TIFF *tif)
TWebPPostEncode(TIFF* tif)
{ {
static const char module[] = "WebPPostEncode"; static const char module[] = "WebPPostEncode";
int64_t stride; int64_t stride;
@ -462,36 +616,44 @@ TWebPPostEncode(TIFF* tif)
stride = (int64_t)sp->sPicture.width * sp->nSamples; stride = (int64_t)sp->sPicture.width * sp->nSamples;
#if WEBP_ENCODER_ABI_VERSION >= 0x0100 #if WEBP_ENCODER_ABI_VERSION >= 0x0100
if (sp->nSamples == 4) { if (sp->nSamples == 4)
if (!WebPPictureImportRGBA(&sp->sPicture, sp->pBuffer, (int)stride)) { {
TIFFErrorExt(tif->tif_clientdata, module, if (!WebPPictureImportRGBA(&sp->sPicture, sp->pBuffer, (int)stride))
"WebPPictureImportRGBA() failed" ); {
TIFFErrorExtR(tif, module, "WebPPictureImportRGBA() failed");
return 0; return 0;
} }
} }
else else
#endif #endif
if (!WebPPictureImportRGB(&sp->sPicture, sp->pBuffer, (int)stride)) { if (!WebPPictureImportRGB(&sp->sPicture, sp->pBuffer, (int)stride))
TIFFErrorExt(tif->tif_clientdata, module, {
"WebPPictureImportRGB() failed"); TIFFErrorExtR(tif, module, "WebPPictureImportRGB() failed");
return 0; return 0;
} }
if (!WebPEncode(&sp->sEncoderConfig, &sp->sPicture)) { if (!WebPEncode(&sp->sEncoderConfig, &sp->sPicture))
{
#if WEBP_ENCODER_ABI_VERSION >= 0x0100 #if WEBP_ENCODER_ABI_VERSION >= 0x0100
const char *pszErrorMsg = NULL; const char *pszErrorMsg = NULL;
switch(sp->sPicture.error_code) { switch (sp->sPicture.error_code)
{
case VP8_ENC_ERROR_OUT_OF_MEMORY: case VP8_ENC_ERROR_OUT_OF_MEMORY:
pszErrorMsg = "Out of memory"; break; pszErrorMsg = "Out of memory";
break;
case VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY: case VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY:
pszErrorMsg = "Out of memory while flushing bits"; break; pszErrorMsg = "Out of memory while flushing bits";
break;
case VP8_ENC_ERROR_NULL_PARAMETER: case VP8_ENC_ERROR_NULL_PARAMETER:
pszErrorMsg = "A pointer parameter is NULL"; break; pszErrorMsg = "A pointer parameter is NULL";
break;
case VP8_ENC_ERROR_INVALID_CONFIGURATION: case VP8_ENC_ERROR_INVALID_CONFIGURATION:
pszErrorMsg = "Configuration is invalid"; break; pszErrorMsg = "Configuration is invalid";
break;
case VP8_ENC_ERROR_BAD_DIMENSION: case VP8_ENC_ERROR_BAD_DIMENSION:
pszErrorMsg = "Picture has invalid width/height"; break; pszErrorMsg = "Picture has invalid width/height";
break;
case VP8_ENC_ERROR_PARTITION0_OVERFLOW: case VP8_ENC_ERROR_PARTITION0_OVERFLOW:
pszErrorMsg = "Partition is bigger than 512k. Try using less " pszErrorMsg = "Partition is bigger than 512k. Try using less "
"SEGMENTS, or increase PARTITION_LIMIT value"; "SEGMENTS, or increase PARTITION_LIMIT value";
@ -500,24 +662,24 @@ TWebPPostEncode(TIFF* tif)
pszErrorMsg = "Partition is bigger than 16M"; pszErrorMsg = "Partition is bigger than 16M";
break; break;
case VP8_ENC_ERROR_BAD_WRITE: case VP8_ENC_ERROR_BAD_WRITE:
pszErrorMsg = "Error while fludshing bytes"; break; pszErrorMsg = "Error while fludshing bytes";
break;
case VP8_ENC_ERROR_FILE_TOO_BIG: case VP8_ENC_ERROR_FILE_TOO_BIG:
pszErrorMsg = "File is bigger than 4G"; break; pszErrorMsg = "File is bigger than 4G";
break;
case VP8_ENC_ERROR_USER_ABORT: case VP8_ENC_ERROR_USER_ABORT:
pszErrorMsg = "User interrupted"; pszErrorMsg = "User interrupted";
break; break;
default: default:
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module,
"WebPEncode returned an unknown error code: %d", "WebPEncode returned an unknown error code: %d",
sp->sPicture.error_code); sp->sPicture.error_code);
pszErrorMsg = "Unknown WebP error type."; pszErrorMsg = "Unknown WebP error type.";
break; break;
} }
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "WebPEncode() failed : %s", pszErrorMsg);
"WebPEncode() failed : %s", pszErrorMsg);
#else #else
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "Error in WebPEncode()");
"Error in WebPEncode()");
#endif #endif
return 0; return 0;
} }
@ -526,16 +688,14 @@ TWebPPostEncode(TIFF* tif)
if (!TIFFFlushData1(tif)) if (!TIFFFlushData1(tif))
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "Error flushing TIFF WebP encoder.");
"Error flushing TIFF WebP encoder.");
return 0; return 0;
} }
return 1; return 1;
} }
static void static void TWebPCleanup(TIFF *tif)
TWebPCleanup(TIFF* tif)
{ {
WebPState *sp = LState(tif); WebPState *sp = LState(tif);
@ -544,52 +704,68 @@ TWebPCleanup(TIFF* 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 & LSTATE_INIT_ENCODE) { if (sp->state & LSTATE_INIT_ENCODE)
{
WebPPictureFree(&sp->sPicture); WebPPictureFree(&sp->sPicture);
} }
if (sp->psDecoder != NULL) { if (sp->psDecoder != NULL)
{
WebPIDelete(sp->psDecoder); WebPIDelete(sp->psDecoder);
WebPFreeDecBuffer(&sp->sDecBuffer); WebPFreeDecBuffer(&sp->sDecBuffer);
sp->psDecoder = NULL; sp->psDecoder = NULL;
sp->last_y = 0; sp->last_y = 0;
} }
if (sp->pBuffer != NULL) { if (sp->pBuffer != NULL)
_TIFFfree(sp->pBuffer); {
_TIFFfreeExt(tif, sp->pBuffer);
sp->pBuffer = NULL; sp->pBuffer = NULL;
} }
_TIFFfree(tif->tif_data); _TIFFfreeExt(tif, tif->tif_data);
tif->tif_data = NULL; tif->tif_data = NULL;
_TIFFSetDefaultCompressionState(tif); _TIFFSetDefaultCompressionState(tif);
} }
static int static int TWebPVSetField(TIFF *tif, uint32_t tag, va_list ap)
TWebPVSetField(TIFF* tif, uint32 tag, va_list ap)
{ {
static const char module[] = "WebPVSetField"; static const char module[] = "WebPVSetField";
WebPState *sp = LState(tif); WebPState *sp = LState(tif);
switch (tag) { switch (tag)
{
case TIFFTAG_WEBP_LEVEL: case TIFFTAG_WEBP_LEVEL:
sp->quality_level = (int)va_arg(ap, int); sp->quality_level = (int)va_arg(ap, int);
if( sp->quality_level <= 0 || if (sp->quality_level <= 0 || sp->quality_level > 100.0f)
sp->quality_level > 100.0f ) { {
TIFFWarningExt(tif->tif_clientdata, module, TIFFWarningExtR(tif, module,
"WEBP_LEVEL should be between 1 and 100"); "WEBP_LEVEL should be between 1 and 100");
} }
return 1; return 1;
case TIFFTAG_WEBP_LOSSLESS: case TIFFTAG_WEBP_LOSSLESS:
#if WEBP_ENCODER_ABI_VERSION >= 0x0100 #if WEBP_ENCODER_ABI_VERSION >= 0x0100
sp->lossless = va_arg(ap, int); sp->lossless = va_arg(ap, int);
if (sp->lossless){ if (sp->lossless)
{
sp->quality_level = 100; sp->quality_level = 100;
} }
return 1; return 1;
#else #else
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(
tif, module,
"Need to upgrade WEBP driver, this version doesn't support "
"lossless compression.");
return 0;
#endif
case TIFFTAG_WEBP_LOSSLESS_EXACT:
#if WEBP_ENCODER_ABI_VERSION >= 0x0209
sp->lossless_exact = va_arg(ap, int);
return 1;
#else
TIFFErrorExtR(
tif, module,
"Need to upgrade WEBP driver, this version doesn't support " "Need to upgrade WEBP driver, this version doesn't support "
"lossless compression."); "lossless compression.");
return 0; return 0;
@ -600,18 +776,21 @@ TWebPVSetField(TIFF* tif, uint32 tag, va_list ap)
/*NOTREACHED*/ /*NOTREACHED*/
} }
static int static int TWebPVGetField(TIFF *tif, uint32_t tag, va_list ap)
TWebPVGetField(TIFF* tif, uint32 tag, va_list ap)
{ {
WebPState *sp = LState(tif); WebPState *sp = LState(tif);
switch (tag) { switch (tag)
{
case TIFFTAG_WEBP_LEVEL: case TIFFTAG_WEBP_LEVEL:
*va_arg(ap, int *) = sp->quality_level; *va_arg(ap, int *) = sp->quality_level;
break; break;
case TIFFTAG_WEBP_LOSSLESS: case TIFFTAG_WEBP_LOSSLESS:
*va_arg(ap, int *) = sp->lossless; *va_arg(ap, int *) = sp->lossless;
break; break;
case TIFFTAG_WEBP_LOSSLESS_EXACT:
*va_arg(ap, int *) = sp->lossless_exact;
break;
default: default:
return (*sp->vgetparent)(tif, tag, ap); return (*sp->vgetparent)(tif, tag, ap);
} }
@ -620,16 +799,16 @@ TWebPVGetField(TIFF* tif, uint32 tag, va_list ap)
static const TIFFField TWebPFields[] = { static const TIFFField TWebPFields[] = {
{TIFFTAG_WEBP_LEVEL, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, {TIFFTAG_WEBP_LEVEL, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "WEBP quality", NULL},
FIELD_PSEUDO, TRUE, FALSE, "WEBP quality", NULL },
{TIFFTAG_WEBP_LOSSLESS, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, {TIFFTAG_WEBP_LOSSLESS, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
TIFF_SETGET_UNDEFINED, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "WEBP lossless/lossy",
FIELD_PSEUDO, TRUE, FALSE, "WEBP lossless/lossy", NULL NULL},
}, {TIFFTAG_WEBP_LOSSLESS_EXACT, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "WEBP exact lossless",
NULL},
}; };
int int TIFFInitWebP(TIFF *tif, int scheme)
TIFFInitWebP(TIFF* tif, int scheme)
{ {
static const char module[] = "TIFFInitWebP"; static const char module[] = "TIFFInitWebP";
WebPState *sp; WebPState *sp;
@ -640,16 +819,16 @@ TIFFInitWebP(TIFF* tif, int scheme)
/* /*
* Merge codec-specific tag information. * Merge codec-specific tag information.
*/ */
if ( !_TIFFMergeFields(tif, TWebPFields, TIFFArrayCount(TWebPFields)) ) { if (!_TIFFMergeFields(tif, TWebPFields, TIFFArrayCount(TWebPFields)))
TIFFErrorExt(tif->tif_clientdata, module, {
"Merging WebP codec-specific tags failed"); TIFFErrorExtR(tif, module, "Merging WebP 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(WebPState)); tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(WebPState));
if (tif->tif_data == NULL) if (tif->tif_data == NULL)
goto bad; goto bad;
sp = LState(tif); sp = LState(tif);
@ -665,6 +844,7 @@ TIFFInitWebP(TIFF* tif, int scheme)
/* Default values for codec-specific fields */ /* Default values for codec-specific fields */
sp->quality_level = 75; /* default comp. level */ sp->quality_level = 75; /* default comp. level */
sp->lossless = 0; /* default to false */ sp->lossless = 0; /* default to false */
sp->lossless_exact = 1; /* exact lossless mode (if lossless enabled) */
sp->state = 0; sp->state = 0;
sp->nSamples = 0; sp->nSamples = 0;
sp->psDecoder = NULL; sp->psDecoder = NULL;
@ -694,8 +874,7 @@ TIFFInitWebP(TIFF* tif, int scheme)
return 1; return 1;
bad: bad:
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "No space for WebP state block");
"No space for WebP state block");
return 0; return 0;
} }

243
3rdparty/libtiff/tif_win32.c vendored
View File

@ -28,6 +28,7 @@
*/ */
#include "tiffiop.h" #include "tiffiop.h"
#include <stdlib.h>
#include <windows.h> #include <windows.h>
@ -54,29 +55,25 @@ 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; }
{
return (int)(intptr_t)fd;
}
static tmsize_t static tmsize_t _tiffReadProc(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 ReadFile 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 (!ReadFile(fd, (LPVOID)ma, n, &o, NULL))
return (0); return (0);
@ -89,24 +86,23 @@ _tiffReadProc(thandle_t fd, void* buf, tmsize_t size)
return (p); return (p);
} }
static tmsize_t static tmsize_t _tiffWriteProc(thandle_t fd, void *buf, tmsize_t size)
_tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)
{ {
/* tmsize_t is 64bit on 64bit systems, but the WinAPI WriteFile 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 (!WriteFile(fd, (LPVOID)ma, n, &o, NULL)) if (!WriteFile(fd, (LPVOID)ma, n, &o, NULL))
return (0); return (0);
@ -119,8 +115,7 @@ _tiffWriteProc(thandle_t fd, void* buf, tmsize_t size)
return (p); return (p);
} }
static uint64 static uint64_t _tiffSeekProc(thandle_t fd, uint64_t off, int whence)
_tiffSeekProc(thandle_t fd, uint64 off, int whence)
{ {
LARGE_INTEGER offli; LARGE_INTEGER offli;
DWORD dwMoveMethod; DWORD dwMoveMethod;
@ -140,20 +135,17 @@ _tiffSeekProc(thandle_t fd, uint64 off, int whence)
dwMoveMethod = FILE_BEGIN; dwMoveMethod = FILE_BEGIN;
break; break;
} }
offli.LowPart=SetFilePointer(fd,offli.LowPart,&offli.HighPart,dwMoveMethod); offli.LowPart =
if ((offli.LowPart==INVALID_SET_FILE_POINTER)&&(GetLastError()!=NO_ERROR)) SetFilePointer(fd, offli.LowPart, &offli.HighPart, dwMoveMethod);
if ((offli.LowPart == INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR))
offli.QuadPart = 0; offli.QuadPart = 0;
return (offli.QuadPart); return (offli.QuadPart);
} }
static int static int _tiffCloseProc(thandle_t fd) { return (CloseHandle(fd) ? 0 : -1); }
_tiffCloseProc(thandle_t fd)
{
return (CloseHandle(fd) ? 0 : -1);
}
static uint64 static uint64_t _tiffSizeProc(thandle_t fd)
_tiffSizeProc(thandle_t fd)
{ {
LARGE_INTEGER m; LARGE_INTEGER m;
if (GetFileSizeEx(fd, &m)) if (GetFileSizeEx(fd, &m))
@ -162,8 +154,7 @@ _tiffSizeProc(thandle_t fd)
return (0); return (0);
} }
static int static int _tiffDummyMapProc(thandle_t fd, void **pbase, toff_t *psize)
_tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
{ {
(void)fd; (void)fd;
(void)pbase; (void)pbase;
@ -182,16 +173,15 @@ _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
@ -207,16 +197,14 @@ _tiffMapProc(thandle_t fd, void** pbase, toff_t* psize)
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;
@ -228,12 +216,18 @@ _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) {
return TIFFFdOpenExt(ifd, name, mode, NULL);
}
TIFF *TIFFFdOpenExt(int ifd, const char *name, const char *mode,
TIFFOpenOptions *opts)
{ {
TIFF *tif; TIFF *tif;
int fSuppressMap; int fSuppressMap;
int m; int m;
fSuppressMap = 0; fSuppressMap = 0;
for (m = 0; mode[m] != 0; m++) for (m = 0; mode[m] != 0; m++)
{ {
@ -243,11 +237,12 @@ TIFFFdOpen(int ifd, const char* name, const char* mode)
break; break;
} }
} }
tif = TIFFClientOpen(name, mode, thandle_from_int(ifd),
_tiffReadProc, _tiffWriteProc, tif = TIFFClientOpenExt(
name, mode, thandle_from_int(ifd), _tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc, _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
fSuppressMap ? _tiffDummyMapProc : _tiffMapProc, fSuppressMap ? _tiffDummyMapProc : _tiffMapProc,
fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc); fSuppressMap ? _tiffDummyUnmapProc : _tiffUnmapProc, opts);
if (tif) if (tif)
tif->tif_fd = ifd; tif->tif_fd = ifd;
return (tif); return (tif);
@ -258,8 +253,12 @@ 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) {
return TIFFOpenExt(name, mode, NULL);
}
TIFF *TIFFOpenExt(const char *name, const char *mode, TIFFOpenOptions *opts)
{ {
static const char module[] = "TIFFOpen"; static const char module[] = "TIFFOpen";
thandle_t fd; thandle_t fd;
@ -267,28 +266,41 @@ TIFFOpen(const char* name, const char* mode)
DWORD dwMode; DWORD dwMode;
TIFF *tif; TIFF *tif;
m = _TIFFgetMode(mode, module); m = _TIFFgetMode(opts, NULL, mode, module);
switch(m) { switch (m)
case O_RDONLY: dwMode = OPEN_EXISTING; break; {
case O_RDWR: dwMode = OPEN_ALWAYS; break; case O_RDONLY:
case O_RDWR|O_CREAT: dwMode = OPEN_ALWAYS; break; dwMode = OPEN_EXISTING;
case O_RDWR|O_TRUNC: dwMode = CREATE_ALWAYS; break; break;
case O_RDWR|O_CREAT|O_TRUNC: dwMode = CREATE_ALWAYS; break; case O_RDWR:
default: return ((TIFF*)0); dwMode = OPEN_EXISTING;
} break;
case O_RDWR | O_CREAT:
fd = (thandle_t)CreateFileA(name, dwMode = OPEN_ALWAYS;
(m == O_RDONLY)?GENERIC_READ:(GENERIC_READ | GENERIC_WRITE), break;
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode, case O_RDWR | O_TRUNC:
(m == O_RDONLY)?FILE_ATTRIBUTE_READONLY:FILE_ATTRIBUTE_NORMAL, dwMode = CREATE_ALWAYS;
NULL); break;
if (fd == INVALID_HANDLE_VALUE) { case O_RDWR | O_CREAT | O_TRUNC:
TIFFErrorExt(0, module, "%s: Cannot open", name); dwMode = CREATE_ALWAYS;
break;
default:
return ((TIFF *)0); return ((TIFF *)0);
} }
tif = TIFFFdOpen(thandle_to_int(fd), name, mode); 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) if (!tif)
CloseHandle(fd); CloseHandle(fd);
return tif; return tif;
@ -297,8 +309,12 @@ 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) {
return TIFFOpenWExt(name, mode, NULL);
}
TIFF *TIFFOpenWExt(const wchar_t *name, const char *mode, TIFFOpenOptions *opts)
{ {
static const char module[] = "TIFFOpenW"; static const char module[] = "TIFFOpenW";
thandle_t fd; thandle_t fd;
@ -308,43 +324,58 @@ TIFFOpenW(const wchar_t* name, const char* mode)
char *mbname; char *mbname;
TIFF *tif; TIFF *tif;
m = _TIFFgetMode(mode, module); m = _TIFFgetMode(opts, NULL, mode, module);
switch(m) { switch (m)
case O_RDONLY: dwMode = OPEN_EXISTING; break; {
case O_RDWR: dwMode = OPEN_ALWAYS; break; case O_RDONLY:
case O_RDWR|O_CREAT: dwMode = OPEN_ALWAYS; break; dwMode = OPEN_EXISTING;
case O_RDWR|O_TRUNC: dwMode = CREATE_ALWAYS; break; break;
case O_RDWR|O_CREAT|O_TRUNC: dwMode = CREATE_ALWAYS; break; case O_RDWR:
default: return ((TIFF*)0); 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)CreateFileW(name, fd = (thandle_t)CreateFileW(
(m == O_RDONLY)?GENERIC_READ:(GENERIC_READ|GENERIC_WRITE), name, (m == O_RDONLY) ? GENERIC_READ : (GENERIC_READ | GENERIC_WRITE),
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, dwMode,
(m == O_RDONLY) ? FILE_ATTRIBUTE_READONLY : FILE_ATTRIBUTE_NORMAL, (m == O_RDONLY) ? FILE_ATTRIBUTE_READONLY : FILE_ATTRIBUTE_NORMAL,
NULL); NULL);
if (fd == INVALID_HANDLE_VALUE) { if (fd == INVALID_HANDLE_VALUE)
TIFFErrorExt(0, module, "%S: Cannot open", name); {
_TIFFErrorEarly(opts, NULL, module, "%S: Cannot open", name);
return ((TIFF *)0); 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 = (char *)_TIFFmalloc(mbsize); mbname = (char *)_TIFFmalloc(mbsize);
if (!mbname) { if (!mbname)
TIFFErrorExt(0, module, {
_TIFFErrorEarly(
opts, NULL, module,
"Can't allocate space for filename conversion buffer"); "Can't allocate space for filename conversion buffer");
return ((TIFF *)0); 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(thandle_to_int(fd), tif = TIFFFdOpenExt(thandle_to_int(fd),
(mbname != NULL) ? mbname : "<unknown>", mode); (mbname != NULL) ? mbname : "<unknown>", mode, opts);
if (!tif) if (!tif)
CloseHandle(fd); CloseHandle(fd);
@ -355,8 +386,7 @@ TIFFOpenW(const wchar_t* name, const char* mode)
#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);
@ -372,44 +402,25 @@ void* _TIFFcalloc(tmsize_t nmemb, tmsize_t siz)
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)
{
free(p);
}
void* void *_TIFFrealloc(void *p, tmsize_t s) { return (realloc(p, (size_t)s)); }
_TIFFrealloc(void* p, tmsize_t s)
{
return (realloc(p, (size_t) s));
}
void void _TIFFmemset(void *p, int v, tmsize_t c) { memset(p, v, (size_t)c); }
_TIFFmemset(void* p, int v, tmsize_t c)
{
memset(p, v, (size_t) c);
}
void void _TIFFmemcpy(void *d, const void *s, tmsize_t c)
_TIFFmemcpy(void* d, const void* s, tmsize_t c)
{ {
memcpy(d, s, (size_t)c); memcpy(d, s, (size_t)c);
} }
int int _TIFFmemcmp(const void *p1, const void *p2, tmsize_t c)
_TIFFmemcmp(const void* p1, const void* p2, tmsize_t c)
{ {
return (memcmp(p1, p2, (size_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);
@ -419,8 +430,7 @@ Win32WarningHandler(const char* module, const char* fmt, va_list ap)
} }
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);
@ -430,12 +440,3 @@ Win32ErrorHandler(const char* module, const char* fmt, va_list ap)
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:
*/

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

@ -40,16 +40,16 @@
((((tif)->tif_flags & TIFF_BUFFERSETUP) && tif->tif_rawdata) || \ ((((tif)->tif_flags & TIFF_BUFFERSETUP) && tif->tif_rawdata) || \
TIFFWriteBufferSetup((tif), NULL, (tmsize_t)-1)) TIFFWriteBufferSetup((tif), NULL, (tmsize_t)-1))
static int TIFFGrowStrips(TIFF* tif, uint32 delta, const char* module); static int TIFFGrowStrips(TIFF *tif, uint32_t delta, const char *module);
static int TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc); static int TIFFAppendToStrip(TIFF *tif, uint32_t strip, uint8_t *data,
tmsize_t cc);
int int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row, uint16_t sample)
TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample)
{ {
static const char module[] = "TIFFWriteScanline"; static const char module[] = "TIFFWriteScanline";
register TIFFDirectory *td; register TIFFDirectory *td;
int status, imagegrew = 0; int status, imagegrew = 0;
uint32 strip; uint32_t strip;
if (!WRITECHECKSTRIPS(tif, module)) if (!WRITECHECKSTRIPS(tif, module))
return (-1); return (-1);
@ -67,9 +67,12 @@ TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample)
* Extend image length if needed * Extend image length if needed
* (but only for PlanarConfig=1). * (but only for PlanarConfig=1).
*/ */
if (row >= td->td_imagelength) { /* extend image */ if (row >= td->td_imagelength)
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { { /* extend image */
TIFFErrorExt(tif->tif_clientdata, module, if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
{
TIFFErrorExtR(
tif, module,
"Can not change \"ImageLength\" when using separate planes"); "Can not change \"ImageLength\" when using separate planes");
return (-1); return (-1);
} }
@ -79,15 +82,18 @@ TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample)
/* /*
* Calculate strip and check for crossings. * Calculate strip and check for crossings.
*/ */
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",
(unsigned long)sample,
(unsigned long)td->td_samplesperpixel);
return (-1); return (-1);
} }
strip = sample * td->td_stripsperimage + row / td->td_rowsperstrip; strip = sample * td->td_stripsperimage + row / td->td_rowsperstrip;
} else }
else
strip = row / td->td_rowsperstrip; strip = row / td->td_rowsperstrip;
/* /*
* Check strip array to make sure there's space. We don't support * Check strip array to make sure there's space. We don't support
@ -98,7 +104,8 @@ TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample)
*/ */
if (strip >= td->td_nstrips && !TIFFGrowStrips(tif, 1, module)) if (strip >= td->td_nstrips && !TIFFGrowStrips(tif, 1, module))
return (-1); return (-1);
if (strip != tif->tif_curstrip) { if (strip != tif->tif_curstrip)
{
/* /*
* Changing strips -- flush any data present. * Changing strips -- flush any data present.
*/ */
@ -113,13 +120,14 @@ TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample)
if (strip >= td->td_stripsperimage && imagegrew) if (strip >= td->td_stripsperimage && imagegrew)
td->td_stripsperimage = td->td_stripsperimage =
TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip); TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip);
if (td->td_stripsperimage == 0) { if (td->td_stripsperimage == 0)
TIFFErrorExt(tif->tif_clientdata, module, "Zero strips per image"); {
TIFFErrorExtR(tif, module, "Zero strips per image");
return (-1); return (-1);
} }
tif->tif_row = tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
(strip % td->td_stripsperimage) * td->td_rowsperstrip; if ((tif->tif_flags & TIFF_CODERSETUP) == 0)
if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { {
if (!(*tif->tif_setupencode)(tif)) if (!(*tif->tif_setupencode)(tif))
return (-1); return (-1);
tif->tif_flags |= TIFF_CODERSETUP; tif->tif_flags |= TIFF_CODERSETUP;
@ -128,14 +136,8 @@ TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample)
tif->tif_rawcc = 0; tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata; tif->tif_rawcp = tif->tif_rawdata;
if( td->td_stripbytecount_p[strip] > 0 ) /* this informs TIFFAppendToStrip() we have changed strip */
{
/* if we are writing over existing tiles, zero length */
td->td_stripbytecount_p[strip] = 0;
/* this forces TIFFAppendToStrip() to do a seek */
tif->tif_curoff = 0; tif->tif_curoff = 0;
}
if (!(*tif->tif_preencode)(tif, sample)) if (!(*tif->tif_preencode)(tif, sample))
return (-1); return (-1);
@ -146,15 +148,17 @@ TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample)
* beginning of a strip (or that we can randomly * beginning of a strip (or that we can randomly
* access the data -- i.e. no encoding). * access the data -- i.e. no encoding).
*/ */
if (row != tif->tif_row) { if (row != tif->tif_row)
if (row < tif->tif_row) { {
if (row < tif->tif_row)
{
/* /*
* Moving backwards within the same strip: * Moving backwards within the same strip:
* backup to the start and then decode * backup to the start and then decode
* forward (below). * forward (below).
*/ */
tif->tif_row = (strip % td->td_stripsperimage) * tif->tif_row =
td->td_rowsperstrip; (strip % td->td_stripsperimage) * td->td_rowsperstrip;
tif->tif_rawcp = tif->tif_rawdata; tif->tif_rawcp = tif->tif_rawdata;
} }
/* /*
@ -166,38 +170,38 @@ TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample)
} }
/* swab if needed - note that source buffer will be altered */ /* swab if needed - note that source buffer will be altered */
tif->tif_postdecode( tif, (uint8*) buf, tif->tif_scanlinesize ); tif->tif_postdecode(tif, (uint8_t *)buf, tif->tif_scanlinesize);
status = (*tif->tif_encoderow)(tif, (uint8*) buf, status = (*tif->tif_encoderow)(tif, (uint8_t *)buf, tif->tif_scanlinesize,
tif->tif_scanlinesize, sample); sample);
/* we are now poised at the beginning of the next row */ /* we are now poised at the beginning of the next row */
tif->tif_row = row + 1; tif->tif_row = row + 1;
return (status); return (status);
} }
/* Make sure that at the first attempt of rewriting a tile/strip, we will have */ /* Make sure that at the first attempt of rewriting a tile/strip, we will have
*/
/* more bytes available in the output buffer than the previous byte count, */ /* more bytes available in the output buffer than the previous byte count, */
/* so that TIFFAppendToStrip() will detect the overflow when it is called the first */ /* so that TIFFAppendToStrip() will detect the overflow when it is called the
* first */
/* time if the new compressed tile is bigger than the older one. (GDAL #4771) */ /* time if the new compressed tile is bigger than the older one. (GDAL #4771) */
static int _TIFFReserveLargeEnoughWriteBuffer(TIFF* tif, uint32 strip_or_tile) static int _TIFFReserveLargeEnoughWriteBuffer(TIFF *tif, uint32_t strip_or_tile)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
if (td->td_stripbytecount_p[strip_or_tile] > 0) if (td->td_stripbytecount_p[strip_or_tile] > 0)
{ {
/* The +1 is to ensure at least one extra bytes */ /* The +1 is to ensure at least one extra bytes */
/* The +4 is because the LZW encoder flushes 4 bytes before the limit */ /* The +4 is because the LZW encoder flushes 4 bytes before the limit */
uint64 safe_buffer_size = (uint64)(td->td_stripbytecount_p[strip_or_tile] + 1 + 4); uint64_t safe_buffer_size =
(uint64_t)(td->td_stripbytecount_p[strip_or_tile] + 1 + 4);
if (tif->tif_rawdatasize <= (tmsize_t)safe_buffer_size) if (tif->tif_rawdatasize <= (tmsize_t)safe_buffer_size)
{ {
if( !(TIFFWriteBufferSetup(tif, NULL, if (!(TIFFWriteBufferSetup(
tif, NULL,
(tmsize_t)TIFFroundup_64(safe_buffer_size, 1024)))) (tmsize_t)TIFFroundup_64(safe_buffer_size, 1024))))
return 0; return 0;
} }
/* Force TIFFAppendToStrip() to consider placing data at end
of file. */
tif->tif_curoff = 0;
} }
return 1; return 1;
} }
@ -208,12 +212,12 @@ static int _TIFFReserveLargeEnoughWriteBuffer(TIFF* tif, uint32 strip_or_tile)
* *
* NB: Image length must be setup before writing. * NB: Image length must be setup before writing.
*/ */
tmsize_t tmsize_t TIFFWriteEncodedStrip(TIFF *tif, uint32_t strip, void *data,
TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc) tmsize_t cc)
{ {
static const char module[] = "TIFFWriteEncodedStrip"; static const char module[] = "TIFFWriteEncodedStrip";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint16 sample; uint16_t sample;
if (!WRITECHECKSTRIPS(tif, module)) if (!WRITECHECKSTRIPS(tif, module))
return ((tmsize_t)-1); return ((tmsize_t)-1);
@ -226,9 +230,12 @@ TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc)
* write (so that the strips array will be fully * write (so that the strips array will be fully
* allocated above). * allocated above).
*/ */
if (strip >= td->td_nstrips) { if (strip >= td->td_nstrips)
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { {
TIFFErrorExt(tif->tif_clientdata, module, if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
{
TIFFErrorExtR(
tif, module,
"Can not grow image by strips when using separate planes"); "Can not grow image by strips when using separate planes");
return ((tmsize_t)-1); return ((tmsize_t)-1);
} }
@ -246,22 +253,29 @@ TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc)
return ((tmsize_t)-1); return ((tmsize_t)-1);
tif->tif_flags |= TIFF_BUF4WRITE; tif->tif_flags |= TIFF_BUF4WRITE;
tif->tif_curstrip = strip; tif->tif_curstrip = strip;
if( !_TIFFReserveLargeEnoughWriteBuffer(tif, strip) ) { /* this informs TIFFAppendToStrip() we have changed or reset strip */
tif->tif_curoff = 0;
if (!_TIFFReserveLargeEnoughWriteBuffer(tif, strip))
{
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
} }
tif->tif_rawcc = 0; tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata; tif->tif_rawcp = tif->tif_rawdata;
if (td->td_stripsperimage == 0) { if (td->td_stripsperimage == 0)
TIFFErrorExt(tif->tif_clientdata, module, "Zero strips per image"); {
TIFFErrorExtR(tif, module, "Zero strips per image");
return ((tmsize_t)-1); return ((tmsize_t)-1);
} }
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip; tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { if ((tif->tif_flags & TIFF_CODERSETUP) == 0)
{
if (!(*tif->tif_setupencode)(tif)) if (!(*tif->tif_setupencode)(tif))
return ((tmsize_t)-1); return ((tmsize_t)-1);
tif->tif_flags |= TIFF_CODERSETUP; tif->tif_flags |= TIFF_CODERSETUP;
@ -273,26 +287,25 @@ TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc)
if (td->td_compression == COMPRESSION_NONE) if (td->td_compression == COMPRESSION_NONE)
{ {
/* swab if needed - note that source buffer will be altered */ /* swab if needed - note that source buffer will be altered */
tif->tif_postdecode( tif, (uint8*) data, cc ); tif->tif_postdecode(tif, (uint8_t *)data, cc);
if (!isFillOrder(tif, td->td_fillorder) && if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0) (tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits((uint8*) data, cc); TIFFReverseBits((uint8_t *)data, cc);
if (cc > 0 && if (cc > 0 && !TIFFAppendToStrip(tif, strip, (uint8_t *)data, cc))
!TIFFAppendToStrip(tif, strip, (uint8*) data, cc))
return ((tmsize_t)-1); return ((tmsize_t)-1);
return (cc); return (cc);
} }
sample = (uint16)(strip / td->td_stripsperimage); sample = (uint16_t)(strip / td->td_stripsperimage);
if (!(*tif->tif_preencode)(tif, sample)) if (!(*tif->tif_preencode)(tif, sample))
return ((tmsize_t)-1); return ((tmsize_t)-1);
/* swab if needed - note that source buffer will be altered */ /* swab if needed - note that source buffer will be altered */
tif->tif_postdecode( tif, (uint8*) data, cc ); tif->tif_postdecode(tif, (uint8_t *)data, cc);
if (!(*tif->tif_encodestrip)(tif, (uint8*) data, cc, sample)) if (!(*tif->tif_encodestrip)(tif, (uint8_t *)data, cc, sample))
return ((tmsize_t)-1); return ((tmsize_t)-1);
if (!(*tif->tif_postencode)(tif)) if (!(*tif->tif_postencode)(tif))
return ((tmsize_t)-1); return ((tmsize_t)-1);
@ -312,8 +325,7 @@ TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc)
* *
* NB: Image length must be setup before writing. * NB: Image length must be setup before writing.
*/ */
tmsize_t tmsize_t TIFFWriteRawStrip(TIFF *tif, uint32_t strip, void *data, tmsize_t cc)
TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc)
{ {
static const char module[] = "TIFFWriteRawStrip"; static const char module[] = "TIFFWriteRawStrip";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
@ -329,9 +341,12 @@ TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc)
* write (so that the strips array will be fully * write (so that the strips array will be fully
* allocated above). * allocated above).
*/ */
if (strip >= td->td_nstrips) { if (strip >= td->td_nstrips)
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) { {
TIFFErrorExt(tif->tif_clientdata, module, if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
{
TIFFErrorExtR(
tif, module,
"Can not grow image by strips when using separate planes"); "Can not grow image by strips when using separate planes");
return ((tmsize_t)-1); return ((tmsize_t)-1);
} }
@ -346,22 +361,31 @@ TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc)
if (!TIFFGrowStrips(tif, 1, module)) if (!TIFFGrowStrips(tif, 1, module))
return ((tmsize_t)-1); return ((tmsize_t)-1);
} }
if (tif->tif_curstrip != strip)
{
tif->tif_curstrip = strip; tif->tif_curstrip = strip;
if (td->td_stripsperimage == 0) {
TIFFErrorExt(tif->tif_clientdata, module,"Zero strips per image"); /* this informs TIFFAppendToStrip() we have changed or reset strip */
tif->tif_curoff = 0;
}
if (td->td_stripsperimage == 0)
{
TIFFErrorExtR(tif, module, "Zero strips per image");
return ((tmsize_t)-1); return ((tmsize_t)-1);
} }
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip; tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
return (TIFFAppendToStrip(tif, strip, (uint8*) data, cc) ? return (TIFFAppendToStrip(tif, strip, (uint8_t *)data, cc) ? cc
cc : (tmsize_t) -1); : (tmsize_t)-1);
} }
/* /*
* Write and compress a tile of data. The * Write and compress a tile of data. The
* tile is selected by the (x,y,z,s) coordinates. * tile is selected by the (x,y,z,s) coordinates.
*/ */
tmsize_t tmsize_t TIFFWriteTile(TIFF *tif, void *buf, uint32_t x, uint32_t y, uint32_t z,
TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s) uint16_t s)
{ {
if (!TIFFCheckTile(tif, x, y, z, s)) if (!TIFFCheckTile(tif, x, y, z, s))
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
@ -371,8 +395,8 @@ TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s)
* This is done because the tile size may not be defined until * This is done because the tile size may not be defined until
* after the output buffer is setup in TIFFWriteBufferSetup. * after the output buffer is setup in TIFFWriteBufferSetup.
*/ */
return (TIFFWriteEncodedTile(tif, return (TIFFWriteEncodedTile(tif, TIFFComputeTile(tif, x, y, z, s), buf,
TIFFComputeTile(tif, x, y, z, s), buf, (tmsize_t)(-1))); (tmsize_t)(-1)));
} }
/* /*
@ -387,19 +411,19 @@ TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s)
* interface does not support automatically growing * interface does not support automatically growing
* the image on each write (as TIFFWriteScanline does). * the image on each write (as TIFFWriteScanline does).
*/ */
tmsize_t tmsize_t TIFFWriteEncodedTile(TIFF *tif, uint32_t tile, void *data, tmsize_t cc)
TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc)
{ {
static const char module[] = "TIFFWriteEncodedTile"; static const char module[] = "TIFFWriteEncodedTile";
TIFFDirectory *td; TIFFDirectory *td;
uint16 sample; uint16_t sample;
uint32 howmany32; uint32_t howmany32;
if (!WRITECHECKTILES(tif, module)) if (!WRITECHECKTILES(tif, module))
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
td = &tif->tif_dir; td = &tif->tif_dir;
if (tile >= td->td_nstrips) { if (tile >= td->td_nstrips)
TIFFErrorExt(tif->tif_clientdata, module, "Tile %lu out of range, max %lu", {
TIFFErrorExtR(tif, module, "Tile %lu out of range, max %lu",
(unsigned long)tile, (unsigned long)td->td_nstrips); (unsigned long)tile, (unsigned long)td->td_nstrips);
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
} }
@ -412,9 +436,14 @@ TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc)
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
tif->tif_flags |= TIFF_BUF4WRITE; tif->tif_flags |= TIFF_BUF4WRITE;
tif->tif_curtile = tile; tif->tif_curtile = tile;
if( !_TIFFReserveLargeEnoughWriteBuffer(tif, tile) ) { /* this informs TIFFAppendToStrip() we have changed or reset tile */
tif->tif_curoff = 0;
if (!_TIFFReserveLargeEnoughWriteBuffer(tif, tile))
{
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
} }
@ -426,19 +455,22 @@ TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc)
* current row and column * current row and column
*/ */
howmany32 = TIFFhowmany_32(td->td_imagelength, td->td_tilelength); howmany32 = TIFFhowmany_32(td->td_imagelength, td->td_tilelength);
if (howmany32 == 0) { if (howmany32 == 0)
TIFFErrorExt(tif->tif_clientdata,module,"Zero tiles"); {
TIFFErrorExtR(tif, module, "Zero tiles");
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
} }
tif->tif_row = (tile % howmany32) * td->td_tilelength; tif->tif_row = (tile % howmany32) * td->td_tilelength;
howmany32 = TIFFhowmany_32(td->td_imagewidth, td->td_tilewidth); howmany32 = TIFFhowmany_32(td->td_imagewidth, td->td_tilewidth);
if (howmany32 == 0) { if (howmany32 == 0)
TIFFErrorExt(tif->tif_clientdata,module,"Zero tiles"); {
TIFFErrorExtR(tif, module, "Zero tiles");
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
} }
tif->tif_col = (tile % howmany32) * td->td_tilewidth; tif->tif_col = (tile % howmany32) * td->td_tilewidth;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0) { if ((tif->tif_flags & TIFF_CODERSETUP) == 0)
{
if (!(*tif->tif_setupencode)(tif)) if (!(*tif->tif_setupencode)(tif))
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
tif->tif_flags |= TIFF_CODERSETUP; tif->tif_flags |= TIFF_CODERSETUP;
@ -457,33 +489,32 @@ TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc)
if (td->td_compression == COMPRESSION_NONE) if (td->td_compression == COMPRESSION_NONE)
{ {
/* swab if needed - note that source buffer will be altered */ /* swab if needed - note that source buffer will be altered */
tif->tif_postdecode( tif, (uint8*) data, cc ); tif->tif_postdecode(tif, (uint8_t *)data, cc);
if (!isFillOrder(tif, td->td_fillorder) && if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0) (tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits((uint8*) data, cc); TIFFReverseBits((uint8_t *)data, cc);
if (cc > 0 && if (cc > 0 && !TIFFAppendToStrip(tif, tile, (uint8_t *)data, cc))
!TIFFAppendToStrip(tif, tile, (uint8*) data, cc))
return ((tmsize_t)-1); return ((tmsize_t)-1);
return (cc); return (cc);
} }
sample = (uint16)(tile/td->td_stripsperimage); sample = (uint16_t)(tile / td->td_stripsperimage);
if (!(*tif->tif_preencode)(tif, sample)) if (!(*tif->tif_preencode)(tif, sample))
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
/* swab if needed - note that source buffer will be altered */ /* swab if needed - note that source buffer will be altered */
tif->tif_postdecode( tif, (uint8*) data, cc ); tif->tif_postdecode(tif, (uint8_t *)data, cc);
if (!(*tif->tif_encodetile)(tif, (uint8*) data, cc, sample)) if (!(*tif->tif_encodetile)(tif, (uint8_t *)data, cc, sample))
return ((tmsize_t)-1); return ((tmsize_t)-1);
if (!(*tif->tif_postencode)(tif)) if (!(*tif->tif_postencode)(tif))
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
if (!isFillOrder(tif, td->td_fillorder) && if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0) (tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits((uint8*)tif->tif_rawdata, tif->tif_rawcc); TIFFReverseBits((uint8_t *)tif->tif_rawdata, tif->tif_rawcc);
if (tif->tif_rawcc > 0 && !TIFFAppendToStrip(tif, tile, if (tif->tif_rawcc > 0 &&
tif->tif_rawdata, tif->tif_rawcc)) !TIFFAppendToStrip(tif, tile, tif->tif_rawdata, tif->tif_rawcc))
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
tif->tif_rawcc = 0; tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata; tif->tif_rawcp = tif->tif_rawdata;
@ -499,63 +530,61 @@ TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc)
* interface does not support automatically growing * interface does not support automatically growing
* the image on each write (as TIFFWriteScanline does). * the image on each write (as TIFFWriteScanline does).
*/ */
tmsize_t tmsize_t TIFFWriteRawTile(TIFF *tif, uint32_t tile, void *data, tmsize_t cc)
TIFFWriteRawTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc)
{ {
static const char module[] = "TIFFWriteRawTile"; static const char module[] = "TIFFWriteRawTile";
if (!WRITECHECKTILES(tif, module)) if (!WRITECHECKTILES(tif, module))
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
if (tile >= tif->tif_dir.td_nstrips) { if (tile >= tif->tif_dir.td_nstrips)
TIFFErrorExt(tif->tif_clientdata, module, "Tile %lu out of range, max %lu", {
TIFFErrorExtR(tif, module, "Tile %lu out of range, max %lu",
(unsigned long)tile, (unsigned long)tile,
(unsigned long)tif->tif_dir.td_nstrips); (unsigned long)tif->tif_dir.td_nstrips);
return ((tmsize_t)(-1)); return ((tmsize_t)(-1));
} }
return (TIFFAppendToStrip(tif, tile, (uint8*) data, cc) ? return (TIFFAppendToStrip(tif, tile, (uint8_t *)data, cc) ? cc
cc : (tmsize_t)(-1)); : (tmsize_t)(-1));
} }
#define isUnspecified(tif, f) \ #define isUnspecified(tif, f) \
(TIFFFieldSet(tif, f) && (tif)->tif_dir.td_imagelength == 0) (TIFFFieldSet(tif, f) && (tif)->tif_dir.td_imagelength == 0)
int int TIFFSetupStrips(TIFF *tif)
TIFFSetupStrips(TIFF* tif)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
if (isTiled(tif)) if (isTiled(tif))
td->td_stripsperimage = td->td_stripsperimage = isUnspecified(tif, FIELD_TILEDIMENSIONS)
isUnspecified(tif, FIELD_TILEDIMENSIONS) ? ? td->td_samplesperpixel
td->td_samplesperpixel : TIFFNumberOfTiles(tif); : TIFFNumberOfTiles(tif);
else else
td->td_stripsperimage = td->td_stripsperimage = isUnspecified(tif, FIELD_ROWSPERSTRIP)
isUnspecified(tif, FIELD_ROWSPERSTRIP) ? ? td->td_samplesperpixel
td->td_samplesperpixel : TIFFNumberOfStrips(tif); : TIFFNumberOfStrips(tif);
td->td_nstrips = td->td_stripsperimage; td->td_nstrips = td->td_stripsperimage;
/* TIFFWriteDirectoryTagData has a limitation to 0x80000000U bytes */ /* TIFFWriteDirectoryTagData has a limitation to 0x80000000U bytes */
if( td->td_nstrips >= 0x80000000U / ((tif->tif_flags&TIFF_BIGTIFF)?0x8U:0x4U) ) if (td->td_nstrips >=
0x80000000U / ((tif->tif_flags & TIFF_BIGTIFF) ? 0x8U : 0x4U))
{ {
TIFFErrorExt(tif->tif_clientdata, "TIFFSetupStrips", TIFFErrorExtR(tif, "TIFFSetupStrips",
"Too large Strip/Tile Offsets/ByteCounts arrays"); "Too large Strip/Tile Offsets/ByteCounts arrays");
return 0; return 0;
} }
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
td->td_stripsperimage /= td->td_samplesperpixel; td->td_stripsperimage /= td->td_samplesperpixel;
td->td_stripoffset_p = (uint64 *) td->td_stripoffset_p = (uint64_t *)_TIFFCheckMalloc(
_TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint64), tif, td->td_nstrips, sizeof(uint64_t), "for \"StripOffsets\" array");
"for \"StripOffsets\" array"); td->td_stripbytecount_p = (uint64_t *)_TIFFCheckMalloc(
td->td_stripbytecount_p = (uint64 *) tif, td->td_nstrips, sizeof(uint64_t), "for \"StripByteCounts\" array");
_TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint64),
"for \"StripByteCounts\" array");
if (td->td_stripoffset_p == NULL || td->td_stripbytecount_p == NULL) if (td->td_stripoffset_p == NULL || td->td_stripbytecount_p == NULL)
return (0); return (0);
/* /*
* Place data at the end-of-file * Place data at the end-of-file
* (by setting offsets to zero). * (by setting offsets to zero).
*/ */
_TIFFmemset(td->td_stripoffset_p, 0, td->td_nstrips*sizeof (uint64)); _TIFFmemset(td->td_stripoffset_p, 0, td->td_nstrips * sizeof(uint64_t));
_TIFFmemset(td->td_stripbytecount_p, 0, td->td_nstrips*sizeof (uint64)); _TIFFmemset(td->td_stripbytecount_p, 0, td->td_nstrips * sizeof(uint64_t));
TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS); TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS);
TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS); TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
return (1); return (1);
@ -568,17 +597,18 @@ TIFFSetupStrips(TIFF* tif)
* we also "freeze" the state of the directory so * we also "freeze" the state of the directory so
* that important information is not changed. * that important information is not changed.
*/ */
int int TIFFWriteCheck(TIFF *tif, int tiles, const char *module)
TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
{ {
if (tif->tif_mode == O_RDONLY) { if (tif->tif_mode == O_RDONLY)
TIFFErrorExt(tif->tif_clientdata, module, "File not open for writing"); {
TIFFErrorExtR(tif, module, "File not open for writing");
return (0); return (0);
} }
if (tiles ^ isTiled(tif)) { if (tiles ^ isTiled(tif))
TIFFErrorExt(tif->tif_clientdata, module, tiles ? {
"Can not write tiles to a striped image" : TIFFErrorExtR(tif, module,
"Can not write scanlines to a tiled image"); tiles ? "Can not write tiles to a striped image"
: "Can not write scanlines to a tiled image");
return (0); return (0);
} }
@ -594,30 +624,16 @@ TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
* TIFF_BEENWRITING is set, TIFFSetField will only allow * TIFF_BEENWRITING is set, TIFFSetField will only allow
* the image's length to be changed). * the image's length to be changed).
*/ */
if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) { if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS))
TIFFErrorExt(tif->tif_clientdata, module, {
TIFFErrorExtR(tif, module,
"Must set \"ImageWidth\" before writing data"); "Must set \"ImageWidth\" before writing data");
return (0); return (0);
} }
if (tif->tif_dir.td_samplesperpixel == 1) { if (tif->tif_dir.td_stripoffset_p == NULL && !TIFFSetupStrips(tif))
/* {
* Planarconfiguration is irrelevant in case of single band
* images and need not be included. We will set it anyway,
* because this field is used in other parts of library even
* in the single band case.
*/
if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG))
tif->tif_dir.td_planarconfig = PLANARCONFIG_CONTIG;
} else {
if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) {
TIFFErrorExt(tif->tif_clientdata, module,
"Must set \"PlanarConfiguration\" before writing data");
return (0);
}
}
if (tif->tif_dir.td_stripoffset_p == NULL && !TIFFSetupStrips(tif)) {
tif->tif_dir.td_nstrips = 0; tif->tif_dir.td_nstrips = 0;
TIFFErrorExt(tif->tif_clientdata, module, "No space for %s arrays", TIFFErrorExtR(tif, module, "No space for %s arrays",
isTiled(tif) ? "tile" : "strip"); isTiled(tif) ? "tile" : "strip");
return (0); return (0);
} }
@ -653,21 +669,22 @@ TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
/* /*
* Setup the raw data buffer used for encoding. * Setup the raw data buffer used for encoding.
*/ */
int int TIFFWriteBufferSetup(TIFF *tif, void *bp, tmsize_t size)
TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size)
{ {
static const char module[] = "TIFFWriteBufferSetup"; static const char module[] = "TIFFWriteBufferSetup";
if (tif->tif_rawdata) { if (tif->tif_rawdata)
if (tif->tif_flags & TIFF_MYBUFFER) { {
_TIFFfree(tif->tif_rawdata); if (tif->tif_flags & TIFF_MYBUFFER)
{
_TIFFfreeExt(tif, tif->tif_rawdata);
tif->tif_flags &= ~TIFF_MYBUFFER; tif->tif_flags &= ~TIFF_MYBUFFER;
} }
tif->tif_rawdata = NULL; tif->tif_rawdata = NULL;
} }
if (size == (tmsize_t)(-1)) { if (size == (tmsize_t)(-1))
size = (isTiled(tif) ? {
tif->tif_tilesize : TIFFStripSize(tif)); size = (isTiled(tif) ? tif->tif_tilesize : TIFFStripSize(tif));
/* Adds 10% margin for cases where compression would expand a bit */ /* Adds 10% margin for cases where compression would expand a bit */
if (size < TIFF_TMSIZE_T_MAX - size / 10) if (size < TIFF_TMSIZE_T_MAX - size / 10)
@ -679,16 +696,19 @@ TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size)
size = 8 * 1024; size = 8 * 1024;
bp = NULL; /* NB: force malloc */ bp = NULL; /* NB: force malloc */
} }
if (bp == NULL) { if (bp == NULL)
bp = _TIFFmalloc(size); {
if (bp == NULL) { bp = _TIFFmallocExt(tif, size);
TIFFErrorExt(tif->tif_clientdata, module, "No space for output buffer"); if (bp == NULL)
{
TIFFErrorExtR(tif, module, "No space for output buffer");
return (0); return (0);
} }
tif->tif_flags |= TIFF_MYBUFFER; tif->tif_flags |= TIFF_MYBUFFER;
} else }
else
tif->tif_flags &= ~TIFF_MYBUFFER; tif->tif_flags &= ~TIFF_MYBUFFER;
tif->tif_rawdata = (uint8*) bp; tif->tif_rawdata = (uint8_t *)bp;
tif->tif_rawdatasize = size; tif->tif_rawdatasize = size;
tif->tif_rawcc = 0; tif->tif_rawcc = 0;
tif->tif_rawcp = tif->tif_rawdata; tif->tif_rawcp = tif->tif_rawdata;
@ -699,33 +719,34 @@ TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size)
/* /*
* Grow the strip data structures by delta strips. * Grow the strip data structures by delta strips.
*/ */
static int static int TIFFGrowStrips(TIFF *tif, uint32_t delta, const char *module)
TIFFGrowStrips(TIFF* tif, uint32 delta, const char* module)
{ {
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint64* new_stripoffset; uint64_t *new_stripoffset;
uint64* new_stripbytecount; uint64_t *new_stripbytecount;
assert(td->td_planarconfig == PLANARCONFIG_CONTIG); assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
new_stripoffset = (uint64*)_TIFFrealloc(td->td_stripoffset_p, new_stripoffset = (uint64_t *)_TIFFreallocExt(
(td->td_nstrips + delta) * sizeof (uint64)); tif, td->td_stripoffset_p, (td->td_nstrips + delta) * sizeof(uint64_t));
new_stripbytecount = (uint64*)_TIFFrealloc(td->td_stripbytecount_p, new_stripbytecount = (uint64_t *)_TIFFreallocExt(
(td->td_nstrips + delta) * sizeof (uint64)); tif, td->td_stripbytecount_p,
if (new_stripoffset == NULL || new_stripbytecount == NULL) { (td->td_nstrips + delta) * sizeof(uint64_t));
if (new_stripoffset == NULL || new_stripbytecount == NULL)
{
if (new_stripoffset) if (new_stripoffset)
_TIFFfree(new_stripoffset); _TIFFfreeExt(tif, new_stripoffset);
if (new_stripbytecount) if (new_stripbytecount)
_TIFFfree(new_stripbytecount); _TIFFfreeExt(tif, new_stripbytecount);
td->td_nstrips = 0; td->td_nstrips = 0;
TIFFErrorExt(tif->tif_clientdata, module, "No space to expand strip arrays"); TIFFErrorExtR(tif, module, "No space to expand strip arrays");
return (0); return (0);
} }
td->td_stripoffset_p = new_stripoffset; td->td_stripoffset_p = new_stripoffset;
td->td_stripbytecount_p = new_stripbytecount; td->td_stripbytecount_p = new_stripbytecount;
_TIFFmemset(td->td_stripoffset_p + td->td_nstrips, _TIFFmemset(td->td_stripoffset_p + td->td_nstrips, 0,
0, delta*sizeof (uint64)); delta * sizeof(uint64_t));
_TIFFmemset(td->td_stripbytecount_p + td->td_nstrips, _TIFFmemset(td->td_stripbytecount_p + td->td_nstrips, 0,
0, delta*sizeof (uint64)); delta * sizeof(uint64_t));
td->td_nstrips += delta; td->td_nstrips += delta;
tif->tif_flags |= TIFF_DIRTYDIRECT; tif->tif_flags |= TIFF_DIRTYDIRECT;
@ -735,20 +756,24 @@ TIFFGrowStrips(TIFF* tif, uint32 delta, const char* module)
/* /*
* Append the data to the specified strip. * Append the data to the specified strip.
*/ */
static int static int TIFFAppendToStrip(TIFF *tif, uint32_t strip, uint8_t *data,
TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc) tmsize_t cc)
{ {
static const char module[] = "TIFFAppendToStrip"; static const char module[] = "TIFFAppendToStrip";
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint64 m; uint64_t m;
int64 old_byte_count = -1; int64_t old_byte_count = -1;
if (td->td_stripoffset_p[strip] == 0 || tif->tif_curoff == 0) { if (tif->tif_curoff == 0)
tif->tif_lastvalidoff = 0;
if (td->td_stripoffset_p[strip] == 0 || tif->tif_curoff == 0)
{
assert(td->td_nstrips > 0); assert(td->td_nstrips > 0);
if( td->td_stripbytecount_p[strip] != 0 if (td->td_stripbytecount_p[strip] != 0 &&
&& td->td_stripoffset_p[strip] != 0 td->td_stripoffset_p[strip] != 0 &&
&& td->td_stripbytecount_p[strip] >= (uint64) cc ) td->td_stripbytecount_p[strip] >= (uint64_t)cc)
{ {
/* /*
* There is already tile data on disk, and the new tile * There is already tile data on disk, and the new tile
@ -757,12 +782,15 @@ TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc)
* more data to append to this strip before we are done * more data to append to this strip before we are done
* depending on how we are getting called. * depending on how we are getting called.
*/ */
if (!SeekOK(tif, td->td_stripoffset_p[strip])) { if (!SeekOK(tif, td->td_stripoffset_p[strip]))
TIFFErrorExt(tif->tif_clientdata, module, {
"Seek error at scanline %lu", TIFFErrorExtR(tif, module, "Seek error at scanline %lu",
(unsigned long)tif->tif_row); (unsigned long)tif->tif_row);
return (0); return (0);
} }
tif->tif_lastvalidoff =
td->td_stripoffset_p[strip] + td->td_stripbytecount_p[strip];
} }
else else
{ {
@ -785,21 +813,106 @@ TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc)
m = tif->tif_curoff + cc; m = tif->tif_curoff + cc;
if (!(tif->tif_flags & TIFF_BIGTIFF)) if (!(tif->tif_flags & TIFF_BIGTIFF))
m = (uint32)m; m = (uint32_t)m;
if ((m<tif->tif_curoff)||(m<(uint64)cc)) if ((m < tif->tif_curoff) || (m < (uint64_t)cc))
{ {
TIFFErrorExt(tif->tif_clientdata, module, "Maximum TIFF file size exceeded"); TIFFErrorExtR(tif, module, "Maximum TIFF file size exceeded");
return (0); return (0);
} }
if (!WriteOK(tif, data, cc)) {
TIFFErrorExt(tif->tif_clientdata, module, "Write error at scanline %lu", if (tif->tif_lastvalidoff != 0 && m > tif->tif_lastvalidoff &&
td->td_stripbytecount_p[strip] > 0)
{
/* Ouch: we have detected that we are rewriting in place a strip/tile */
/* with several calls to TIFFAppendToStrip(). The first call was with */
/* a size smaller than the previous size of the strip/tile, so we */
/* opted to rewrite in place, but a following call causes us to go */
/* outsize of the strip/tile area, so we have to finally go for a */
/* append-at-end-of-file strategy, and start by moving what we already
*/
/* wrote. */
tmsize_t tempSize;
void *temp;
uint64_t offsetRead;
uint64_t offsetWrite;
uint64_t toCopy = td->td_stripbytecount_p[strip];
if (toCopy < 1024 * 1024)
tempSize = (tmsize_t)toCopy;
else
tempSize = 1024 * 1024;
offsetRead = td->td_stripoffset_p[strip];
offsetWrite = TIFFSeekFile(tif, 0, SEEK_END);
m = offsetWrite + toCopy + cc;
if (!(tif->tif_flags & TIFF_BIGTIFF) && m != (uint32_t)m)
{
TIFFErrorExtR(tif, module, "Maximum TIFF file size exceeded");
return (0);
}
temp = _TIFFmallocExt(tif, tempSize);
if (temp == NULL)
{
TIFFErrorExtR(tif, module, "No space for output buffer");
return (0);
}
tif->tif_flags |= TIFF_DIRTYSTRIP;
td->td_stripoffset_p[strip] = offsetWrite;
td->td_stripbytecount_p[strip] = 0;
/* Move data written by previous calls to us at end of file */
while (toCopy > 0)
{
if (!SeekOK(tif, offsetRead))
{
TIFFErrorExtR(tif, module, "Seek error");
_TIFFfreeExt(tif, temp);
return (0);
}
if (!ReadOK(tif, temp, tempSize))
{
TIFFErrorExtR(tif, module, "Cannot read");
_TIFFfreeExt(tif, temp);
return (0);
}
if (!SeekOK(tif, offsetWrite))
{
TIFFErrorExtR(tif, module, "Seek error");
_TIFFfreeExt(tif, temp);
return (0);
}
if (!WriteOK(tif, temp, tempSize))
{
TIFFErrorExtR(tif, module, "Cannot write");
_TIFFfreeExt(tif, temp);
return (0);
}
offsetRead += tempSize;
offsetWrite += tempSize;
td->td_stripbytecount_p[strip] += tempSize;
toCopy -= tempSize;
}
_TIFFfreeExt(tif, temp);
/* Append the data of this call */
offsetWrite += cc;
m = offsetWrite;
}
if (!WriteOK(tif, data, cc))
{
TIFFErrorExtR(tif, module, "Write error at scanline %lu",
(unsigned long)tif->tif_row); (unsigned long)tif->tif_row);
return (0); return (0);
} }
tif->tif_curoff = m; tif->tif_curoff = m;
td->td_stripbytecount_p[strip] += cc; td->td_stripbytecount_p[strip] += cc;
if( (int64) td->td_stripbytecount_p[strip] != old_byte_count ) if ((int64_t)td->td_stripbytecount_p[strip] != old_byte_count)
tif->tif_flags |= TIFF_DIRTYSTRIP; tif->tif_flags |= TIFF_DIRTYSTRIP;
return (1); return (1);
@ -810,16 +923,15 @@ TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc)
* called by ``encodestrip routines'' w/o concern * called by ``encodestrip routines'' w/o concern
* for infinite recursion. * for infinite recursion.
*/ */
int int TIFFFlushData1(TIFF *tif)
TIFFFlushData1(TIFF* tif) {
if (tif->tif_rawcc > 0 && tif->tif_flags & TIFF_BUF4WRITE)
{ {
if (tif->tif_rawcc > 0 && tif->tif_flags & TIFF_BUF4WRITE ) {
if (!isFillOrder(tif, tif->tif_dir.td_fillorder) && if (!isFillOrder(tif, tif->tif_dir.td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0) (tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits((uint8*)tif->tif_rawdata, TIFFReverseBits((uint8_t *)tif->tif_rawdata, tif->tif_rawcc);
tif->tif_rawcc); if (!TIFFAppendToStrip(
if (!TIFFAppendToStrip(tif, tif, isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip,
isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip,
tif->tif_rawdata, tif->tif_rawcc)) tif->tif_rawdata, tif->tif_rawcc))
{ {
/* We update those variables even in case of error since there's */ /* We update those variables even in case of error since there's */
@ -841,17 +953,8 @@ TIFFFlushData1(TIFF* tif)
* (very carefully), or to 0 so that the next write gets * (very carefully), or to 0 so that the next write gets
* appended to the end of the file. * appended to the end of the file.
*/ */
void void TIFFSetWriteOffset(TIFF *tif, toff_t off)
TIFFSetWriteOffset(TIFF* tif, toff_t off)
{ {
tif->tif_curoff = off; tif->tif_curoff = off;
tif->tif_lastvalidoff = 0;
} }
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

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

@ -63,14 +63,16 @@
* State block for each open TIFF * State block for each open TIFF
* file using ZIP compression/decompression. * file using ZIP compression/decompression.
*/ */
typedef struct { typedef struct
{
TIFFPredictorState predict; TIFFPredictorState predict;
z_stream stream; z_stream stream;
int zipquality; /* compression level */ int zipquality; /* compression level */
int state; /* state flags */ int state; /* state flags */
int subcodec; /* DEFLATE_SUBCODEC_ZLIB or DEFLATE_SUBCODEC_LIBDEFLATE */ int subcodec; /* DEFLATE_SUBCODEC_ZLIB or DEFLATE_SUBCODEC_LIBDEFLATE */
#if LIBDEFLATE_SUPPORT #if LIBDEFLATE_SUPPORT
int libdeflate_state; /* -1 = until first time ZIPEncode() / ZIPDecode() is called, 0 = use zlib, 1 = use libdeflate */ int libdeflate_state; /* -1 = until first time ZIPEncode() / ZIPDecode() is
called, 0 = use zlib, 1 = use libdeflate */
struct libdeflate_decompressor *libdeflate_dec; struct libdeflate_decompressor *libdeflate_dec;
struct libdeflate_compressor *libdeflate_enc; struct libdeflate_compressor *libdeflate_enc;
#endif #endif
@ -85,18 +87,16 @@ typedef struct {
#define DecoderState(tif) ZState(tif) #define DecoderState(tif) ZState(tif)
#define EncoderState(tif) ZState(tif) #define EncoderState(tif) ZState(tif)
static int ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s); static int ZIPEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s);
static int ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s); static int ZIPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s);
static int static int ZIPFixupTags(TIFF *tif)
ZIPFixupTags(TIFF* tif)
{ {
(void)tif; (void)tif;
return (1); return (1);
} }
static int static int ZIPSetupDecode(TIFF *tif)
ZIPSetupDecode(TIFF* tif)
{ {
static const char module[] = "ZIPSetupDecode"; static const char module[] = "ZIPSetupDecode";
ZIPState *sp = DecoderState(tif); ZIPState *sp = DecoderState(tif);
@ -104,7 +104,8 @@ ZIPSetupDecode(TIFF* 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 & ZSTATE_INIT_ENCODE) { if (sp->state & ZSTATE_INIT_ENCODE)
{
deflateEnd(&sp->stream); deflateEnd(&sp->stream);
sp->state = 0; sp->state = 0;
} }
@ -113,10 +114,13 @@ ZIPSetupDecode(TIFF* tif)
/* PredictorSetupDecode() if this function succeeds but */ /* PredictorSetupDecode() if this function succeeds but */
/* PredictorSetup() fails */ /* PredictorSetup() fails */
if ((sp->state & ZSTATE_INIT_DECODE) == 0 && if ((sp->state & ZSTATE_INIT_DECODE) == 0 &&
inflateInit(&sp->stream) != Z_OK) { inflateInit(&sp->stream) != Z_OK)
TIFFErrorExt(tif->tif_clientdata, module, "%s", SAFE_MSG(sp)); {
TIFFErrorExtR(tif, module, "%s", SAFE_MSG(sp));
return (0); return (0);
} else { }
else
{
sp->state |= ZSTATE_INIT_DECODE; sp->state |= ZSTATE_INIT_DECODE;
return (1); return (1);
} }
@ -125,8 +129,7 @@ ZIPSetupDecode(TIFF* tif)
/* /*
* Setup state for decoding a strip. * Setup state for decoding a strip.
*/ */
static int static int ZIPPreDecode(TIFF *tif, uint16_t s)
ZIPPreDecode(TIFF* tif, uint16 s)
{ {
ZIPState *sp = DecoderState(tif); ZIPState *sp = DecoderState(tif);
@ -144,12 +147,13 @@ ZIPPreDecode(TIFF* tif, uint16 s)
we need to simplify this code to reflect a ZLib that is likely updated we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond to deal with 8byte memory sizes, though this code will respond
appropriately even before we simplify it */ appropriately even before we simplify it */
sp->stream.avail_in = (uint64)tif->tif_rawcc < 0xFFFFFFFFU ? (uInt) tif->tif_rawcc : 0xFFFFFFFFU; sp->stream.avail_in = (uint64_t)tif->tif_rawcc < 0xFFFFFFFFU
? (uInt)tif->tif_rawcc
: 0xFFFFFFFFU;
return (inflateReset(&sp->stream) == Z_OK); return (inflateReset(&sp->stream) == Z_OK);
} }
static int static int ZIPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{ {
static const char module[] = "ZIPDecode"; static const char module[] = "ZIPDecode";
ZIPState *sp = DecoderState(tif); ZIPState *sp = DecoderState(tif);
@ -164,7 +168,8 @@ ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
/* If we have libdeflate support and we are asked to read a whole */ /* If we have libdeflate support and we are asked to read a whole */
/* strip/tile, then go for using it */ /* strip/tile, then go for using it */
do { do
{
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
if (sp->libdeflate_state == 0) if (sp->libdeflate_state == 0)
@ -173,21 +178,24 @@ ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
break; break;
/* Check if we are in the situation where we can use libdeflate */ /* Check if we are in the situation where we can use libdeflate */
if (isTiled(tif)) { if (isTiled(tif))
if( TIFFTileSize64(tif) != (uint64)occ ) {
if (TIFFTileSize64(tif) != (uint64_t)occ)
break; break;
} else { }
uint32 strip_height = td->td_imagelength - tif->tif_row; else
{
uint32_t strip_height = td->td_imagelength - tif->tif_row;
if (strip_height > td->td_rowsperstrip) if (strip_height > td->td_rowsperstrip)
strip_height = td->td_rowsperstrip; strip_height = td->td_rowsperstrip;
if( TIFFVStripSize64(tif, strip_height) != (uint64)occ ) if (TIFFVStripSize64(tif, strip_height) != (uint64_t)occ)
break; break;
} }
/* Check for overflow */ /* Check for overflow */
if( (size_t)tif->tif_rawcc != (uint64)tif->tif_rawcc ) if ((size_t)tif->tif_rawcc != (uint64_t)tif->tif_rawcc)
break; break;
if( (size_t)occ != (uint64)occ ) if ((size_t)occ != (uint64_t)occ)
break; break;
/* Go for decompression using libdeflate */ /* Go for decompression using libdeflate */
@ -204,21 +212,22 @@ ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
sp->libdeflate_state = 1; sp->libdeflate_state = 1;
res = libdeflate_zlib_decompress( res = libdeflate_zlib_decompress(sp->libdeflate_dec, tif->tif_rawcp,
sp->libdeflate_dec, tif->tif_rawcp, (size_t)tif->tif_rawcc, op, (size_t)occ, NULL); (size_t)tif->tif_rawcc, op,
(size_t)occ, NULL);
tif->tif_rawcp += tif->tif_rawcc; tif->tif_rawcp += tif->tif_rawcc;
tif->tif_rawcc = 0; tif->tif_rawcc = 0;
/* We accept LIBDEFLATE_INSUFFICIENT_SPACE has a return */ /* We accept LIBDEFLATE_INSUFFICIENT_SPACE has a return */
/* There are odd files in the wild where the last strip, when */ /* There are odd files in the wild where the last strip, when */
/* it is smaller in height than td_rowsperstrip, actually contains */ /* it is smaller in height than td_rowsperstrip, actually contains
*/
/* data for td_rowsperstrip lines. Just ignore that silently. */ /* data for td_rowsperstrip lines. Just ignore that silently. */
if (res != LIBDEFLATE_SUCCESS && if (res != LIBDEFLATE_SUCCESS &&
res != LIBDEFLATE_INSUFFICIENT_SPACE) res != LIBDEFLATE_INSUFFICIENT_SPACE)
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "Decoding error at scanline %lu",
"Decoding error at scanline %lu",
(unsigned long)tif->tif_row); (unsigned long)tif->tif_row);
return 0; return 0;
} }
@ -236,33 +245,40 @@ ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
we need to simplify this code to reflect a ZLib that is likely updated we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond to deal with 8byte memory sizes, though this code will respond
appropriately even before we simplify it */ appropriately even before we simplify it */
do { do
{
int state; int state;
uInt avail_in_before = (uint64)tif->tif_rawcc <= 0xFFFFFFFFU ? (uInt)tif->tif_rawcc : 0xFFFFFFFFU; uInt avail_in_before = (uint64_t)tif->tif_rawcc <= 0xFFFFFFFFU
uInt avail_out_before = (uint64)occ < 0xFFFFFFFFU ? (uInt) occ : 0xFFFFFFFFU; ? (uInt)tif->tif_rawcc
: 0xFFFFFFFFU;
uInt avail_out_before =
(uint64_t)occ < 0xFFFFFFFFU ? (uInt)occ : 0xFFFFFFFFU;
sp->stream.avail_in = avail_in_before; sp->stream.avail_in = avail_in_before;
sp->stream.avail_out = avail_out_before; sp->stream.avail_out = avail_out_before;
/* coverity[overrun-buffer-arg] */
state = inflate(&sp->stream, Z_PARTIAL_FLUSH); state = inflate(&sp->stream, Z_PARTIAL_FLUSH);
tif->tif_rawcc -= (avail_in_before - sp->stream.avail_in); tif->tif_rawcc -= (avail_in_before - sp->stream.avail_in);
occ -= (avail_out_before - sp->stream.avail_out); occ -= (avail_out_before - sp->stream.avail_out);
if (state == Z_STREAM_END) if (state == Z_STREAM_END)
break; break;
if (state == Z_DATA_ERROR) { if (state == Z_DATA_ERROR)
TIFFErrorExt(tif->tif_clientdata, module, {
"Decoding error at scanline %lu, %s", TIFFErrorExtR(tif, module, "Decoding error at scanline %lu, %s",
(unsigned long)tif->tif_row, SAFE_MSG(sp)); (unsigned long)tif->tif_row, SAFE_MSG(sp));
return (0); return (0);
} }
if (state != Z_OK) { if (state != Z_OK)
TIFFErrorExt(tif->tif_clientdata, module, {
"ZLib error: %s", SAFE_MSG(sp)); TIFFErrorExtR(tif, module, "ZLib error: %s", SAFE_MSG(sp));
return (0); return (0);
} }
} while (occ > 0); } while (occ > 0);
if (occ != 0) { if (occ != 0)
TIFFErrorExt(tif->tif_clientdata, module, {
"Not enough data at scanline %lu (short " TIFF_UINT64_FORMAT " bytes)", TIFFErrorExtR(tif, module,
(unsigned long) tif->tif_row, (TIFF_UINT64_T) occ); "Not enough data at scanline %lu (short %" PRIu64
" bytes)",
(unsigned long)tif->tif_row, (uint64_t)occ);
return (0); return (0);
} }
@ -271,15 +287,15 @@ ZIPDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
return (1); return (1);
} }
static int static int ZIPSetupEncode(TIFF *tif)
ZIPSetupEncode(TIFF* tif)
{ {
static const char module[] = "ZIPSetupEncode"; static const char module[] = "ZIPSetupEncode";
ZIPState *sp = EncoderState(tif); ZIPState *sp = EncoderState(tif);
int cappedQuality; int cappedQuality;
assert(sp != NULL); assert(sp != NULL);
if (sp->state & ZSTATE_INIT_DECODE) { if (sp->state & ZSTATE_INIT_DECODE)
{
inflateEnd(&sp->stream); inflateEnd(&sp->stream);
sp->state = 0; sp->state = 0;
} }
@ -288,10 +304,13 @@ ZIPSetupEncode(TIFF* tif)
if (cappedQuality > Z_BEST_COMPRESSION) if (cappedQuality > Z_BEST_COMPRESSION)
cappedQuality = Z_BEST_COMPRESSION; cappedQuality = Z_BEST_COMPRESSION;
if (deflateInit(&sp->stream, cappedQuality) != Z_OK) { if (deflateInit(&sp->stream, cappedQuality) != Z_OK)
TIFFErrorExt(tif->tif_clientdata, module, "%s", SAFE_MSG(sp)); {
TIFFErrorExtR(tif, module, "%s", SAFE_MSG(sp));
return (0); return (0);
} else { }
else
{
sp->state |= ZSTATE_INIT_ENCODE; sp->state |= ZSTATE_INIT_ENCODE;
return (1); return (1);
} }
@ -300,8 +319,7 @@ ZIPSetupEncode(TIFF* tif)
/* /*
* Reset encoding state at the start of a strip. * Reset encoding state at the start of a strip.
*/ */
static int static int ZIPPreEncode(TIFF *tif, uint16_t s)
ZIPPreEncode(TIFF* tif, uint16 s)
{ {
ZIPState *sp = EncoderState(tif); ZIPState *sp = EncoderState(tif);
@ -318,15 +336,16 @@ ZIPPreEncode(TIFF* tif, uint16 s)
we need to simplify this code to reflect a ZLib that is likely updated we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond to deal with 8byte memory sizes, though this code will respond
appropriately even before we simplify it */ appropriately even before we simplify it */
sp->stream.avail_out = (uint64)tif->tif_rawdatasize <= 0xFFFFFFFFU ? (uInt)tif->tif_rawdatasize : 0xFFFFFFFFU; sp->stream.avail_out = (uint64_t)tif->tif_rawdatasize <= 0xFFFFFFFFU
? (uInt)tif->tif_rawdatasize
: 0xFFFFFFFFU;
return (deflateReset(&sp->stream) == Z_OK); return (deflateReset(&sp->stream) == Z_OK);
} }
/* /*
* Encode a chunk of pixels. * Encode a chunk of pixels.
*/ */
static int static int ZIPEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
{ {
static const char module[] = "ZIPEncode"; static const char module[] = "ZIPEncode";
ZIPState *sp = EncoderState(tif); ZIPState *sp = EncoderState(tif);
@ -342,7 +361,8 @@ ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
/* If we have libdeflate support and we are asked to write a whole */ /* If we have libdeflate support and we are asked to write a whole */
/* strip/tile, then go for using it */ /* strip/tile, then go for using it */
do { do
{
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
if (sp->libdeflate_state == 0) if (sp->libdeflate_state == 0)
@ -355,21 +375,24 @@ ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
break; break;
/* Check if we are in the situation where we can use libdeflate */ /* Check if we are in the situation where we can use libdeflate */
if (isTiled(tif)) { if (isTiled(tif))
if( TIFFTileSize64(tif) != (uint64)cc ) {
if (TIFFTileSize64(tif) != (uint64_t)cc)
break; break;
} else { }
uint32 strip_height = td->td_imagelength - tif->tif_row; else
{
uint32_t strip_height = td->td_imagelength - tif->tif_row;
if (strip_height > td->td_rowsperstrip) if (strip_height > td->td_rowsperstrip)
strip_height = td->td_rowsperstrip; strip_height = td->td_rowsperstrip;
if( TIFFVStripSize64(tif, strip_height) != (uint64)cc ) if (TIFFVStripSize64(tif, strip_height) != (uint64_t)cc)
break; break;
} }
/* Check for overflow */ /* Check for overflow */
if( (size_t)tif->tif_rawdatasize != (uint64)tif->tif_rawdatasize ) if ((size_t)tif->tif_rawdatasize != (uint64_t)tif->tif_rawdatasize)
break; break;
if( (size_t)cc != (uint64)cc ) if ((size_t)cc != (uint64_t)cc)
break; break;
/* Go for compression using libdeflate */ /* Go for compression using libdeflate */
@ -380,20 +403,22 @@ ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
/* To get results as good as zlib, we asked for an extra */ /* To get results as good as zlib, we asked for an extra */
/* level of compression */ /* level of compression */
sp->libdeflate_enc = libdeflate_alloc_compressor( sp->libdeflate_enc = libdeflate_alloc_compressor(
sp->zipquality == Z_DEFAULT_COMPRESSION ? 7 : sp->zipquality == Z_DEFAULT_COMPRESSION ? 7
sp->zipquality >= 6 && sp->zipquality <= 9 ? sp->zipquality + 1 : : sp->zipquality >= 6 && sp->zipquality <= 9
sp->zipquality); ? sp->zipquality + 1
: sp->zipquality);
if (sp->libdeflate_enc == NULL) if (sp->libdeflate_enc == NULL)
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "Cannot allocate compressor");
"Cannot allocate compressor");
break; break;
} }
} }
/* Make sure the output buffer is large enough for the worse case. */ /* Make sure the output buffer is large enough for the worse case.
*/
/* In TIFFWriteBufferSetup(), when libtiff allocates the buffer */ /* In TIFFWriteBufferSetup(), when libtiff allocates the buffer */
/* we've taken a 10% margin over the uncompressed size, which should */ /* we've taken a 10% margin over the uncompressed size, which should
*/
/* be large enough even for the the worse case scenario. */ /* be large enough even for the the worse case scenario. */
if (libdeflate_zlib_compress_bound(sp->libdeflate_enc, (size_t)cc) > if (libdeflate_zlib_compress_bound(sp->libdeflate_enc, (size_t)cc) >
(size_t)tif->tif_rawdatasize) (size_t)tif->tif_rawdatasize)
@ -403,12 +428,12 @@ ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
sp->libdeflate_state = 1; sp->libdeflate_state = 1;
nCompressedBytes = libdeflate_zlib_compress( nCompressedBytes = libdeflate_zlib_compress(
sp->libdeflate_enc, bp, (size_t)cc, tif->tif_rawdata, (size_t)tif->tif_rawdatasize); sp->libdeflate_enc, bp, (size_t)cc, tif->tif_rawdata,
(size_t)tif->tif_rawdatasize);
if (nCompressedBytes == 0) if (nCompressedBytes == 0)
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "Encoder error at scanline %lu",
"Encoder error at scanline %lu",
(unsigned long)tif->tif_row); (unsigned long)tif->tif_row);
return 0; return 0;
} }
@ -429,21 +454,26 @@ ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
we need to simplify this code to reflect a ZLib that is likely updated we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond to deal with 8byte memory sizes, though this code will respond
appropriately even before we simplify it */ appropriately even before we simplify it */
do { do
uInt avail_in_before = (uint64)cc <= 0xFFFFFFFFU ? (uInt)cc : 0xFFFFFFFFU; {
uInt avail_in_before =
(uint64_t)cc <= 0xFFFFFFFFU ? (uInt)cc : 0xFFFFFFFFU;
sp->stream.avail_in = avail_in_before; sp->stream.avail_in = avail_in_before;
if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK) { /* coverity[overrun-buffer-arg] */
TIFFErrorExt(tif->tif_clientdata, module, if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK)
"Encoder error: %s", {
SAFE_MSG(sp)); TIFFErrorExtR(tif, module, "Encoder error: %s", SAFE_MSG(sp));
return (0); return (0);
} }
if (sp->stream.avail_out == 0) { if (sp->stream.avail_out == 0)
{
tif->tif_rawcc = tif->tif_rawdatasize; tif->tif_rawcc = tif->tif_rawdatasize;
if (!TIFFFlushData1(tif)) if (!TIFFFlushData1(tif))
return 0; return 0;
sp->stream.next_out = tif->tif_rawdata; sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = (uint64)tif->tif_rawdatasize <= 0xFFFFFFFFU ? (uInt)tif->tif_rawdatasize : 0xFFFFFFFFU; sp->stream.avail_out = (uint64_t)tif->tif_rawdatasize <= 0xFFFFFFFFU
? (uInt)tif->tif_rawdatasize
: 0xFFFFFFFFU;
} }
cc -= (avail_in_before - sp->stream.avail_in); cc -= (avail_in_before - sp->stream.avail_in);
} while (cc > 0); } while (cc > 0);
@ -454,8 +484,7 @@ ZIPEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
* 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 ZIPPostEncode(TIFF *tif)
ZIPPostEncode(TIFF* tif)
{ {
static const char module[] = "ZIPPostEncode"; static const char module[] = "ZIPPostEncode";
ZIPState *sp = EncoderState(tif); ZIPState *sp = EncoderState(tif);
@ -467,31 +496,35 @@ ZIPPostEncode(TIFF* tif)
#endif #endif
sp->stream.avail_in = 0; sp->stream.avail_in = 0;
do { do
{
state = deflate(&sp->stream, Z_FINISH); state = deflate(&sp->stream, Z_FINISH);
switch (state) { switch (state)
{
case Z_STREAM_END: case Z_STREAM_END:
case Z_OK: case Z_OK:
if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize) if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
{ {
tif->tif_rawcc = tif->tif_rawdatasize - sp->stream.avail_out; tif->tif_rawcc =
tif->tif_rawdatasize - sp->stream.avail_out;
if (!TIFFFlushData1(tif)) if (!TIFFFlushData1(tif))
return 0; return 0;
sp->stream.next_out = tif->tif_rawdata; sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out = (uint64)tif->tif_rawdatasize <= 0xFFFFFFFFU ? (uInt)tif->tif_rawdatasize : 0xFFFFFFFFU; sp->stream.avail_out =
(uint64_t)tif->tif_rawdatasize <= 0xFFFFFFFFU
? (uInt)tif->tif_rawdatasize
: 0xFFFFFFFFU;
} }
break; break;
default: default:
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "ZLib error: %s", SAFE_MSG(sp));
"ZLib error: %s", SAFE_MSG(sp));
return (0); return (0);
} }
} while (state != Z_STREAM_END); } while (state != Z_STREAM_END);
return (1); return (1);
} }
static void static void ZIPCleanup(TIFF *tif)
ZIPCleanup(TIFF* tif)
{ {
ZIPState *sp = ZState(tif); ZIPState *sp = ZState(tif);
@ -502,10 +535,13 @@ ZIPCleanup(TIFF* 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 & ZSTATE_INIT_ENCODE) { if (sp->state & ZSTATE_INIT_ENCODE)
{
deflateEnd(&sp->stream); deflateEnd(&sp->stream);
sp->state = 0; sp->state = 0;
} else if( sp->state & ZSTATE_INIT_DECODE) { }
else if (sp->state & ZSTATE_INIT_DECODE)
{
inflateEnd(&sp->stream); inflateEnd(&sp->stream);
sp->state = 0; sp->state = 0;
} }
@ -517,37 +553,40 @@ ZIPCleanup(TIFF* tif)
libdeflate_free_compressor(sp->libdeflate_enc); libdeflate_free_compressor(sp->libdeflate_enc);
#endif #endif
_TIFFfree(sp); _TIFFfreeExt(tif, sp);
tif->tif_data = NULL; tif->tif_data = NULL;
_TIFFSetDefaultCompressionState(tif); _TIFFSetDefaultCompressionState(tif);
} }
static int static int ZIPVSetField(TIFF *tif, uint32_t tag, va_list ap)
ZIPVSetField(TIFF* tif, uint32 tag, va_list ap)
{ {
static const char module[] = "ZIPVSetField"; static const char module[] = "ZIPVSetField";
ZIPState *sp = ZState(tif); ZIPState *sp = ZState(tif);
switch (tag) { switch (tag)
{
case TIFFTAG_ZIPQUALITY: case TIFFTAG_ZIPQUALITY:
sp->zipquality = (int)va_arg(ap, int); sp->zipquality = (int)va_arg(ap, int);
if (sp->zipquality < Z_DEFAULT_COMPRESSION || if (sp->zipquality < Z_DEFAULT_COMPRESSION ||
sp->zipquality > LIBDEFLATE_MAX_COMPRESSION_LEVEL ) { sp->zipquality > LIBDEFLATE_MAX_COMPRESSION_LEVEL)
TIFFErrorExt(tif->tif_clientdata, module, {
TIFFErrorExtR(
tif, module,
"Invalid ZipQuality value. Should be in [-1,%d] range", "Invalid ZipQuality value. Should be in [-1,%d] range",
LIBDEFLATE_MAX_COMPRESSION_LEVEL); LIBDEFLATE_MAX_COMPRESSION_LEVEL);
return 0; return 0;
} }
if ( sp->state&ZSTATE_INIT_ENCODE ) { if (sp->state & ZSTATE_INIT_ENCODE)
{
int cappedQuality = sp->zipquality; int cappedQuality = sp->zipquality;
if (cappedQuality > Z_BEST_COMPRESSION) if (cappedQuality > Z_BEST_COMPRESSION)
cappedQuality = Z_BEST_COMPRESSION; cappedQuality = Z_BEST_COMPRESSION;
if (deflateParams(&sp->stream, if (deflateParams(&sp->stream, cappedQuality,
cappedQuality, Z_DEFAULT_STRATEGY) != Z_OK) { Z_DEFAULT_STRATEGY) != Z_OK)
TIFFErrorExt(tif->tif_clientdata, module, "ZLib error: %s", {
SAFE_MSG(sp)); TIFFErrorExtR(tif, module, "ZLib error: %s", SAFE_MSG(sp));
return (0); return (0);
} }
} }
@ -567,15 +606,15 @@ ZIPVSetField(TIFF* tif, uint32 tag, va_list ap)
if (sp->subcodec != DEFLATE_SUBCODEC_ZLIB && if (sp->subcodec != DEFLATE_SUBCODEC_ZLIB &&
sp->subcodec != DEFLATE_SUBCODEC_LIBDEFLATE) sp->subcodec != DEFLATE_SUBCODEC_LIBDEFLATE)
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "Invalid DeflateCodec value.");
"Invalid DeflateCodec value.");
return 0; return 0;
} }
#if !LIBDEFLATE_SUPPORT #if !LIBDEFLATE_SUPPORT
if (sp->subcodec == DEFLATE_SUBCODEC_LIBDEFLATE) if (sp->subcodec == DEFLATE_SUBCODEC_LIBDEFLATE)
{ {
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module,
"DeflateCodec = DEFLATE_SUBCODEC_LIBDEFLATE unsupported in this build"); "DeflateCodec = DEFLATE_SUBCODEC_LIBDEFLATE "
"unsupported in this build");
return 0; return 0;
} }
#endif #endif
@ -587,12 +626,12 @@ ZIPVSetField(TIFF* tif, uint32 tag, va_list ap)
/*NOTREACHED*/ /*NOTREACHED*/
} }
static int static int ZIPVGetField(TIFF *tif, uint32_t tag, va_list ap)
ZIPVGetField(TIFF* tif, uint32 tag, va_list ap)
{ {
ZIPState *sp = ZState(tif); ZIPState *sp = ZState(tif);
switch (tag) { switch (tag)
{
case TIFFTAG_ZIPQUALITY: case TIFFTAG_ZIPQUALITY:
*va_arg(ap, int *) = sp->zipquality; *va_arg(ap, int *) = sp->zipquality;
break; break;
@ -608,18 +647,19 @@ ZIPVGetField(TIFF* tif, uint32 tag, va_list ap)
} }
static const TIFFField zipFields[] = { static const TIFFField zipFields[] = {
{ TIFFTAG_ZIPQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "", NULL }, {TIFFTAG_ZIPQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
{ TIFFTAG_DEFLATE_SUBCODEC, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "", NULL }, TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "", NULL},
{TIFFTAG_DEFLATE_SUBCODEC, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT,
TIFF_SETGET_UNDEFINED, FIELD_PSEUDO, TRUE, FALSE, "", NULL},
}; };
int int TIFFInitZIP(TIFF *tif, int scheme)
TIFFInitZIP(TIFF* tif, int scheme)
{ {
static const char module[] = "TIFFInitZIP"; static const char module[] = "TIFFInitZIP";
ZIPState *sp; ZIPState *sp;
assert( (scheme == COMPRESSION_DEFLATE) assert((scheme == COMPRESSION_DEFLATE) ||
|| (scheme == COMPRESSION_ADOBE_DEFLATE)); (scheme == COMPRESSION_ADOBE_DEFLATE));
#ifdef NDEBUG #ifdef NDEBUG
(void)scheme; (void)scheme;
#endif #endif
@ -627,8 +667,9 @@ TIFFInitZIP(TIFF* tif, int scheme)
/* /*
* Merge codec-specific tag information. * Merge codec-specific tag information.
*/ */
if (!_TIFFMergeFields(tif, zipFields, TIFFArrayCount(zipFields))) { if (!_TIFFMergeFields(tif, zipFields, TIFFArrayCount(zipFields)))
TIFFErrorExt(tif->tif_clientdata, module, {
TIFFErrorExtR(tif, module,
"Merging Deflate codec-specific tags failed"); "Merging Deflate codec-specific tags failed");
return 0; return 0;
} }
@ -636,7 +677,7 @@ TIFFInitZIP(TIFF* tif, int scheme)
/* /*
* 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*) _TIFFcalloc(sizeof (ZIPState), 1); tif->tif_data = (uint8_t *)_TIFFcallocExt(tif, sizeof(ZIPState), 1);
if (tif->tif_data == NULL) if (tif->tif_data == NULL)
goto bad; goto bad;
sp = ZState(tif); sp = ZState(tif);
@ -684,17 +725,7 @@ TIFFInitZIP(TIFF* tif, int scheme)
(void)TIFFPredictorInit(tif); (void)TIFFPredictorInit(tif);
return (1); return (1);
bad: bad:
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "No space for ZIP state block");
"No space for ZIP state block");
return (0); return (0);
} }
#endif /* ZIP_SUPPORT */ #endif /* ZIP_SUPPORT */
/* 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_zstd.c vendored
View File

@ -39,7 +39,8 @@
/* /*
* 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; TIFFPredictorState predict;
ZSTD_DStream *dstream; ZSTD_DStream *dstream;
ZSTD_CStream *cstream; ZSTD_CStream *cstream;
@ -57,25 +58,24 @@ typedef struct {
#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); ZSTD_freeCStream(sp->cstream);
sp->cstream = NULL; sp->cstream = NULL;
sp->state = 0; sp->state = 0;
@ -88,8 +88,7 @@ ZSTDSetupDecode(TIFF* tif)
/* /*
* 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);
@ -101,22 +100,20 @@ ZSTDPreDecode(TIFF* tif, uint16 s)
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 ) if (sp->dstream == NULL)
{ {
ZSTD_freeDStream(sp->dstream);
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); zstd_ret = ZSTD_initDStream(sp->dstream);
if( ZSTD_isError(zstd_ret) ) { if (ZSTD_isError(zstd_ret))
TIFFErrorExt(tif->tif_clientdata, module, {
"Error in ZSTD_initDStream(): %s", TIFFErrorExtR(tif, module, "Error in ZSTD_initDStream(): %s",
ZSTD_getErrorName(zstd_ret)); ZSTD_getErrorName(zstd_ret));
return 0; return 0;
} }
@ -124,8 +121,7 @@ ZSTDPreDecode(TIFF* tif, uint16 s)
return 1; return 1;
} }
static int static int ZSTDDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
ZSTDDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
{ {
static const char module[] = "ZSTDDecode"; static const char module[] = "ZSTDDecode";
ZSTDState *sp = DecoderState(tif); ZSTDState *sp = DecoderState(tif);
@ -145,24 +141,24 @@ ZSTDDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
out_buffer.size = (size_t)occ; out_buffer.size = (size_t)occ;
out_buffer.pos = 0; out_buffer.pos = 0;
do { do
zstd_ret = ZSTD_decompressStream(sp->dstream, &out_buffer, {
&in_buffer); zstd_ret = ZSTD_decompressStream(sp->dstream, &out_buffer, &in_buffer);
if( ZSTD_isError(zstd_ret) ) { if (ZSTD_isError(zstd_ret))
TIFFErrorExt(tif->tif_clientdata, module, {
"Error in ZSTD_decompressStream(): %s", TIFFErrorExtR(tif, module, "Error in ZSTD_decompressStream(): %s",
ZSTD_getErrorName(zstd_ret)); ZSTD_getErrorName(zstd_ret));
return 0; return 0;
} }
} while( zstd_ret != 0 && } while (zstd_ret != 0 && in_buffer.pos < in_buffer.size &&
in_buffer.pos < in_buffer.size &&
out_buffer.pos < out_buffer.size); out_buffer.pos < out_buffer.size);
if (out_buffer.pos < (size_t)occ) { if (out_buffer.pos < (size_t)occ)
TIFFErrorExt(tif->tif_clientdata, module, {
TIFFErrorExtR(tif, module,
"Not enough data at scanline %lu (short %lu bytes)", "Not enough data at scanline %lu (short %lu bytes)",
(unsigned long)tif->tif_row, (unsigned long)tif->tif_row,
(unsigned long) (size_t)occ - out_buffer.pos); (unsigned long)((size_t)occ - out_buffer.pos));
return 0; return 0;
} }
@ -172,13 +168,13 @@ ZSTDDecode(TIFF* tif, uint8* op, tmsize_t occ, uint16 s)
return 1; return 1;
} }
static int static int ZSTDSetupEncode(TIFF *tif)
ZSTDSetupEncode(TIFF* tif)
{ {
ZSTDState *sp = EncoderState(tif); ZSTDState *sp = EncoderState(tif);
assert(sp != NULL); assert(sp != NULL);
if (sp->state & LSTATE_INIT_DECODE) { if (sp->state & LSTATE_INIT_DECODE)
{
ZSTD_freeDStream(sp->dstream); ZSTD_freeDStream(sp->dstream);
sp->dstream = NULL; sp->dstream = NULL;
sp->state = 0; sp->state = 0;
@ -191,8 +187,7 @@ ZSTDSetupEncode(TIFF* tif)
/* /*
* 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);
@ -203,21 +198,20 @@ ZSTDPreEncode(TIFF* tif, uint16 s)
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;
} }
@ -232,8 +226,7 @@ ZSTDPreEncode(TIFF* tif, uint16 s)
/* /*
* 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);
@ -249,16 +242,18 @@ ZSTDEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
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", {
TIFFErrorExtR(tif, module, "Error in ZSTD_compressStream(): %s",
ZSTD_getErrorName(zstd_ret)); ZSTD_getErrorName(zstd_ret));
return 0; return 0;
} }
if( sp->out_buffer.pos == sp->out_buffer.size ) { if (sp->out_buffer.pos == sp->out_buffer.size)
{
tif->tif_rawcc = tif->tif_rawdatasize; tif->tif_rawcc = tif->tif_rawdatasize;
if (!TIFFFlushData1(tif)) if (!TIFFFlushData1(tif))
return 0; return 0;
@ -273,22 +268,23 @@ ZSTDEncode(TIFF* tif, uint8* bp, tmsize_t cc, uint16 s)
/* /*
* 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); zstd_ret = ZSTD_endStream(sp->cstream, &sp->out_buffer);
if( ZSTD_isError(zstd_ret) ) { if (ZSTD_isError(zstd_ret))
TIFFErrorExt(tif->tif_clientdata, module, {
"Error in ZSTD_endStream(): %s", TIFFErrorExtR(tif, module, "Error in ZSTD_endStream(): %s",
ZSTD_getErrorName(zstd_ret)); ZSTD_getErrorName(zstd_ret));
return 0; return 0;
} }
if( sp->out_buffer.pos > 0 ) { if (sp->out_buffer.pos > 0)
{
tif->tif_rawcc = sp->out_buffer.pos; tif->tif_rawcc = sp->out_buffer.pos;
if (!TIFFFlushData1(tif)) if (!TIFFFlushData1(tif))
return 0; return 0;
@ -299,8 +295,7 @@ ZSTDPostEncode(TIFF* tif)
return 1; return 1;
} }
static void static void ZSTDCleanup(TIFF *tif)
ZSTDCleanup(TIFF* tif)
{ {
ZSTDState *sp = LState(tif); ZSTDState *sp = LState(tif);
@ -311,33 +306,35 @@ ZSTDCleanup(TIFF* 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); ZSTD_freeDStream(sp->dstream);
sp->dstream = NULL; sp->dstream = NULL;
} }
if (sp->cstream) { if (sp->cstream)
{
ZSTD_freeCStream(sp->cstream); ZSTD_freeCStream(sp->cstream);
sp->cstream = NULL; sp->cstream = NULL;
} }
_TIFFfree(sp); _TIFFfreeExt(tif, sp);
tif->tif_data = NULL; 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());
} }
@ -348,12 +345,12 @@ ZSTDVSetField(TIFF* tif, uint32 tag, va_list 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;
@ -365,31 +362,31 @@ ZSTDVGetField(TIFF* tif, uint32 tag, va_list ap)
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;
(void)scheme;
assert(scheme == COMPRESSION_ZSTD); 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; 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(ZSTDState)); tif->tif_data = (uint8_t *)_TIFFmallocExt(tif, sizeof(ZSTDState));
if (tif->tif_data == NULL) if (tif->tif_data == NULL)
goto bad; goto bad;
sp = LState(tif); sp = LState(tif);
@ -433,10 +430,7 @@ TIFFInitZSTD(TIFF* tif, int scheme)
(void)TIFFPredictorInit(tif); (void)TIFFPredictorInit(tif);
return 1; return 1;
bad: bad:
TIFFErrorExt(tif->tif_clientdata, module, TIFFErrorExtR(tif, module, "No space for ZSTD state block");
"No space for ZSTD state block");
return 0; return 0;
} }
#endif /* ZSTD_SUPPORT */ #endif /* ZSTD_SUPPORT */
/* vim: set ts=8 sts=8 sw=8 noet: */

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

@ -56,24 +56,38 @@
/* /*
* Intrinsic data types required by the file format: * Intrinsic data types required by the file format:
* *
* 8-bit quantities int8/uint8 * 8-bit quantities int8_t/uint_8_t
* 16-bit quantities int16/uint16 * 16-bit quantities int16_t/uint_16_t
* 32-bit quantities int32/uint32 * 32-bit quantities int32_t/uint_32_t
* 64-bit quantities int64/uint64 * 64-bit quantities int64_t/uint_64_t
* strings unsigned char* * strings unsigned char*
*/ */
#ifdef __GNUC__
#define TIFF_GCC_DEPRECATED __attribute__((deprecated))
#else
#define TIFF_GCC_DEPRECATED
#endif
#ifdef _MSC_VER
#define TIFF_MSC_DEPRECATED \
__declspec(deprecated("libtiff type deprecated; please use corresponding " \
"C99 stdint.h type"))
#else
#define TIFF_MSC_DEPRECATED
#endif
typedef TIFF_INT8_T int8; #ifndef TIFF_DISABLE_DEPRECATED
typedef TIFF_UINT8_T uint8; typedef TIFF_MSC_DEPRECATED int8_t int8 TIFF_GCC_DEPRECATED;
typedef TIFF_MSC_DEPRECATED uint8_t uint8 TIFF_GCC_DEPRECATED;
typedef TIFF_INT16_T int16; typedef TIFF_MSC_DEPRECATED int16_t int16 TIFF_GCC_DEPRECATED;
typedef TIFF_UINT16_T uint16; typedef TIFF_MSC_DEPRECATED uint16_t uint16 TIFF_GCC_DEPRECATED;
typedef TIFF_INT32_T int32; typedef TIFF_MSC_DEPRECATED int32_t int32 TIFF_GCC_DEPRECATED;
typedef TIFF_UINT32_T uint32; typedef TIFF_MSC_DEPRECATED uint32_t uint32 TIFF_GCC_DEPRECATED;
typedef TIFF_INT64_T int64; typedef TIFF_MSC_DEPRECATED int64_t int64 TIFF_GCC_DEPRECATED;
typedef TIFF_UINT64_T uint64; typedef TIFF_MSC_DEPRECATED uint64_t uint64 TIFF_GCC_DEPRECATED;
#endif /* TIFF_DISABLE_DEPRECATED */
/* /*
* Some types as promoted in a variable argument list * Some types as promoted in a variable argument list
@ -88,24 +102,26 @@ typedef int uint16_vap;
/* /*
* TIFF header. * TIFF header.
*/ */
typedef struct { typedef struct
uint16 tiff_magic; /* magic number (defines byte order) */ {
uint16 tiff_version; /* TIFF version number */ uint16_t tiff_magic; /* magic number (defines byte order) */
uint16_t tiff_version; /* TIFF version number */
} TIFFHeaderCommon; } TIFFHeaderCommon;
typedef struct { typedef struct
uint16 tiff_magic; /* magic number (defines byte order) */ {
uint16 tiff_version; /* TIFF version number */ uint16_t tiff_magic; /* magic number (defines byte order) */
uint32 tiff_diroff; /* byte offset to first directory */ uint16_t tiff_version; /* TIFF version number */
uint32_t tiff_diroff; /* byte offset to first directory */
} TIFFHeaderClassic; } TIFFHeaderClassic;
typedef struct { typedef struct
uint16 tiff_magic; /* magic number (defines byte order) */ {
uint16 tiff_version; /* TIFF version number */ uint16_t tiff_magic; /* magic number (defines byte order) */
uint16 tiff_offsetsize; /* size of offsets, should be 8 */ uint16_t tiff_version; /* TIFF version number */
uint16 tiff_unused; /* unused word, should be 0 */ uint16_t tiff_offsetsize; /* size of offsets, should be 8 */
uint64 tiff_diroff; /* byte offset to first directory */ uint16_t tiff_unused; /* unused word, should be 0 */
uint64_t tiff_diroff; /* byte offset to first directory */
} TIFFHeaderBig; } TIFFHeaderBig;
/* /*
* NB: In the comments below, * NB: In the comments below,
* - items marked with a + are obsoleted by revision 5.0, * - items marked with a + are obsoleted by revision 5.0,
@ -120,12 +136,14 @@ typedef struct {
* *
* Note: RATIONALs are the ratio of two 32-bit integer values. * Note: RATIONALs are the ratio of two 32-bit integer values.
*--: *--:
* Note2: TIFF_IFD8 data type is used in tiffFields[]-tag definition in order to distinguish the write-handling * Note2: TIFF_IFD8 data type is used in tiffFields[]-tag definition in order to
of those tags between ClassicTIFF and BigTiff: distinguish the write-handling of those tags between ClassicTIFF and BigTiff:
For ClassicTIFF libtiff writes a 32-bit value and the TIFF_IFD type-id into the file For ClassicTIFF libtiff writes a 32-bit value and the TIFF_IFD
For BigTIFF libtiff writes a 64-bit value and the TIFF_IFD8 type-id into the file type-id into the file For BigTIFF libtiff writes a 64-bit value and the
TIFF_IFD8 type-id into the file
*/ */
typedef enum { typedef enum
{
TIFF_NOTYPE = 0, /* placeholder */ TIFF_NOTYPE = 0, /* placeholder */
TIFF_BYTE = 1, /* 8-bit unsigned integer */ TIFF_BYTE = 1, /* 8-bit unsigned integer */
TIFF_ASCII = 2, /* 8-bit bytes w/ last byte null */ TIFF_ASCII = 2, /* 8-bit bytes w/ last byte null */
@ -148,6 +166,7 @@ typedef enum {
/* /*
* TIFF Tag Definitions. * TIFF Tag Definitions.
*/ */
/* clang-format off */ /* for better readability of tag comments */
#define TIFFTAG_SUBFILETYPE 254 /* subfile data descriptor */ #define TIFFTAG_SUBFILETYPE 254 /* subfile data descriptor */
#define FILETYPE_REDUCEDIMAGE 0x1 /* reduced resolution version */ #define FILETYPE_REDUCEDIMAGE 0x1 /* reduced resolution version */
#define FILETYPE_PAGE 0x2 /* one page of many */ #define FILETYPE_PAGE 0x2 /* one page of many */
@ -183,9 +202,8 @@ typedef enum {
/* compression codes 32908-32911 are reserved for Pixar */ /* compression codes 32908-32911 are reserved for Pixar */
#define COMPRESSION_PIXARFILM 32908 /* Pixar companded 10bit LZW */ #define COMPRESSION_PIXARFILM 32908 /* Pixar companded 10bit LZW */
#define COMPRESSION_PIXARLOG 32909 /* Pixar companded 11bit ZIP */ #define COMPRESSION_PIXARLOG 32909 /* Pixar companded 11bit ZIP */
#define COMPRESSION_DEFLATE 32946 /* Deflate compression */ #define COMPRESSION_DEFLATE 32946 /* Deflate compression, legacy tag */
#define COMPRESSION_ADOBE_DEFLATE 8 /* Deflate compression, #define COMPRESSION_ADOBE_DEFLATE 8 /* Deflate compression, as recognized by Adobe */
as recognized by Adobe */
/* compression code 32947 is reserved for Oceana Matrix <dev@oceana.com> */ /* compression code 32947 is reserved for Oceana Matrix <dev@oceana.com> */
#define COMPRESSION_DCS 32947 /* Kodak DCS encoding */ #define COMPRESSION_DCS 32947 /* Kodak DCS encoding */
#define COMPRESSION_JBIG 34661 /* ISO JBIG */ #define COMPRESSION_JBIG 34661 /* ISO JBIG */
@ -197,6 +215,7 @@ typedef enum {
#define COMPRESSION_LZMA 34925 /* LZMA2 */ #define COMPRESSION_LZMA 34925 /* LZMA2 */
#define COMPRESSION_ZSTD 50000 /* ZSTD: WARNING not registered in Adobe-maintained registry */ #define COMPRESSION_ZSTD 50000 /* ZSTD: WARNING not registered in Adobe-maintained registry */
#define COMPRESSION_WEBP 50001 /* WEBP: WARNING not registered in Adobe-maintained registry */ #define COMPRESSION_WEBP 50001 /* WEBP: WARNING not registered in Adobe-maintained registry */
#define COMPRESSION_JXL 50002 /* JPEGXL: WARNING not registered in Adobe-maintained registry */
#define TIFFTAG_PHOTOMETRIC 262 /* photometric interpretation */ #define TIFFTAG_PHOTOMETRIC 262 /* photometric interpretation */
#define PHOTOMETRIC_MINISWHITE 0 /* min value is white */ #define PHOTOMETRIC_MINISWHITE 0 /* min value is white */
#define PHOTOMETRIC_MINISBLACK 1 /* min value is black */ #define PHOTOMETRIC_MINISBLACK 1 /* min value is black */
@ -319,14 +338,10 @@ typedef enum {
#define SAMPLEFORMAT_COMPLEXIEEEFP 6 /* !complex ieee floating */ #define SAMPLEFORMAT_COMPLEXIEEEFP 6 /* !complex ieee floating */
#define TIFFTAG_SMINSAMPLEVALUE 340 /* !variable MinSampleValue */ #define TIFFTAG_SMINSAMPLEVALUE 340 /* !variable MinSampleValue */
#define TIFFTAG_SMAXSAMPLEVALUE 341 /* !variable MaxSampleValue */ #define TIFFTAG_SMAXSAMPLEVALUE 341 /* !variable MaxSampleValue */
#define TIFFTAG_CLIPPATH 343 /* %ClipPath #define TIFFTAG_CLIPPATH 343 /* %ClipPath [Adobe TIFF technote 2] */
[Adobe TIFF technote 2] */ #define TIFFTAG_XCLIPPATHUNITS 344 /* %XClipPathUnits [Adobe TIFF technote 2] */
#define TIFFTAG_XCLIPPATHUNITS 344 /* %XClipPathUnits #define TIFFTAG_YCLIPPATHUNITS 345 /* %YClipPathUnits [Adobe TIFF technote 2] */
[Adobe TIFF technote 2] */ #define TIFFTAG_INDEXED 346 /* %Indexed [Adobe TIFF Technote 3] */
#define TIFFTAG_YCLIPPATHUNITS 345 /* %YClipPathUnits
[Adobe TIFF technote 2] */
#define TIFFTAG_INDEXED 346 /* %Indexed
[Adobe TIFF Technote 3] */
#define TIFFTAG_JPEGTABLES 347 /* %JPEG table stream */ #define TIFFTAG_JPEGTABLES 347 /* %JPEG table stream */
#define TIFFTAG_OPIPROXY 351 /* %OPI Proxy [Adobe TIFF technote] */ #define TIFFTAG_OPIPROXY 351 /* %OPI Proxy [Adobe TIFF technote] */
/* Tags 400-435 are from the TIFF/FX spec */ /* Tags 400-435 are from the TIFF/FX spec */
@ -375,12 +390,11 @@ typedef enum {
#define YCBCRPOSITION_COSITED 2 /* !as in CCIR 601-1 */ #define YCBCRPOSITION_COSITED 2 /* !as in CCIR 601-1 */
#define TIFFTAG_REFERENCEBLACKWHITE 532 /* !colorimetry info */ #define TIFFTAG_REFERENCEBLACKWHITE 532 /* !colorimetry info */
#define TIFFTAG_STRIPROWCOUNTS 559 /* !TIFF/FX strip row counts */ #define TIFFTAG_STRIPROWCOUNTS 559 /* !TIFF/FX strip row counts */
#define TIFFTAG_XMLPACKET 700 /* %XML packet #define TIFFTAG_XMLPACKET 700 /* %XML packet [Adobe XMP Specification, January 2004 */
[Adobe XMP Specification, #define TIFFTAG_OPIIMAGEID 32781 /* %OPI ImageID [Adobe TIFF technote] */
January 2004 */ /* For eiStream Annotation Specification, Version 1.00.06 see
#define TIFFTAG_OPIIMAGEID 32781 /* %OPI ImageID * http://web.archive.org/web/20050309141348/http://www.kofile.com/support%20pro/faqs/annospec.htm */
[Adobe TIFF technote] */ #define TIFFTAG_TIFFANNOTATIONDATA 32932
#define TIFFTAG_TIFFANNOTATIONDATA 32932 /* http://web.archive.org/web/20050309141348/http://www.kofile.com/support%20pro/faqs/annospec.htm */
/* tags 32952-32956 are private tags registered to Island Graphics */ /* tags 32952-32956 are private tags registered to Island Graphics */
#define TIFFTAG_REFPTS 32953 /* image reference points */ #define TIFFTAG_REFPTS 32953 /* image reference points */
#define TIFFTAG_REGIONTACKPOINT 32954 /* region-xform tack point */ #define TIFFTAG_REGIONTACKPOINT 32954 /* region-xform tack point */
@ -411,21 +425,24 @@ typedef enum {
#define TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA 33306 #define TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA 33306
/* tag 33405 is a private tag registered to Eastman Kodak */ /* tag 33405 is a private tag registered to Eastman Kodak */
#define TIFFTAG_WRITERSERIALNUMBER 33405 /* device serial number */ #define TIFFTAG_WRITERSERIALNUMBER 33405 /* device serial number */
#define TIFFTAG_CFAREPEATPATTERNDIM 33421 /* dimensions of CFA pattern */ #define TIFFTAG_CFAREPEATPATTERNDIM 33421 /* (alias for TIFFTAG_EP_CFAREPEATPATTERNDIM)*/
#define TIFFTAG_CFAPATTERN 33422 /* color filter array pattern */ #define TIFFTAG_CFAPATTERN 33422 /* (alias for TIFFTAG_EP_CFAPATTERN) */
#define TIFFTAG_BATTERYLEVEL 33423 /* (alias for TIFFTAG_EP_BATTERYLEVEL) */
/* tag 33432 is listed in the 6.0 spec w/ unknown ownership */ /* tag 33432 is listed in the 6.0 spec w/ unknown ownership */
#define TIFFTAG_COPYRIGHT 33432 /* copyright string */ #define TIFFTAG_COPYRIGHT 33432 /* copyright string */
/* Tags 33445-33452 are used for GEL fileformat, see /* Tags 33445-33452 are used for Molecular Dynamics GEL fileformat,
* http://research.stowers-institute.org/mcm/efg/ScientificSoftware/Utility/TiffTags/GEL-FileFormat.pdf * see http://research.stowers-institute.org/mcm/efg/ScientificSoftware/Utility/TiffTags/GEL-FileFormat.pdf
* (2023: the above web site is unavailable but tags are explained briefly at
* https://www.awaresystems.be/imaging/tiff/tifftags/docs/gel.html
*/ */
#define TIFFTAG_MD_FILETAG 33445 /* http://research.stowers-institute.org/mcm/efg/ScientificSoftware/Utility/TiffTags/GEL-FileFormat.pdf */ #define TIFFTAG_MD_FILETAG 33445 /* Specifies the pixel data format encoding in the GEL file format. */
#define TIFFTAG_MD_SCALEPIXEL 33446 /* http://research.stowers-institute.org/mcm/efg/ScientificSoftware/Utility/TiffTags/GEL-FileFormat.pdf */ #define TIFFTAG_MD_SCALEPIXEL 33446 /* scale factor */
#define TIFFTAG_MD_COLORTABLE 33447 /* http://research.stowers-institute.org/mcm/efg/ScientificSoftware/Utility/TiffTags/GEL-FileFormat.pdf */ #define TIFFTAG_MD_COLORTABLE 33447 /* conversion from 16bit to 8bit */
#define TIFFTAG_MD_LABNAME 33448 /* http://research.stowers-institute.org/mcm/efg/ScientificSoftware/Utility/TiffTags/GEL-FileFormat.pdf */ #define TIFFTAG_MD_LABNAME 33448 /* name of the lab that scanned this file. */
#define TIFFTAG_MD_SAMPLEINFO 33449 /* http://research.stowers-institute.org/mcm/efg/ScientificSoftware/Utility/TiffTags/GEL-FileFormat.pdf */ #define TIFFTAG_MD_SAMPLEINFO 33449 /* information about the scanned GEL sample */
#define TIFFTAG_MD_PREPDATE 33450 /* http://research.stowers-institute.org/mcm/efg/ScientificSoftware/Utility/TiffTags/GEL-FileFormat.pdf */ #define TIFFTAG_MD_PREPDATE 33450 /* information about the date the sample was prepared YY/MM/DD */
#define TIFFTAG_MD_PREPTIME 33451 /* http://research.stowers-institute.org/mcm/efg/ScientificSoftware/Utility/TiffTags/GEL-FileFormat.pdf */ #define TIFFTAG_MD_PREPTIME 33451 /* information about the time the sample was prepared HH:MM*/
#define TIFFTAG_MD_FILEUNITS 33452 /* http://research.stowers-institute.org/mcm/efg/ScientificSoftware/Utility/TiffTags/GEL-FileFormat.pdf */ #define TIFFTAG_MD_FILEUNITS 33452 /* Units for data in this file, as used in the GEL file format. */
/* IPTC TAG from RichTIFF specifications */ /* IPTC TAG from RichTIFF specifications */
#define TIFFTAG_RICHTIFFIPTC 33723 #define TIFFTAG_RICHTIFFIPTC 33723
#define TIFFTAG_INGR_PACKET_DATA_TAG 33918 /* Intergraph Application specific storage. */ #define TIFFTAG_INGR_PACKET_DATA_TAG 33918 /* Intergraph Application specific storage. */
@ -448,8 +465,7 @@ typedef enum {
#define TIFFTAG_IT8TRANSPARENCYINDICATOR 34028 /* HC transparency switch */ #define TIFFTAG_IT8TRANSPARENCYINDICATOR 34028 /* HC transparency switch */
#define TIFFTAG_IT8COLORCHARACTERIZATION 34029 /* color character. table */ #define TIFFTAG_IT8COLORCHARACTERIZATION 34029 /* color character. table */
#define TIFFTAG_IT8HCUSAGE 34030 /* HC usage indicator */ #define TIFFTAG_IT8HCUSAGE 34030 /* HC usage indicator */
#define TIFFTAG_IT8TRAPINDICATOR 34031 /* Trapping indicator #define TIFFTAG_IT8TRAPINDICATOR 34031 /* Trapping indicator (untrapped=0, trapped=1) */
(untrapped=0, trapped=1) */
#define TIFFTAG_IT8CMYKEQUIVALENT 34032 /* CMYK color equivalents */ #define TIFFTAG_IT8CMYKEQUIVALENT 34032 /* CMYK color equivalents */
/* tags 34232-34236 are private tags registered to Texas Instruments */ /* tags 34232-34236 are private tags registered to Texas Instruments */
#define TIFFTAG_FRAMECOUNT 34232 /* Sequence Frame Count */ #define TIFFTAG_FRAMECOUNT 34232 /* Sequence Frame Count */
@ -463,9 +479,9 @@ typedef enum {
#define TIFFTAG_IMAGELAYER 34732 /* !TIFF/FX image layer information */ #define TIFFTAG_IMAGELAYER 34732 /* !TIFF/FX image layer information */
/* tag 34750 is a private tag registered to Pixel Magic */ /* tag 34750 is a private tag registered to Pixel Magic */
#define TIFFTAG_JBIGOPTIONS 34750 /* JBIG options */ #define TIFFTAG_JBIGOPTIONS 34750 /* JBIG options */
#define TIFFTAG_GPSIFD 34853 /* Pointer to GPS private directory */ #define TIFFTAG_GPSIFD 34853 /* Pointer to EXIF GPS private directory */
/* tags 34908-34914 are private tags registered to SGI */ /* tags 34908-34914 are private tags registered to SGI */
#define TIFFTAG_FAXRECVPARAMS 34908 /* encoded Class 2 ses. parms */ #define TIFFTAG_FAXRECVPARAMS 34908 /* encoded Class 2 ses. params */
#define TIFFTAG_FAXSUBADDRESS 34909 /* received SubAddr string */ #define TIFFTAG_FAXSUBADDRESS 34909 /* received SubAddr string */
#define TIFFTAG_FAXRECVTIME 34910 /* receive time (secs) */ #define TIFFTAG_FAXRECVTIME 34910 /* receive time (secs) */
#define TIFFTAG_FAXDCS 34911 /* encoded fax ses. params, Table 2/T.30 */ #define TIFFTAG_FAXDCS 34911 /* encoded fax ses. params, Table 2/T.30 */
@ -474,106 +490,193 @@ typedef enum {
/* tag 34929 is a private tag registered to FedEx */ /* tag 34929 is a private tag registered to FedEx */
#define TIFFTAG_FEDEX_EDR 34929 /* unknown use */ #define TIFFTAG_FEDEX_EDR 34929 /* unknown use */
#define TIFFTAG_IMAGESOURCEDATA 37724 /* http://justsolve.archiveteam.org/wiki/PSD, http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/ */ #define TIFFTAG_IMAGESOURCEDATA 37724 /* http://justsolve.archiveteam.org/wiki/PSD, http://www.adobe.com/devnet-apps/photoshop/fileformatashtml/ */
#define TIFFTAG_INTEROPERABILITYIFD 40965 /* Pointer to Interoperability private directory */ #define TIFFTAG_INTEROPERABILITYIFD 40965 /* Pointer to EXIF Interoperability private directory */
#define TIFFTAG_GDAL_METADATA 42112 /* Used by the GDAL library */ #define TIFFTAG_GDAL_METADATA 42112 /* Used by the GDAL library */
#define TIFFTAG_GDAL_NODATA 42113 /* Used by the GDAL library */ #define TIFFTAG_GDAL_NODATA 42113 /* Used by the GDAL library */
#define TIFFTAG_OCE_SCANJOB_DESCRIPTION 50215 /* Used in the Oce scanning process */ #define TIFFTAG_OCE_SCANJOB_DESCRIPTION 50215 /* Used in the Oce scanning process */
#define TIFFTAG_OCE_APPLICATION_SELECTOR 50216 /* Used in the Oce scanning process. */ #define TIFFTAG_OCE_APPLICATION_SELECTOR 50216 /* Used in the Oce scanning process. */
#define TIFFTAG_OCE_IDENTIFICATION_NUMBER 50217 #define TIFFTAG_OCE_IDENTIFICATION_NUMBER 50217
#define TIFFTAG_OCE_IMAGELOGIC_CHARACTERISTICS 50218 #define TIFFTAG_OCE_IMAGELOGIC_CHARACTERISTICS 50218
/* tags 50674 to 50677 are reserved for ESRI */ /* tags 50674 to 50677 are reserved for ESRI */
#define TIFFTAG_LERC_PARAMETERS 50674 /* Stores LERC version and additional compression method */ #define TIFFTAG_LERC_PARAMETERS 50674 /* Stores LERC version and additional compression method */
/* Adobe Digital Negative (DNG) format tags */ /* Adobe Digital Negative (DNG) format tags */
#define TIFFTAG_DNGVERSION 50706 /* &DNG version number */ #define TIFFTAG_DNGVERSION 50706 /* &DNG version number */
#define TIFFTAG_DNGBACKWARDVERSION 50707 /* &DNG compatibility version */ #define TIFFTAG_DNGBACKWARDVERSION 50707 /* &DNG compatibility version */
#define TIFFTAG_UNIQUECAMERAMODEL 50708 /* &name for the camera model */ #define TIFFTAG_UNIQUECAMERAMODEL 50708 /* &name for the camera model */
#define TIFFTAG_LOCALIZEDCAMERAMODEL 50709 /* &localized camera model #define TIFFTAG_LOCALIZEDCAMERAMODEL 50709 /* &localized camera model name (UTF-8) */
name */ #define TIFFTAG_CFAPLANECOLOR 50710 /* &CFAPattern->LinearRaw space mapping */
#define TIFFTAG_CFAPLANECOLOR 50710 /* &CFAPattern->LinearRaw space
mapping */
#define TIFFTAG_CFALAYOUT 50711 /* &spatial layout of the CFA */ #define TIFFTAG_CFALAYOUT 50711 /* &spatial layout of the CFA */
#define TIFFTAG_LINEARIZATIONTABLE 50712 /* &lookup table description */ #define TIFFTAG_LINEARIZATIONTABLE 50712 /* &lookup table description */
#define TIFFTAG_BLACKLEVELREPEATDIM 50713 /* &repeat pattern size for #define TIFFTAG_BLACKLEVELREPEATDIM 50713 /* &repeat pattern size for the BlackLevel tag */
the BlackLevel tag */
#define TIFFTAG_BLACKLEVEL 50714 /* &zero light encoding level */ #define TIFFTAG_BLACKLEVEL 50714 /* &zero light encoding level */
#define TIFFTAG_BLACKLEVELDELTAH 50715 /* &zero light encoding level #define TIFFTAG_BLACKLEVELDELTAH 50715 /* &zero light encoding level differences (columns) */
differences (columns) */ #define TIFFTAG_BLACKLEVELDELTAV 50716 /* &zero light encoding level differences (rows) */
#define TIFFTAG_BLACKLEVELDELTAV 50716 /* &zero light encoding level #define TIFFTAG_WHITELEVEL 50717 /* &fully saturated encoding level */
differences (rows) */
#define TIFFTAG_WHITELEVEL 50717 /* &fully saturated encoding
level */
#define TIFFTAG_DEFAULTSCALE 50718 /* &default scale factors */ #define TIFFTAG_DEFAULTSCALE 50718 /* &default scale factors */
#define TIFFTAG_DEFAULTCROPORIGIN 50719 /* &origin of the final image #define TIFFTAG_DEFAULTCROPORIGIN 50719 /* &origin of the final image area */
area */ #define TIFFTAG_DEFAULTCROPSIZE 50720 /* &size of the final image area */
#define TIFFTAG_DEFAULTCROPSIZE 50720 /* &size of the final image #define TIFFTAG_COLORMATRIX1 50721 /* &XYZ->reference color space transformation matrix 1 */
area */ #define TIFFTAG_COLORMATRIX2 50722 /* &XYZ->reference color space transformation matrix 2 */
#define TIFFTAG_COLORMATRIX1 50721 /* &XYZ->reference color space
transformation matrix 1 */
#define TIFFTAG_COLORMATRIX2 50722 /* &XYZ->reference color space
transformation matrix 2 */
#define TIFFTAG_CAMERACALIBRATION1 50723 /* &calibration matrix 1 */ #define TIFFTAG_CAMERACALIBRATION1 50723 /* &calibration matrix 1 */
#define TIFFTAG_CAMERACALIBRATION2 50724 /* &calibration matrix 2 */ #define TIFFTAG_CAMERACALIBRATION2 50724 /* &calibration matrix 2 */
#define TIFFTAG_REDUCTIONMATRIX1 50725 /* &dimensionality reduction #define TIFFTAG_REDUCTIONMATRIX1 50725 /* &dimensionality reduction matrix 1 */
matrix 1 */ #define TIFFTAG_REDUCTIONMATRIX2 50726 /* &dimensionality reduction matrix 2 */
#define TIFFTAG_REDUCTIONMATRIX2 50726 /* &dimensionality reduction #define TIFFTAG_ANALOGBALANCE 50727 /* &gain applied the stored raw values*/
matrix 2 */ #define TIFFTAG_ASSHOTNEUTRAL 50728 /* &selected white balance in linear reference space */
#define TIFFTAG_ANALOGBALANCE 50727 /* &gain applied the stored raw #define TIFFTAG_ASSHOTWHITEXY 50729 /* &selected white balance in x-y chromaticity coordinates */
values*/ #define TIFFTAG_BASELINEEXPOSURE 50730 /* &how much to move the zero point */
#define TIFFTAG_ASSHOTNEUTRAL 50728 /* &selected white balance in
linear reference space */
#define TIFFTAG_ASSHOTWHITEXY 50729 /* &selected white balance in
x-y chromaticity
coordinates */
#define TIFFTAG_BASELINEEXPOSURE 50730 /* &how much to move the zero
point */
#define TIFFTAG_BASELINENOISE 50731 /* &relative noise level */ #define TIFFTAG_BASELINENOISE 50731 /* &relative noise level */
#define TIFFTAG_BASELINESHARPNESS 50732 /* &relative amount of #define TIFFTAG_BASELINESHARPNESS 50732 /* &relative amount of sharpening */
sharpening */ /* TIFFTAG_BAYERGREENSPLIT: &how closely the values of the green pixels in the blue/green rows
#define TIFFTAG_BAYERGREENSPLIT 50733 /* &how closely the values of * track the values of the green pixels in the red/green rows */
the green pixels in the #define TIFFTAG_BAYERGREENSPLIT 50733
blue/green rows track the
values of the green pixels
in the red/green rows */
#define TIFFTAG_LINEARRESPONSELIMIT 50734 /* &non-linear encoding range */ #define TIFFTAG_LINEARRESPONSELIMIT 50734 /* &non-linear encoding range */
#define TIFFTAG_CAMERASERIALNUMBER 50735 /* &camera's serial number */ #define TIFFTAG_CAMERASERIALNUMBER 50735 /* &camera's serial number */
#define TIFFTAG_LENSINFO 50736 /* info about the lens */ #define TIFFTAG_LENSINFO 50736 /* info about the lens */
#define TIFFTAG_CHROMABLURRADIUS 50737 /* &chroma blur radius */ #define TIFFTAG_CHROMABLURRADIUS 50737 /* &chroma blur radius */
#define TIFFTAG_ANTIALIASSTRENGTH 50738 /* &relative strength of the #define TIFFTAG_ANTIALIASSTRENGTH 50738 /* &relative strength of the camera's anti-alias filter */
camera's anti-alias filter */
#define TIFFTAG_SHADOWSCALE 50739 /* &used by Adobe Camera Raw */ #define TIFFTAG_SHADOWSCALE 50739 /* &used by Adobe Camera Raw */
#define TIFFTAG_DNGPRIVATEDATA 50740 /* &manufacturer's private data */ #define TIFFTAG_DNGPRIVATEDATA 50740 /* &manufacturer's private data */
#define TIFFTAG_MAKERNOTESAFETY 50741 /* &whether the EXIF MakerNote #define TIFFTAG_MAKERNOTESAFETY 50741 /* &whether the EXIF MakerNote tag is safe to preserve along with the rest of the EXIF data */
tag is safe to preserve
along with the rest of the
EXIF data */
#define TIFFTAG_CALIBRATIONILLUMINANT1 50778 /* &illuminant 1 */ #define TIFFTAG_CALIBRATIONILLUMINANT1 50778 /* &illuminant 1 */
#define TIFFTAG_CALIBRATIONILLUMINANT2 50779 /* &illuminant 2 */ #define TIFFTAG_CALIBRATIONILLUMINANT2 50779 /* &illuminant 2 */
#define TIFFTAG_BESTQUALITYSCALE 50780 /* &best quality multiplier */ #define TIFFTAG_BESTQUALITYSCALE 50780 /* &best quality multiplier */
#define TIFFTAG_RAWDATAUNIQUEID 50781 /* &unique identifier for #define TIFFTAG_RAWDATAUNIQUEID 50781 /* &unique identifier for the raw image data */
the raw image data */ #define TIFFTAG_ORIGINALRAWFILENAME 50827 /* &file name of the original raw file (UTF-8) */
#define TIFFTAG_ORIGINALRAWFILENAME 50827 /* &file name of the original #define TIFFTAG_ORIGINALRAWFILEDATA 50828 /* &contents of the original raw file */
raw file */ #define TIFFTAG_ACTIVEAREA 50829 /* &active (non-masked) pixels of the sensor */
#define TIFFTAG_ORIGINALRAWFILEDATA 50828 /* &contents of the original #define TIFFTAG_MASKEDAREAS 50830 /* &list of coordinates of fully masked pixels */
raw file */
#define TIFFTAG_ACTIVEAREA 50829 /* &active (non-masked) pixels
of the sensor */
#define TIFFTAG_MASKEDAREAS 50830 /* &list of coordinates
of fully masked pixels */
#define TIFFTAG_ASSHOTICCPROFILE 50831 /* &these two tags used to */ #define TIFFTAG_ASSHOTICCPROFILE 50831 /* &these two tags used to */
#define TIFFTAG_ASSHOTPREPROFILEMATRIX 50832 /* map cameras's color space #define TIFFTAG_ASSHOTPREPROFILEMATRIX 50832 /* map cameras's color space into ICC profile space */
into ICC profile space */
#define TIFFTAG_CURRENTICCPROFILE 50833 /* & */ #define TIFFTAG_CURRENTICCPROFILE 50833 /* & */
#define TIFFTAG_CURRENTPREPROFILEMATRIX 50834 /* & */ #define TIFFTAG_CURRENTPREPROFILEMATRIX 50834 /* & */
#define TIFFTAG_RPCCOEFFICIENT 50844 /* Define by GDAL for geospatial georeferencing through RPC: http://geotiff.maptools.org/rpc_prop.html */ /* DNG 1.2.0.0 */
#define TIFFTAG_COLORIMETRICREFERENCE 50879 /* &colorimetric reference */
#define TIFFTAG_CAMERACALIBRATIONSIGNATURE 50931 /* &camera calibration signature (UTF-8) */
#define TIFFTAG_PROFILECALIBRATIONSIGNATURE 50932 /* &profile calibration signature (UTF-8) */
/* TIFFTAG_EXTRACAMERAPROFILES 50933 &extra camera profiles : is already defined for GeoTIFF DGIWG */
#define TIFFTAG_ASSHOTPROFILENAME 50934 /* &as shot profile name (UTF-8) */
#define TIFFTAG_NOISEREDUCTIONAPPLIED 50935 /* &amount of applied noise reduction */
#define TIFFTAG_PROFILENAME 50936 /* &camera profile name (UTF-8) */
#define TIFFTAG_PROFILEHUESATMAPDIMS 50937 /* &dimensions of HSV mapping */
#define TIFFTAG_PROFILEHUESATMAPDATA1 50938 /* &first HSV mapping table */
#define TIFFTAG_PROFILEHUESATMAPDATA2 50939 /* &second HSV mapping table */
#define TIFFTAG_PROFILETONECURVE 50940 /* &default tone curve */
#define TIFFTAG_PROFILEEMBEDPOLICY 50941 /* &profile embedding policy */
#define TIFFTAG_PROFILECOPYRIGHT 50942 /* &profile copyright information (UTF-8) */
#define TIFFTAG_FORWARDMATRIX1 50964 /* &matrix for mapping white balanced camera colors to XYZ D50 */
#define TIFFTAG_FORWARDMATRIX2 50965 /* &matrix for mapping white balanced camera colors to XYZ D50 */
#define TIFFTAG_PREVIEWAPPLICATIONNAME 50966 /* &name of application that created preview (UTF-8) */
#define TIFFTAG_PREVIEWAPPLICATIONVERSION 50967 /* &version of application that created preview (UTF-8) */
#define TIFFTAG_PREVIEWSETTINGSNAME 50968 /* &name of conversion settings (UTF-8) */
#define TIFFTAG_PREVIEWSETTINGSDIGEST 50969 /* &unique id of conversion settings */
#define TIFFTAG_PREVIEWCOLORSPACE 50970 /* &preview color space */
#define TIFFTAG_PREVIEWDATETIME 50971 /* &date/time preview was rendered */
#define TIFFTAG_RAWIMAGEDIGEST 50972 /* &md5 of raw image data */
#define TIFFTAG_ORIGINALRAWFILEDIGEST 50973 /* &md5 of the data stored in the OriginalRawFileData tag */
#define TIFFTAG_SUBTILEBLOCKSIZE 50974 /* &subtile block size */
#define TIFFTAG_ROWINTERLEAVEFACTOR 50975 /* &number of interleaved fields */
#define TIFFTAG_PROFILELOOKTABLEDIMS 50981 /* &num of input samples in each dim of default "look" table */
#define TIFFTAG_PROFILELOOKTABLEDATA 50982 /* &default "look" table for use as starting point */
/* DNG 1.3.0.0 */
#define TIFFTAG_OPCODELIST1 51008 /* &opcodes that should be applied to raw image after reading */
#define TIFFTAG_OPCODELIST2 51009 /* &opcodes that should be applied after mapping to linear reference */
#define TIFFTAG_OPCODELIST3 51022 /* &opcodes that should be applied after demosaicing */
#define TIFFTAG_NOISEPROFILE 51041 /* &noise profile */
/* DNG 1.4.0.0 */
#define TIFFTAG_DEFAULTUSERCROP 51125 /* &default user crop rectangle in relative coords */
#define TIFFTAG_DEFAULTBLACKRENDER 51110 /* &black rendering hint */
#define TIFFTAG_BASELINEEXPOSUREOFFSET 51109 /* &baseline exposure offset */
#define TIFFTAG_PROFILELOOKTABLEENCODING 51108 /* &3D LookTable indexing conversion */
#define TIFFTAG_PROFILEHUESATMAPENCODING 51107 /* &3D HueSatMap indexing conversion */
#define TIFFTAG_ORIGINALDEFAULTFINALSIZE 51089 /* &default final size of larger original file for this proxy */
#define TIFFTAG_ORIGINALBESTQUALITYFINALSIZE 51090 /* &best quality final size of larger original file for this proxy */
#define TIFFTAG_ORIGINALDEFAULTCROPSIZE 51091 /* &the default crop size of larger original file for this proxy */
#define TIFFTAG_NEWRAWIMAGEDIGEST 51111 /* &modified MD5 digest of the raw image data */
#define TIFFTAG_RAWTOPREVIEWGAIN 51112 /* &The gain between the main raw FD and the preview IFD containing this tag */
/* DNG 1.5.0.0 */
#define TIFFTAG_DEPTHFORMAT 51177 /* &encoding of the depth data in the file */
#define TIFFTAG_DEPTHNEAR 51178 /* &distance from the camera represented by value 0 in the depth map */
#define TIFFTAG_DEPTHFAR 51179 /* &distance from the camera represented by the maximum value in the depth map */
#define TIFFTAG_DEPTHUNITS 51180 /* &measurement units for DepthNear and DepthFar */
#define TIFFTAG_DEPTHMEASURETYPE 51181 /* &measurement geometry for the depth map */
#define TIFFTAG_ENHANCEPARAMS 51182 /* &a string that documents how the enhanced image data was processed. */
/* DNG 1.6.0.0 */
#define TIFFTAG_PROFILEGAINTABLEMAP 52525 /* &spatially varying gain tables that can be applied as starting point */
#define TIFFTAG_SEMANTICNAME 52526 /* &a string that identifies the semantic mask */
#define TIFFTAG_SEMANTICINSTANCEID 52528 /* &a string that identifies a specific instance in a semantic mask */
#define TIFFTAG_MASKSUBAREA 52536 /* &the crop rectangle of this IFD's mask, relative to the main image */
#define TIFFTAG_RGBTABLES 52543 /* &color transforms to apply to masked image regions */
#define TIFFTAG_CALIBRATIONILLUMINANT3 52529 /* &the illuminant used for the third set of color calibration tags */
#define TIFFTAG_COLORMATRIX3 52531 /* &matrix to convert XYZ values to reference camera native color space under CalibrationIlluminant3 */
#define TIFFTAG_CAMERACALIBRATION3 52530 /* &matrix to transform reference camera native space values to individual camera native space values under CalibrationIlluminant3 */
#define TIFFTAG_REDUCTIONMATRIX3 52538 /* &dimensionality reduction matrix for use in color conversion to XYZ under CalibrationIlluminant3 */
#define TIFFTAG_PROFILEHUESATMAPDATA3 52537 /* &the data for the third HSV table */
#define TIFFTAG_FORWARDMATRIX3 52532 /* &matrix to map white balanced camera colors to XYZ D50 */
#define TIFFTAG_ILLUMINANTDATA1 52533 /* &data for the first calibration illuminant */
#define TIFFTAG_ILLUMINANTDATA2 52534 /* &data for the second calibration illuminant */
#define TIFFTAG_ILLUMINANTDATA3 53535 /* &data for the third calibration illuminant */
/* TIFF/EP */
#define TIFFTAG_EP_CFAREPEATPATTERNDIM 33421 /* dimensions of CFA pattern */
#define TIFFTAG_EP_CFAPATTERN 33422 /* color filter array pattern */
#define TIFFTAG_EP_BATTERYLEVEL 33423 /* battery level (rational or ASCII) */
#define TIFFTAG_EP_INTERLACE 34857 /* Number of multi-field images */
/* TIFFTAG_EP_IPTC_NAA and TIFFTAG_RICHTIFFIPTC share the same tag number (33723)
* LibTIFF type is UNDEFINED or BYTE, but often times incorrectly specified as LONG,
* because TIFF/EP (ISO/DIS 12234-2) specifies type LONG or ASCII. */
#define TIFFTAG_EP_IPTC_NAA 33723 /* Alias IPTC/NAA Newspaper Association RichTIFF */
#define TIFFTAG_EP_TIMEZONEOFFSET 34858 /* Time zone offset relative to UTC */
#define TIFFTAG_EP_SELFTIMERMODE 34859 /* Number of seconds capture was delayed from button press */
#define TIFFTAG_EP_FLASHENERGY 37387 /* Flash energy, or range if there is uncertainty */
#define TIFFTAG_EP_SPATIALFREQUENCYRESPONSE 37388 /* Spatial frequency response */
#define TIFFTAG_EP_NOISE 37389 /* Camera noise measurement values */
#define TIFFTAG_EP_FOCALPLANEXRESOLUTION 37390 /* Focal plane X resolution */
#define TIFFTAG_EP_FOCALPLANEYRESOLUTION 37391 /* Focal plane Y resolution */
#define TIFFTAG_EP_FOCALPLANERESOLUTIONUNIT 37392 /* Focal plane resolution unit */
#define TIFFTAG_EP_IMAGENUMBER 37393 /* Number of image when several of burst shot stored in same TIFF/EP */
#define TIFFTAG_EP_SECURITYCLASSIFICATION 37394 /* Security classification */
#define TIFFTAG_EP_IMAGEHISTORY 37395 /* Record of what has been done to the image */
#define TIFFTAG_EP_EXPOSUREINDEX 37397 /* Exposure index */
#define TIFFTAG_EP_STANDARDID 37398 /* TIFF/EP standard version, n.n.n.n */
#define TIFFTAG_EP_SENSINGMETHOD 37399 /* Type of image sensor */
/*
* TIFF/EP tags equivalent to EXIF tags
* Note that TIFF-EP and EXIF use nearly the same metadata tag set, but TIFF-EP stores the tags in IFD 0,
* while EXIF store the tags in a separate IFD. Either location is allowed by DNG, but the EXIF location is preferred.
*/
#define TIFFTAG_EP_EXPOSURETIME 33434 /* Exposure time */
#define TIFFTAG_EP_FNUMBER 33437 /* F number */
#define TIFFTAG_EP_EXPOSUREPROGRAM 34850 /* Exposure program */
#define TIFFTAG_EP_SPECTRALSENSITIVITY 34852 /* Spectral sensitivity */
#define TIFFTAG_EP_ISOSPEEDRATINGS 34855 /* ISO speed rating */
#define TIFFTAG_EP_OECF 34856 /* Optoelectric conversion factor */
#define TIFFTAG_EP_DATETIMEORIGINAL 36867 /* Date and time of original data generation */
#define TIFFTAG_EP_COMPRESSEDBITSPERPIXEL 37122 /* Image compression mode */
#define TIFFTAG_EP_SHUTTERSPEEDVALUE 37377 /* Shutter speed */
#define TIFFTAG_EP_APERTUREVALUE 37378 /* Aperture */
#define TIFFTAG_EP_BRIGHTNESSVALUE 37379 /* Brightness */
#define TIFFTAG_EP_EXPOSUREBIASVALUE 37380 /* Exposure bias */
#define TIFFTAG_EP_MAXAPERTUREVALUE 37381 /* Maximum lens aperture */
#define TIFFTAG_EP_SUBJECTDISTANCE 37382 /* Subject distance */
#define TIFFTAG_EP_METERINGMODE 37383 /* Metering mode */
#define TIFFTAG_EP_LIGHTSOURCE 37384 /* Light source */
#define TIFFTAG_EP_FLASH 37385 /* Flash */
#define TIFFTAG_EP_FOCALLENGTH 37386 /* Lens focal length */
#define TIFFTAG_EP_SUBJECTLOCATION 37396 /* Subject location (area) */
#define TIFFTAG_RPCCOEFFICIENT 50844 /* Define by GDAL for geospatial georeferencing through RPC: http://geotiff.maptools.org/rpc_prop.html */
#define TIFFTAG_ALIAS_LAYER_METADATA 50784 /* Alias Sketchbook Pro layer usage description. */ #define TIFFTAG_ALIAS_LAYER_METADATA 50784 /* Alias Sketchbook Pro layer usage description. */
/* GeoTIFF DGIWG */ /* GeoTIFF DGIWG */
#define TIFFTAG_TIFF_RSID 50908 /* https://www.awaresystems.be/imaging/tiff/tifftags/tiff_rsid.html */ #define TIFFTAG_TIFF_RSID 50908 /* https://www.awaresystems.be/imaging/tiff/tifftags/tiff_rsid.html */
#define TIFFTAG_GEO_METADATA 50909 /* https://www.awaresystems.be/imaging/tiff/tifftags/geo_metadata.html */ #define TIFFTAG_GEO_METADATA 50909 /* https://www.awaresystems.be/imaging/tiff/tifftags/geo_metadata.html */
#define TIFFTAG_EXTRACAMERAPROFILES 50933 /* http://wwwimages.adobe.com/www.adobe.com/content/dam/Adobe/en/products/photoshop/pdfs/dng_spec_1.4.0.0.pdf */ #define TIFFTAG_EXTRACAMERAPROFILES 50933 /* http://wwwimages.adobe.com/www.adobe.com/content/dam/Adobe/en/products/photoshop/pdfs/dng_spec_1.4.0.0.pdf */
/* tag 65535 is an undefined tag used by Eastman Kodak */ /* tag 65535 is an undefined tag used by Eastman Kodak */
@ -658,6 +761,7 @@ typedef enum {
#define TIFFTAG_LERC_MAXZERROR 65567 /* LERC maximum error */ #define TIFFTAG_LERC_MAXZERROR 65567 /* LERC maximum error */
#define TIFFTAG_WEBP_LEVEL 65568 /* WebP compression level */ #define TIFFTAG_WEBP_LEVEL 65568 /* WebP compression level */
#define TIFFTAG_WEBP_LOSSLESS 65569 /* WebP lossless/lossy */ #define TIFFTAG_WEBP_LOSSLESS 65569 /* WebP lossless/lossy */
#define TIFFTAG_WEBP_LOSSLESS_EXACT 65571 /* WebP lossless exact mode. Set-only mode. Default is 1. Can be set to 0 to increase compression rate, but R,G,B in areas where alpha = 0 will not be preserved */
#define TIFFTAG_DEFLATE_SUBCODEC 65570 /* ZIP codec: to get/set the sub-codec to use. Will default to libdeflate when available */ #define TIFFTAG_DEFLATE_SUBCODEC 65570 /* ZIP codec: to get/set the sub-codec to use. Will default to libdeflate when available */
#define DEFLATE_SUBCODEC_ZLIB 0 #define DEFLATE_SUBCODEC_ZLIB 0
#define DEFLATE_SUBCODEC_LIBDEFLATE 1 #define DEFLATE_SUBCODEC_LIBDEFLATE 1
@ -669,14 +773,14 @@ typedef enum {
#define EXIFTAG_FNUMBER 33437 /* F number */ #define EXIFTAG_FNUMBER 33437 /* F number */
#define EXIFTAG_EXPOSUREPROGRAM 34850 /* Exposure program */ #define EXIFTAG_EXPOSUREPROGRAM 34850 /* Exposure program */
#define EXIFTAG_SPECTRALSENSITIVITY 34852 /* Spectral sensitivity */ #define EXIFTAG_SPECTRALSENSITIVITY 34852 /* Spectral sensitivity */
/* After EXIF 2.2.1 ISOSpeedRatings is named PhotographicSensitivity.
In addition, while "Count=Any", only 1 count should be used. */
#define EXIFTAG_ISOSPEEDRATINGS 34855 /* ISO speed rating */ #define EXIFTAG_ISOSPEEDRATINGS 34855 /* ISO speed rating */
#define EXIFTAG_PHOTOGRAPHICSENSITIVITY 34855 /* Photographic Sensitivity (new name for tag 34855) */ #define EXIFTAG_PHOTOGRAPHICSENSITIVITY 34855 /* Photographic Sensitivity (new name for tag 34855) */
#define EXIFTAG_OECF 34856 /* Optoelectric conversion factor */ #define EXIFTAG_OECF 34856 /* Optoelectric conversion factor */
#define EXIFTAG_EXIFVERSION 36864 /* Exif version */ #define EXIFTAG_EXIFVERSION 36864 /* Exif version */
#define EXIFTAG_DATETIMEORIGINAL 36867 /* Date and time of original #define EXIFTAG_DATETIMEORIGINAL 36867 /* Date and time of original data generation */
data generation */ #define EXIFTAG_DATETIMEDIGITIZED 36868 /* Date and time of digital data generation */
#define EXIFTAG_DATETIMEDIGITIZED 36868 /* Date and time of digital
data generation */
#define EXIFTAG_COMPONENTSCONFIGURATION 37121 /* Meaning of each component */ #define EXIFTAG_COMPONENTSCONFIGURATION 37121 /* Meaning of each component */
#define EXIFTAG_COMPRESSEDBITSPERPIXEL 37122 /* Image compression mode */ #define EXIFTAG_COMPRESSEDBITSPERPIXEL 37122 /* Image compression mode */
#define EXIFTAG_SHUTTERSPEEDVALUE 37377 /* Shutter speed */ #define EXIFTAG_SHUTTERSPEEDVALUE 37377 /* Shutter speed */
@ -740,10 +844,14 @@ typedef enum {
#define EXIFTAG_PRESSURE 37890 /* Pressure as the ambient situation at the shot hecto-Pascal (hPa) */ #define EXIFTAG_PRESSURE 37890 /* Pressure as the ambient situation at the shot hecto-Pascal (hPa) */
#define EXIFTAG_WATERDEPTH 37891 /* WaterDepth as the ambient situation at the shot in meter (m) */ #define EXIFTAG_WATERDEPTH 37891 /* WaterDepth as the ambient situation at the shot in meter (m) */
#define EXIFTAG_ACCELERATION 37892 /* Acceleration (a scalar regardless of direction) as the ambientsituation at the shot in units of mGal (10-5 m/s^2) */ #define EXIFTAG_ACCELERATION 37892 /* Acceleration (a scalar regardless of direction) as the ambientsituation at the shot in units of mGal (10-5 m/s^2) */
#define EXIFTAG_CAMERAELEVATIONANGLE 37893 /* Elevation/depression. angle of the orientation of the camera(imaging optical axis) as the ambient situation at the shot in degree from -180deg to +180deg. */ /* EXIFTAG_CAMERAELEVATIONANGLE: Elevation/depression. angle of the orientation of the camera(imaging optical axis)
* as the ambient situation at the shot in degree from -180deg to +180deg. */
#define EXIFTAG_CAMERAELEVATIONANGLE 37893
#define EXIFTAG_CAMERAOWNERNAME 42032 /* owner of a camera */ #define EXIFTAG_CAMERAOWNERNAME 42032 /* owner of a camera */
#define EXIFTAG_BODYSERIALNUMBER 42033 /* serial number of the body of the camera */ #define EXIFTAG_BODYSERIALNUMBER 42033 /* serial number of the body of the camera */
#define EXIFTAG_LENSSPECIFICATION 42034 /* minimum focal length (in mm), maximum focal length (in mm), minimum F number in the minimum focal length, and minimum F number in the maximum focal length, */ /* EXIFTAG_LENSSPECIFICATION: minimum focal length (in mm), maximum focal length (in mm),minimum F number in the minimum focal length,
* and minimum F number in the maximum focal length, */
#define EXIFTAG_LENSSPECIFICATION 42034
#define EXIFTAG_LENSMAKE 42035 /* the lens manufacturer */ #define EXIFTAG_LENSMAKE 42035 /* the lens manufacturer */
#define EXIFTAG_LENSMODEL 42036 /* the lens model name and model number */ #define EXIFTAG_LENSMODEL 42036 /* the lens model name and model number */
#define EXIFTAG_LENSSERIALNUMBER 42037 /* the serial number of the interchangeable lens */ #define EXIFTAG_LENSSERIALNUMBER 42037 /* the serial number of the interchangeable lens */
@ -789,12 +897,3 @@ typedef enum {
#define GPSTAG_GPSHPOSITIONINGERROR 31 /* Indicates horizontal positioning errors in meters. */ #define GPSTAG_GPSHPOSITIONINGERROR 31 /* Indicates horizontal positioning errors in meters. */
#endif /* _TIFF_ */ #endif /* _TIFF_ */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

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 */

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

@ -60,16 +60,18 @@ 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 */
@ -87,7 +89,8 @@ 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) && \
!defined(USE_WIN32_FILEIO)
#define AVOID_WIN32_FILEIO #define AVOID_WIN32_FILEIO
#endif #endif
#endif #endif
@ -135,14 +138,15 @@ typedef void* thandle_t; /* client data handle */
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_mat[3][3]; /* XYZ -> luminance matrix */
float d_YCR; /* Light o/p for reference white */ float d_YCR; /* Light o/p for reference white */
float d_YCG; float d_YCG;
float d_YCB; float d_YCB;
uint32 d_Vrwr; /* Pixel values for ref. white */ uint32_t d_Vrwr; /* Pixel values for ref. white */
uint32 d_Vrwg; uint32_t d_Vrwg;
uint32 d_Vrwb; uint32_t d_Vrwb;
float d_Y0R; /* Residual light for black pixel */ float d_Y0R; /* Residual light for black pixel */
float d_Y0G; float d_Y0G;
float d_Y0B; float d_Y0B;
@ -151,16 +155,18 @@ typedef struct {
float d_gammaB; float d_gammaB;
} TIFFDisplay; } TIFFDisplay;
typedef struct { /* YCbCr->RGB support */ typedef struct
{ /* YCbCr->RGB support */
TIFFRGBValue *clamptab; /* range clamping table */ TIFFRGBValue *clamptab; /* range clamping table */
int *Cr_r_tab; int *Cr_r_tab;
int *Cb_b_tab; int *Cb_b_tab;
int32* Cr_g_tab; int32_t *Cr_g_tab;
int32* Cb_g_tab; int32_t *Cb_g_tab;
int32* Y_tab; int32_t *Y_tab;
} TIFFYCbCrToRGB; } TIFFYCbCrToRGB;
typedef struct { /* CIE Lab 1976->RGB support */ typedef struct
{ /* CIE Lab 1976->RGB support */
int range; /* Size of conversion table */ int range; /* Size of conversion table */
#define CIELABTORGB_TABLE_RANGE 1500 #define CIELABTORGB_TABLE_RANGE 1500
float rstep, gstep, bstep; float rstep, gstep, bstep;
@ -185,46 +191,49 @@ typedef struct _TIFFRGBAImage TIFFRGBAImage;
* 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 */ TIFF *tif; /* image handle */
int stoponerr; /* stop on read error */ int stoponerr; /* stop on read error */
int isContig; /* data is packed/separate */ int isContig; /* data is packed/separate */
int alpha; /* type of alpha data present */ int alpha; /* type of alpha data present */
uint32 width; /* image width */ uint32_t width; /* image width */
uint32 height; /* image height */ uint32_t height; /* image height */
uint16 bitspersample; /* image bits/sample */ uint16_t bitspersample; /* image bits/sample */
uint16 samplesperpixel; /* image samples/pixel */ uint16_t samplesperpixel; /* image samples/pixel */
uint16 orientation; /* image orientation */ uint16_t orientation; /* image orientation */
uint16 req_orientation; /* requested orientation */ uint16_t req_orientation; /* requested orientation */
uint16 photometric; /* image photometric interp */ uint16_t photometric; /* image photometric interp */
uint16* redcmap; /* colormap palette */ uint16_t *redcmap; /* colormap palette */
uint16* greencmap; uint16_t *greencmap;
uint16* bluecmap; uint16_t *bluecmap;
/* get image data routine */ /* get image data routine */
int (*get)(TIFFRGBAImage*, uint32*, uint32, uint32); int (*get)(TIFFRGBAImage *, uint32_t *, uint32_t, uint32_t);
/* put decoded strip/tile */ /* put decoded strip/tile */
union { union
{
void (*any)(TIFFRGBAImage *); void (*any)(TIFFRGBAImage *);
tileContigRoutine contig; tileContigRoutine contig;
tileSeparateRoutine separate; tileSeparateRoutine separate;
} put; } put;
TIFFRGBValue *Map; /* sample mapping array */ TIFFRGBValue *Map; /* sample mapping array */
uint32** BWmap; /* black&white map */ uint32_t **BWmap; /* black&white map */
uint32** PALmap; /* palette image map */ uint32_t **PALmap; /* palette image map */
TIFFYCbCrToRGB *ycbcr; /* YCbCr conversion state */ TIFFYCbCrToRGB *ycbcr; /* YCbCr conversion state */
TIFFCIELabToRGB *cielab; /* CIE L*a*b 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;
@ -247,31 +256,42 @@ struct _TIFFRGBAImage {
* 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; char *name;
uint16 scheme; uint16_t scheme;
TIFFInitMethod init; 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 *,
va_list);
typedef int (*TIFFErrorHandlerExtR)(TIFF *, void *user_data, const char *,
const char *, va_list);
typedef tmsize_t (*TIFFReadWriteProc)(thandle_t, void *, tmsize_t); typedef tmsize_t (*TIFFReadWriteProc)(thandle_t, void *, tmsize_t);
typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int); typedef toff_t (*TIFFSeekProc)(thandle_t, toff_t, int);
typedef int (*TIFFCloseProc)(thandle_t); typedef int (*TIFFCloseProc)(thandle_t);
@ -282,10 +302,10 @@ 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);
/* /*
@ -304,34 +324,42 @@ 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_ANY TIFF_NOTYPE /* for field descriptor searching */
#define TIFF_VARIABLE -1 /* marker for variable length tags */ #define TIFF_VARIABLE -1 /* marker for variable length tags */
#define TIFF_SPP -2 /* marker for SamplesPerPixel tags */ #define TIFF_SPP -2 /* marker for SamplesPerPixel tags */
#define TIFF_VARIABLE2 -3 /* marker for uint32 var-length tags */ #define TIFF_VARIABLE2 -3 /* marker for uint32_t var-length tags */
#define FIELD_CUSTOM 65 #define FIELD_CUSTOM 65
typedef struct _TIFFField TIFFField; typedef struct _TIFFField TIFFField;
typedef struct _TIFFFieldArray TIFFFieldArray; typedef struct _TIFFFieldArray TIFFFieldArray;
extern const TIFFField* TIFFFindField(TIFF *, uint32, TIFFDataType); extern const TIFFField *TIFFFindField(TIFF *, uint32_t, TIFFDataType);
extern const TIFFField* TIFFFieldWithTag(TIFF*, uint32); extern const TIFFField *TIFFFieldWithTag(TIFF *, uint32_t);
extern const TIFFField *TIFFFieldWithName(TIFF *, const char *); extern const TIFFField *TIFFFieldWithName(TIFF *, const char *);
extern uint32 TIFFFieldTag(const TIFFField*); extern uint32_t TIFFFieldTag(const TIFFField *);
extern const char *TIFFFieldName(const TIFFField *); extern const char *TIFFFieldName(const TIFFField *);
extern TIFFDataType TIFFFieldDataType(const TIFFField *); extern TIFFDataType TIFFFieldDataType(const TIFFField *);
extern int TIFFFieldPassCount(const TIFFField *); extern int TIFFFieldPassCount(const TIFFField *);
extern int TIFFFieldReadCount(const TIFFField *); extern int TIFFFieldReadCount(const TIFFField *);
extern int TIFFFieldWriteCount(const TIFFField *); extern int TIFFFieldWriteCount(const TIFFField *);
extern int
TIFFFieldSetGetSize(const TIFFField *); /* returns internal storage size of
TIFFSetGetFieldType in bytes. */
extern int TIFFFieldSetGetCountSize(
const TIFFField *); /* returns size of count parameter 0=none,
2=uint16_t, 4=uint32_t */
extern int TIFFFieldIsAnonymous(const TIFFField *);
typedef int (*TIFFVSetMethod)(TIFF*, uint32, va_list); typedef int (*TIFFVSetMethod)(TIFF *, uint32_t, va_list);
typedef int (*TIFFVGetMethod)(TIFF*, uint32, va_list); typedef int (*TIFFVGetMethod)(TIFF *, uint32_t, va_list);
typedef void (*TIFFPrintMethod)(TIFF *, FILE *, long); typedef void (*TIFFPrintMethod)(TIFF *, FILE *, long);
typedef struct { typedef struct
{
TIFFVSetMethod vsetfield; /* tag set routine */ TIFFVSetMethod vsetfield; /* tag set routine */
TIFFVGetMethod vgetfield; /* tag get routine */ TIFFVGetMethod vgetfield; /* tag get routine */
TIFFPrintMethod printdir; /* directory print routine */ TIFFPrintMethod printdir; /* directory print routine */
@ -345,32 +373,33 @@ extern void TIFFCleanup(TIFF* tif);
extern void TIFFClose(TIFF *tif); extern void TIFFClose(TIFF *tif);
extern int TIFFFlush(TIFF *tif); extern int TIFFFlush(TIFF *tif);
extern int TIFFFlushData(TIFF *tif); extern int TIFFFlushData(TIFF *tif);
extern int TIFFGetField(TIFF* tif, uint32 tag, ...); extern int TIFFGetField(TIFF *tif, uint32_t tag, ...);
extern int TIFFVGetField(TIFF* tif, uint32 tag, va_list ap); extern int TIFFVGetField(TIFF *tif, uint32_t tag, va_list ap);
extern int TIFFGetFieldDefaulted(TIFF* tif, uint32 tag, ...); extern int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag, ...);
extern int TIFFVGetFieldDefaulted(TIFF* tif, uint32 tag, va_list ap); extern int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap);
extern int TIFFReadDirectory(TIFF *tif); extern int TIFFReadDirectory(TIFF *tif);
extern int TIFFReadCustomDirectory(TIFF* tif, toff_t diroff, const TIFFFieldArray* infoarray); extern int TIFFReadCustomDirectory(TIFF *tif, toff_t diroff,
const TIFFFieldArray *infoarray);
extern int TIFFReadEXIFDirectory(TIFF *tif, toff_t diroff); extern int TIFFReadEXIFDirectory(TIFF *tif, toff_t diroff);
extern int TIFFReadGPSDirectory(TIFF *tif, toff_t diroff); extern int TIFFReadGPSDirectory(TIFF *tif, toff_t diroff);
extern uint64 TIFFScanlineSize64(TIFF* tif); extern uint64_t TIFFScanlineSize64(TIFF *tif);
extern tmsize_t TIFFScanlineSize(TIFF *tif); extern tmsize_t TIFFScanlineSize(TIFF *tif);
extern uint64 TIFFRasterScanlineSize64(TIFF* tif); extern uint64_t TIFFRasterScanlineSize64(TIFF *tif);
extern tmsize_t TIFFRasterScanlineSize(TIFF *tif); extern tmsize_t TIFFRasterScanlineSize(TIFF *tif);
extern uint64 TIFFStripSize64(TIFF* tif); extern uint64_t TIFFStripSize64(TIFF *tif);
extern tmsize_t TIFFStripSize(TIFF *tif); extern tmsize_t TIFFStripSize(TIFF *tif);
extern uint64 TIFFRawStripSize64(TIFF* tif, uint32 strip); extern uint64_t TIFFRawStripSize64(TIFF *tif, uint32_t strip);
extern tmsize_t TIFFRawStripSize(TIFF* tif, uint32 strip); extern tmsize_t TIFFRawStripSize(TIFF *tif, uint32_t strip);
extern uint64 TIFFVStripSize64(TIFF* tif, uint32 nrows); extern uint64_t TIFFVStripSize64(TIFF *tif, uint32_t nrows);
extern tmsize_t TIFFVStripSize(TIFF* tif, uint32 nrows); extern tmsize_t TIFFVStripSize(TIFF *tif, uint32_t nrows);
extern uint64 TIFFTileRowSize64(TIFF* tif); extern uint64_t TIFFTileRowSize64(TIFF *tif);
extern tmsize_t TIFFTileRowSize(TIFF *tif); extern tmsize_t TIFFTileRowSize(TIFF *tif);
extern uint64 TIFFTileSize64(TIFF* tif); extern uint64_t TIFFTileSize64(TIFF *tif);
extern tmsize_t TIFFTileSize(TIFF *tif); extern tmsize_t TIFFTileSize(TIFF *tif);
extern uint64 TIFFVTileSize64(TIFF* tif, uint32 nrows); extern uint64_t TIFFVTileSize64(TIFF *tif, uint32_t nrows);
extern tmsize_t TIFFVTileSize(TIFF* tif, uint32 nrows); extern tmsize_t TIFFVTileSize(TIFF *tif, uint32_t nrows);
extern uint32 TIFFDefaultStripSize(TIFF* tif, uint32 request); extern uint32_t TIFFDefaultStripSize(TIFF *tif, uint32_t request);
extern void TIFFDefaultTileSize(TIFF*, uint32*, uint32*); extern void TIFFDefaultTileSize(TIFF *, uint32_t *, uint32_t *);
extern int TIFFFileno(TIFF *); extern int TIFFFileno(TIFF *);
extern int TIFFSetFileno(TIFF *, int); extern int TIFFSetFileno(TIFF *, int);
extern thandle_t TIFFClientdata(TIFF *); extern thandle_t TIFFClientdata(TIFF *);
@ -382,6 +411,7 @@ extern int TIFFIsByteSwapped(TIFF*);
extern int TIFFIsUpSampled(TIFF *); extern int TIFFIsUpSampled(TIFF *);
extern int TIFFIsMSB2LSB(TIFF *); extern int TIFFIsMSB2LSB(TIFF *);
extern int TIFFIsBigEndian(TIFF *); extern int TIFFIsBigEndian(TIFF *);
extern int TIFFIsBigTIFF(TIFF *);
extern TIFFReadWriteProc TIFFGetReadProc(TIFF *); extern TIFFReadWriteProc TIFFGetReadProc(TIFF *);
extern TIFFReadWriteProc TIFFGetWriteProc(TIFF *); extern TIFFReadWriteProc TIFFGetWriteProc(TIFF *);
extern TIFFSeekProc TIFFGetSeekProc(TIFF *); extern TIFFSeekProc TIFFGetSeekProc(TIFF *);
@ -389,12 +419,12 @@ extern TIFFCloseProc TIFFGetCloseProc(TIFF*);
extern TIFFSizeProc TIFFGetSizeProc(TIFF *); extern TIFFSizeProc TIFFGetSizeProc(TIFF *);
extern TIFFMapFileProc TIFFGetMapFileProc(TIFF *); extern TIFFMapFileProc TIFFGetMapFileProc(TIFF *);
extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF *); extern TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF *);
extern uint32 TIFFCurrentRow(TIFF*); extern uint32_t TIFFCurrentRow(TIFF *);
extern uint16 TIFFCurrentDirectory(TIFF*); extern tdir_t TIFFCurrentDirectory(TIFF *);
extern uint16 TIFFNumberOfDirectories(TIFF*); extern tdir_t TIFFNumberOfDirectories(TIFF *);
extern uint64 TIFFCurrentDirOffset(TIFF*); extern uint64_t TIFFCurrentDirOffset(TIFF *);
extern uint32 TIFFCurrentStrip(TIFF*); extern uint32_t TIFFCurrentStrip(TIFF *);
extern uint32 TIFFCurrentTile(TIFF* tif); extern uint32_t TIFFCurrentTile(TIFF *tif);
extern int TIFFReadBufferSetup(TIFF *tif, void *bp, tmsize_t size); extern int TIFFReadBufferSetup(TIFF *tif, void *bp, tmsize_t size);
extern int TIFFWriteBufferSetup(TIFF *tif, void *bp, tmsize_t size); extern int TIFFWriteBufferSetup(TIFF *tif, void *bp, tmsize_t size);
extern int TIFFSetupStrips(TIFF *); extern int TIFFSetupStrips(TIFF *);
@ -405,14 +435,14 @@ extern int TIFFCreateCustomDirectory(TIFF*,const TIFFFieldArray*);
extern int TIFFCreateEXIFDirectory(TIFF *); extern int TIFFCreateEXIFDirectory(TIFF *);
extern int TIFFCreateGPSDirectory(TIFF *); extern int TIFFCreateGPSDirectory(TIFF *);
extern int TIFFLastDirectory(TIFF *); extern int TIFFLastDirectory(TIFF *);
extern int TIFFSetDirectory(TIFF*, uint16); extern int TIFFSetDirectory(TIFF *, tdir_t);
extern int TIFFSetSubDirectory(TIFF*, uint64); extern int TIFFSetSubDirectory(TIFF *, uint64_t);
extern int TIFFUnlinkDirectory(TIFF*, uint16); extern int TIFFUnlinkDirectory(TIFF *, tdir_t);
extern int TIFFSetField(TIFF*, uint32, ...); extern int TIFFSetField(TIFF *, uint32_t, ...);
extern int TIFFVSetField(TIFF*, uint32, va_list); extern int TIFFVSetField(TIFF *, uint32_t, va_list);
extern int TIFFUnsetField(TIFF*, uint32); extern int TIFFUnsetField(TIFF *, uint32_t);
extern int TIFFWriteDirectory(TIFF *); extern int TIFFWriteDirectory(TIFF *);
extern int TIFFWriteCustomDirectory(TIFF *, uint64 *); extern int TIFFWriteCustomDirectory(TIFF *, uint64_t *);
extern int TIFFCheckpointDirectory(TIFF *); extern int TIFFCheckpointDirectory(TIFF *);
extern int TIFFRewriteDirectory(TIFF *); extern int TIFFRewriteDirectory(TIFF *);
extern int TIFFDeferStrileArrayWriting(TIFF *); extern int TIFFDeferStrileArrayWriting(TIFF *);
@ -420,87 +450,145 @@ 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);
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); 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 TIFFReadRGBATileExt(TIFF *, uint32_t, uint32_t, uint32_t *,
int stop_on_error);
extern int TIFFRGBAImageOK(TIFF *, char[1024]); extern int TIFFRGBAImageOK(TIFF *, char[1024]);
extern int TIFFRGBAImageBegin(TIFFRGBAImage *, TIFF *, int, char[1024]); extern int TIFFRGBAImageBegin(TIFFRGBAImage *, TIFF *, int, char[1024]);
extern int TIFFRGBAImageGet(TIFFRGBAImage*, uint32*, uint32, uint32); extern int TIFFRGBAImageGet(TIFFRGBAImage *, uint32_t *, uint32_t,
uint32_t);
extern void TIFFRGBAImageEnd(TIFFRGBAImage *); extern void TIFFRGBAImageEnd(TIFFRGBAImage *);
extern TIFF* TIFFOpen(const char*, const char*);
# ifdef __WIN32__
extern TIFF* TIFFOpenW(const wchar_t*, const char*);
# 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 *TIFFFileName(TIFF *);
extern const char *TIFFSetFileName(TIFF *, const char *); extern const char *TIFFSetFileName(TIFF *, const char *);
extern void TIFFError(const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,2,3))); extern void TIFFError(const char *, const char *, ...)
extern void TIFFErrorExt(thandle_t, const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,3,4))); TIFF_ATTRIBUTE((__format__(__printf__, 2, 3)));
extern void TIFFWarning(const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,2,3))); extern void TIFFErrorExt(thandle_t, const char *, const char *, ...)
extern void TIFFWarningExt(thandle_t, const char*, const char*, ...) TIFF_ATTRIBUTE((__format__ (__printf__,3,4))); 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 TIFFErrorHandler TIFFSetErrorHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt); extern TIFFErrorHandlerExt TIFFSetErrorHandlerExt(TIFFErrorHandlerExt);
extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler); extern TIFFErrorHandler TIFFSetWarningHandler(TIFFErrorHandler);
extern TIFFErrorHandlerExt TIFFSetWarningHandlerExt(TIFFErrorHandlerExt); 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 TIFFExtendProc TIFFSetTagExtender(TIFFExtendProc);
extern uint32 TIFFComputeTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s); extern uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y,
extern int TIFFCheckTile(TIFF* tif, uint32 x, uint32 y, uint32 z, uint16 s); uint32_t z, uint16_t s);
extern uint32 TIFFNumberOfTiles(TIFF*); extern int TIFFCheckTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z,
extern tmsize_t TIFFReadTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s); uint16_t s);
extern tmsize_t TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s); extern uint32_t TIFFNumberOfTiles(TIFF *);
extern uint32 TIFFComputeStrip(TIFF*, uint32, uint16); extern tmsize_t TIFFReadTile(TIFF *tif, void *buf, uint32_t x, uint32_t y,
extern uint32 TIFFNumberOfStrips(TIFF*); uint32_t z, uint16_t s);
extern tmsize_t TIFFReadEncodedStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size); extern tmsize_t TIFFWriteTile(TIFF *tif, void *buf, uint32_t x, uint32_t y,
extern tmsize_t TIFFReadRawStrip(TIFF* tif, uint32 strip, void* buf, tmsize_t size); uint32_t z, uint16_t s);
extern tmsize_t TIFFReadEncodedTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size); extern uint32_t TIFFComputeStrip(TIFF *, uint32_t, uint16_t);
extern tmsize_t TIFFReadRawTile(TIFF* tif, uint32 tile, void* buf, tmsize_t size); extern uint32_t TIFFNumberOfStrips(TIFF *);
extern int TIFFReadFromUserBuffer(TIFF* tif, uint32 strile, extern tmsize_t TIFFReadEncodedStrip(TIFF *tif, uint32_t strip, void *buf,
void* inbuf, tmsize_t insize, tmsize_t size);
void* outbuf, tmsize_t outsize); extern tmsize_t TIFFReadRawStrip(TIFF *tif, uint32_t strip, void *buf,
extern tmsize_t TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc); tmsize_t size);
extern tmsize_t TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc); extern tmsize_t TIFFReadEncodedTile(TIFF *tif, uint32_t tile, void *buf,
extern tmsize_t TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc); tmsize_t size);
extern tmsize_t TIFFWriteRawTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc); extern tmsize_t TIFFReadRawTile(TIFF *tif, uint32_t tile, void *buf,
extern int TIFFDataWidth(TIFFDataType); /* table of tag datatype widths */ 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 TIFFSetWriteOffset(TIFF *tif, toff_t off);
extern void TIFFSwabShort(uint16*); extern void TIFFSwabShort(uint16_t *);
extern void TIFFSwabLong(uint32*); extern void TIFFSwabLong(uint32_t *);
extern void TIFFSwabLong8(uint64*); extern void TIFFSwabLong8(uint64_t *);
extern void TIFFSwabFloat(float *); extern void TIFFSwabFloat(float *);
extern void TIFFSwabDouble(double *); extern void TIFFSwabDouble(double *);
extern void TIFFSwabArrayOfShort(uint16* wp, tmsize_t n); extern void TIFFSwabArrayOfShort(uint16_t *wp, tmsize_t n);
extern void TIFFSwabArrayOfTriples(uint8* tp, tmsize_t n); extern void TIFFSwabArrayOfTriples(uint8_t *tp, tmsize_t n);
extern void TIFFSwabArrayOfLong(uint32* lp, tmsize_t n); extern void TIFFSwabArrayOfLong(uint32_t *lp, tmsize_t n);
extern void TIFFSwabArrayOfLong8(uint64* lp, tmsize_t n); extern void TIFFSwabArrayOfLong8(uint64_t *lp, tmsize_t n);
extern void TIFFSwabArrayOfFloat(float *fp, tmsize_t n); extern void TIFFSwabArrayOfFloat(float *fp, tmsize_t n);
extern void TIFFSwabArrayOfDouble(double *dp, tmsize_t n); extern void TIFFSwabArrayOfDouble(double *dp, tmsize_t n);
extern void TIFFReverseBits(uint8* cp, tmsize_t n); extern void TIFFReverseBits(uint8_t *cp, tmsize_t n);
extern const unsigned char *TIFFGetBitRevTable(int); extern const unsigned char *TIFFGetBitRevTable(int);
extern uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile); extern uint64_t TIFFGetStrileOffset(TIFF *tif, uint32_t strile);
extern uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile); extern uint64_t TIFFGetStrileByteCount(TIFF *tif, uint32_t strile);
extern uint64 TIFFGetStrileOffsetWithErr(TIFF *tif, uint32 strile, int *pbErr); extern uint64_t TIFFGetStrileOffsetWithErr(TIFF *tif, uint32_t strile,
extern uint64 TIFFGetStrileByteCountWithErr(TIFF *tif, uint32 strile, int *pbErr); 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
@ -508,42 +596,44 @@ extern uint64 TIFFGetStrileByteCountWithErr(TIFF *tif, uint32 strile, int *pbErr
#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 *);
extern void TIFFCIELabToXYZ(TIFFCIELabToRGB *, uint32_t, int32_t, int32_t,
float *, float *, float *); float *, float *, float *);
extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float, extern void TIFFXYZToRGB(TIFFCIELabToRGB *, float, float, float, uint32_t *,
uint32 *, uint32 *, uint32 *); 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 */ ttag_t field_tag; /* field's tag */
short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */ short field_readcount; /* read count/TIFF_VARIABLE/TIFF_SPP */
short field_writecount; /* write count/TIFF_VARIABLE */ short field_writecount; /* write count/TIFF_VARIABLE */
@ -554,19 +644,10 @@ typedef struct {
char *field_name; /* ASCII name */ char *field_name; /* ASCII name */
} TIFFFieldInfo; } TIFFFieldInfo;
extern int TIFFMergeFieldInfo(TIFF*, const TIFFFieldInfo[], uint32); extern int TIFFMergeFieldInfo(TIFF *, const TIFFFieldInfo[], uint32_t);
#if defined(c_plusplus) || defined(__cplusplus) #if defined(c_plusplus) || defined(__cplusplus)
} }
#endif #endif
#endif /* _TIFFIO_ */ #endif /* _TIFFIO_ */
/* vim: set ts=8 sts=8 sw=8 noet: */
/*
* Local Variables:
* mode: c
* c-basic-offset: 8
* fill-column: 78
* End:
*/

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

@ -29,20 +29,11 @@
* 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:
*/

342
3rdparty/libtiff/tiffiop.h vendored
View File

@ -38,9 +38,7 @@
#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>
@ -48,27 +46,23 @@
#define assert(x) #define assert(x)
#endif #endif
#ifdef HAVE_SEARCH_H #include "tif_hash_set.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
#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
#ifndef TIFF_MAX_DIR_COUNT
#define TIFF_MAX_DIR_COUNT 1048576
#endif
#define TIFF_NON_EXISTENT_DIR_NUMBER UINT_MAX
#define streq(a, b) (strcmp(a, b) == 0) #define streq(a, b) (strcmp(a, b) == 0)
#define strneq(a, b, n) (strncmp(a, b, n) == 0) #define strneq(a, b, n) (strncmp(a, b, n) == 0)
@ -77,20 +71,8 @@ extern int snprintf(char* str, size_t size, const char* format, ...);
#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;
@ -105,18 +87,27 @@ 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
{
uint64_t offset;
tdir_t dirNumber;
};
typedef struct TIFFOffsetAndDirNumber TIFFOffsetAndDirNumber;
struct tiff
{
char *tif_name; /* name of open file */ char *tif_name; /* name of open file */
int tif_fd; /* open file descriptor */ int tif_fd; /* open file descriptor */
int tif_mode; /* open mode (O_*) */ int tif_mode; /* open mode (O_*) */
uint32 tif_flags; uint32_t tif_flags;
#define TIFF_FILLORDER 0x00003U /* natural bit fill order for machine */ #define TIFF_FILLORDER 0x00003U /* natural bit fill order for machine */
#define TIFF_DIRTYHEADER 0x00004U /* header must be written on close */ #define TIFF_DIRTYHEADER 0x00004U /* header must be written on close */
#define TIFF_DIRTYDIRECT 0x00008U /* current directory must be written */ #define TIFF_DIRTYDIRECT 0x00008U /* current directory must be written */
@ -132,41 +123,56 @@ struct tiff {
#define TIFF_INSUBIFD 0x02000U /* currently writing a subifd */ #define TIFF_INSUBIFD 0x02000U /* currently writing a subifd */
#define TIFF_UPSAMPLED 0x04000U /* library is doing data up-sampling */ #define TIFF_UPSAMPLED 0x04000U /* library is doing data up-sampling */
#define TIFF_STRIPCHOP 0x08000U /* enable strip chopping support */ #define TIFF_STRIPCHOP 0x08000U /* enable strip chopping support */
#define TIFF_HEADERONLY 0x10000U /* read header only, do not process the first directory */ #define TIFF_HEADERONLY \
#define TIFF_NOREADRAW 0x20000U /* skip reading of raw uncompressed image data */ 0x10000U /* read header only, do not process the first directory */
#define TIFF_NOREADRAW \
0x20000U /* skip reading of raw uncompressed image data */
#define TIFF_INCUSTOMIFD 0x40000U /* currently writing a custom IFD */ #define TIFF_INCUSTOMIFD 0x40000U /* currently writing a custom IFD */
#define TIFF_BIGTIFF 0x80000U /* read/write bigtiff */ #define TIFF_BIGTIFF 0x80000U /* read/write bigtiff */
#define TIFF_BUF4WRITE 0x100000U /* rawcc bytes are for writing */ #define TIFF_BUF4WRITE 0x100000U /* rawcc bytes are for writing */
#define TIFF_DIRTYSTRIP 0x200000U /* stripoffsets/stripbytecount dirty*/ #define TIFF_DIRTYSTRIP 0x200000U /* stripoffsets/stripbytecount dirty*/
#define TIFF_PERSAMPLE 0x400000U /* get/set per sample tags as arrays */ #define TIFF_PERSAMPLE 0x400000U /* get/set per sample tags as arrays */
#define TIFF_BUFFERMMAP 0x800000U /* read buffer (tif_rawdata) points into mmap() memory */ #define TIFF_BUFFERMMAP \
#define TIFF_DEFERSTRILELOAD 0x1000000U /* defer strip/tile offset/bytecount array loading. */ 0x800000U /* read buffer (tif_rawdata) points into mmap() memory */
#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 */ #define TIFF_DEFERSTRILELOAD \
#define TIFF_CHOPPEDUPARRAYS 0x4000000U /* set when allocChoppedUpStripArrays() has modified strip array */ 0x1000000U /* defer strip/tile offset/bytecount array loading. */
uint64 tif_diroff; /* file offset of current directory */ #define TIFF_LAZYSTRILELOAD \
uint64 tif_nextdiroff; /* file offset of following directory */ 0x2000000U /* lazy/ondemand loading of strip/tile offset/bytecount values. \
uint64* tif_dirlist; /* list of offsets to already seen directories to prevent IFD looping */ Only used if TIFF_DEFERSTRILELOAD is set and in read-only \
uint16 tif_dirlistsize; /* number of entries in offset list */ mode */
uint16 tif_dirnumber; /* number of already seen directories */ #define TIFF_CHOPPEDUPARRAYS \
0x4000000U /* set when allocChoppedUpStripArrays() has modified strip \
array */
uint64_t tif_diroff; /* file offset of current directory */
uint64_t tif_nextdiroff; /* file offset of following directory */
uint64_t tif_lastdiroff; /* file offset of last directory written so far */
TIFFHashSet *tif_map_dir_offset_to_number;
TIFFHashSet *tif_map_dir_number_to_offset;
int tif_setdirectory_force_absolute; /* switch between relative and absolute
stepping in TIFFSetDirectory() */
TIFFDirectory tif_dir; /* internal rep of current directory */ TIFFDirectory tif_dir; /* internal rep of current directory */
TIFFDirectory tif_customdir; /* custom IFDs are separated from the main ones */ TIFFDirectory
union { tif_customdir; /* custom IFDs are separated from the main ones */
union
{
TIFFHeaderCommon common; TIFFHeaderCommon common;
TIFFHeaderClassic classic; TIFFHeaderClassic classic;
TIFFHeaderBig big; TIFFHeaderBig big;
} tif_header; } tif_header;
uint16 tif_header_size; /* file's header block and its length */ uint16_t tif_header_size; /* file's header block and its length */
uint32 tif_row; /* current scanline */ uint32_t tif_row; /* current scanline */
uint16 tif_curdir; /* current directory (index) */ tdir_t tif_curdir; /* current directory (index) */
uint32 tif_curstrip; /* current strip for read/write */ uint32_t tif_curstrip; /* current strip for read/write */
uint64 tif_curoff; /* current offset for read/write */ uint64_t tif_curoff; /* current offset for read/write */
uint64 tif_dataoff; /* current offset for writing dir */ uint64_t tif_lastvalidoff; /* last valid offset allowed for rewrite in
place. Used only by TIFFAppendToStrip() */
uint64_t tif_dataoff; /* current offset for writing dir */
/* SubIFD support */ /* SubIFD support */
uint16 tif_nsubifd; /* remaining subifds to write */ uint16_t tif_nsubifd; /* remaining subifds to write */
uint64 tif_subifdoff; /* offset for patching SubIFD link */ uint64_t tif_subifdoff; /* offset for patching SubIFD link */
/* tiling support */ /* tiling support */
uint32 tif_col; /* current column (offset by row too) */ uint32_t tif_col; /* current column (offset by row too) */
uint32 tif_curtile; /* current tile for read/write */ uint32_t tif_curtile; /* current tile for read/write */
tmsize_t tif_tilesize; /* # of bytes in a tile */ tmsize_t tif_tilesize; /* # of bytes in a tile */
/* compression scheme hooks */ /* compression scheme hooks */
int tif_decodestatus; int tif_decodestatus;
@ -188,18 +194,18 @@ struct tiff {
TIFFVoidMethod tif_cleanup; /* cleanup state routine */ TIFFVoidMethod tif_cleanup; /* cleanup state routine */
TIFFStripMethod tif_defstripsize; /* calculate/constrain strip size */ TIFFStripMethod tif_defstripsize; /* calculate/constrain strip size */
TIFFTileMethod tif_deftilesize; /* calculate/constrain tile size */ TIFFTileMethod tif_deftilesize; /* calculate/constrain tile size */
uint8* tif_data; /* compression scheme private data */ uint8_t *tif_data; /* compression scheme private data */
/* input/output buffering */ /* input/output buffering */
tmsize_t tif_scanlinesize; /* # of bytes in a scanline */ tmsize_t tif_scanlinesize; /* # of bytes in a scanline */
tmsize_t tif_scanlineskew; /* scanline skew for reading strips */ tmsize_t tif_scanlineskew; /* scanline skew for reading strips */
uint8* tif_rawdata; /* raw data buffer */ uint8_t *tif_rawdata; /* raw data buffer */
tmsize_t tif_rawdatasize; /* # of bytes in raw data buffer */ tmsize_t tif_rawdatasize; /* # of bytes in raw data buffer */
tmsize_t tif_rawdataoff; /* rawdata offset within strip */ tmsize_t tif_rawdataoff; /* rawdata offset within strip */
tmsize_t tif_rawdataloaded; /* amount of data in rawdata */ tmsize_t tif_rawdataloaded; /* amount of data in rawdata */
uint8* tif_rawcp; /* current spot in raw buffer */ uint8_t *tif_rawcp; /* current spot in raw buffer */
tmsize_t tif_rawcc; /* bytes unread from raw buffer */ tmsize_t tif_rawcc; /* bytes unread from raw buffer */
/* memory-mapped file support */ /* memory-mapped file support */
uint8* tif_base; /* base of mapped file */ uint8_t *tif_base; /* base of mapped file */
tmsize_t tif_size; /* size of mapped file region (bytes, thus tmsize_t) */ tmsize_t tif_size; /* size of mapped file region (bytes, thus tmsize_t) */
TIFFMapFileProc tif_mapproc; /* map file method */ TIFFMapFileProc tif_mapproc; /* map file method */
TIFFUnmapFileProc tif_unmapproc; /* unmap file method */ TIFFUnmapFileProc tif_unmapproc; /* unmap file method */
@ -222,6 +228,21 @@ struct tiff {
* setting up an old tag extension scheme. */ * setting up an old tag extension scheme. */
TIFFFieldArray *tif_fieldscompat; TIFFFieldArray *tif_fieldscompat;
size_t tif_nfieldscompat; 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 */
};
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 isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */
@ -236,10 +257,8 @@ struct tiff {
((*(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) \
((*(tif)->tif_sizeproc)((tif)->tif_clientdata))
#define TIFFMapFileContents(tif, paddr, psize) \ #define TIFFMapFileContents(tif, paddr, psize) \
((*(tif)->tif_mapproc)((tif)->tif_clientdata, (paddr), (psize))) ((*(tif)->tif_mapproc)((tif)->tif_clientdata, (paddr), (psize)))
#define TIFFUnmapFileContents(tif, addr, size) \ #define TIFFUnmapFileContents(tif, addr, size) \
@ -249,33 +268,40 @@ struct tiff {
* 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 TIFFhowmany8_32(x) \
(((x)&0x07) ? ((uint32_t)(x) >> 3) + 1 : (uint32_t)(x) >> 3)
#define TIFFroundup_32(x, y) (TIFFhowmany_32(x, y) * (y)) #define TIFFroundup_32(x, y) (TIFFhowmany_32(x, y) * (y))
#define TIFFhowmany_64(x, y) ((((uint64)(x))+(((uint64)(y))-1))/((uint64)(y))) #define TIFFhowmany_64(x, y) \
#define TIFFhowmany8_64(x) (((x)&0x07)?((uint64)(x)>>3)+1:(uint64)(x)>>3) ((((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)) #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))
@ -305,16 +331,19 @@ struct tiff {
#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
@ -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,43 +369,53 @@ 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 _TIFFNoSeek(TIFF *tif, uint32_t off);
extern void _TIFFSwab16BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
extern void _TIFFSwab24BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
extern void _TIFFSwab32BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
extern void _TIFFSwab64BitData(TIFF *tif, uint8_t *buf, tmsize_t cc);
extern int TIFFFlushData1(TIFF *tif); extern int TIFFFlushData1(TIFF *tif);
extern int TIFFDefaultDirectory(TIFF *tif); extern int TIFFDefaultDirectory(TIFF *tif);
extern void _TIFFSetDefaultCompressionState(TIFF *tif); extern void _TIFFSetDefaultCompressionState(TIFF *tif);
extern int _TIFFRewriteField(TIFF *, uint16, TIFFDataType, tmsize_t, void *); extern int _TIFFRewriteField(TIFF *, uint16_t, TIFFDataType, tmsize_t,
void *);
extern int TIFFSetCompressionScheme(TIFF *tif, int scheme); extern int TIFFSetCompressionScheme(TIFF *tif, int scheme);
extern int TIFFSetDefaultCompressionState(TIFF *tif); extern int TIFFSetDefaultCompressionState(TIFF *tif);
extern uint32 _TIFFDefaultStripSize(TIFF* tif, uint32 s); extern uint32_t _TIFFDefaultStripSize(TIFF *tif, uint32_t s);
extern void _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th); extern void _TIFFDefaultTileSize(TIFF *tif, uint32_t *tw, uint32_t *th);
extern int _TIFFDataSize(TIFFDataType type);
/*--: 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 _TIFFsetByteArray(void**, void*, uint32); extern void _TIFFsetShortArrayExt(TIFF *, uint16_t **, const uint16_t *,
extern void _TIFFsetString(char**, char*); uint32_t);
extern void _TIFFsetShortArray(uint16**, uint16*, uint32); extern void _TIFFsetLongArray(uint32_t **, const uint32_t *, uint32_t);
extern void _TIFFsetLongArray(uint32**, uint32*, uint32); extern void _TIFFsetLongArrayExt(TIFF *, uint32_t **, const uint32_t *,
extern void _TIFFsetFloatArray(float**, float*, uint32); uint32_t);
extern void _TIFFsetDoubleArray(double**, double*, uint32); extern void _TIFFsetFloatArray(float **, const float *, uint32_t);
extern void _TIFFsetFloatArrayExt(TIFF *, float **, const float *,
uint32_t);
extern void _TIFFsetDoubleArray(double **, const double *, uint32_t);
extern void _TIFFsetDoubleArrayExt(TIFF *, double **, const double *,
uint32_t);
extern void _TIFFprintAscii(FILE *, const char *); extern void _TIFFprintAscii(FILE *, const char *);
extern void _TIFFprintAsciiTag(FILE *, const char *, const char *); extern void _TIFFprintAsciiTag(FILE *, const char *, const char *);
@ -384,31 +424,40 @@ extern TIFFErrorHandler _TIFFwarningHandler;
extern TIFFErrorHandler _TIFFerrorHandler; extern TIFFErrorHandler _TIFFerrorHandler;
extern TIFFErrorHandlerExt _TIFFwarningHandlerExt; extern TIFFErrorHandlerExt _TIFFwarningHandlerExt;
extern TIFFErrorHandlerExt _TIFFerrorHandlerExt; extern TIFFErrorHandlerExt _TIFFerrorHandlerExt;
void _TIFFErrorEarly(TIFFOpenOptions *opts, thandle_t clientdata,
const char *module, const char *fmt, ...)
TIFF_ATTRIBUTE((__format__(__printf__, 4, 5)));
extern uint32 _TIFFMultiply32(TIFF*, uint32, uint32, const char*); extern uint32_t _TIFFMultiply32(TIFF *, uint32_t, uint32_t, const char *);
extern uint64 _TIFFMultiply64(TIFF*, uint64, uint64, const char*); extern uint64_t _TIFFMultiply64(TIFF *, uint64_t, uint64_t, const char *);
extern tmsize_t _TIFFMultiplySSize(TIFF*, tmsize_t, tmsize_t, const char*); extern tmsize_t _TIFFMultiplySSize(TIFF *, tmsize_t, tmsize_t,
extern tmsize_t _TIFFCastUInt64ToSSize(TIFF*, uint64, const char*); const char *);
extern tmsize_t _TIFFCastUInt64ToSSize(TIFF *, uint64_t, const char *);
extern void *_TIFFCheckMalloc(TIFF *, tmsize_t, tmsize_t, const char *); extern void *_TIFFCheckMalloc(TIFF *, tmsize_t, tmsize_t, const char *);
extern void* _TIFFCheckRealloc(TIFF*, void*, tmsize_t, tmsize_t, const char*); extern void *_TIFFCheckRealloc(TIFF *, void *, tmsize_t, tmsize_t,
const char *);
extern double _TIFFUInt64ToDouble(uint64); extern double _TIFFUInt64ToDouble(uint64_t);
extern float _TIFFUInt64ToFloat(uint64); extern float _TIFFUInt64ToFloat(uint64_t);
extern float _TIFFClampDoubleToFloat(double); extern float _TIFFClampDoubleToFloat(double);
extern uint32_t _TIFFClampDoubleToUInt32(double);
extern tmsize_t extern void _TIFFCleanupIFDOffsetAndNumberMaps(TIFF *tif);
_TIFFReadEncodedStripAndAllocBuffer(TIFF* tif, uint32 strip,
void **buf, tmsize_t bufsizetoalloc, extern tmsize_t _TIFFReadEncodedStripAndAllocBuffer(TIFF *tif,
uint32_t strip,
void **buf,
tmsize_t bufsizetoalloc,
tmsize_t size_to_read); tmsize_t size_to_read);
extern tmsize_t extern tmsize_t _TIFFReadEncodedTileAndAllocBuffer(TIFF *tif, uint32_t tile,
_TIFFReadEncodedTileAndAllocBuffer(TIFF* tif, uint32 tile, void **buf,
void **buf, tmsize_t bufsizetoalloc, tmsize_t bufsizetoalloc,
tmsize_t size_to_read); tmsize_t size_to_read);
extern tmsize_t extern tmsize_t _TIFFReadTileAndAllocBuffer(TIFF *tif, void **buf,
_TIFFReadTileAndAllocBuffer(TIFF* tif, tmsize_t bufsizetoalloc,
void **buf, tmsize_t bufsizetoalloc, uint32_t x, uint32_t y,
uint32 x, uint32 y, uint32 z, uint16 s); uint32_t z, uint16_t s);
extern int _TIFFSeekOK(TIFF *tif, toff_t off); extern int _TIFFSeekOK(TIFF *tif, toff_t off);
extern int TIFFInitDumpMode(TIFF *, int); extern int TIFFInitDumpMode(TIFF *, int);
@ -447,6 +496,9 @@ extern int TIFFInitPixarLog(TIFF*, int);
#ifdef LOGLUV_SUPPORT #ifdef LOGLUV_SUPPORT
extern int TIFFInitSGILog(TIFF *, int); extern int TIFFInitSGILog(TIFF *, int);
#endif #endif
#ifdef LERC_SUPPORT
extern int TIFFInitLERC(TIFF *tif, int);
#endif
#ifdef LZMA_SUPPORT #ifdef LZMA_SUPPORT
extern int TIFFInitLZMA(TIFF *, int); extern int TIFFInitLZMA(TIFF *, int);
#endif #endif
@ -456,22 +508,16 @@ extern int TIFFInitZSTD(TIFF*, int);
#ifdef WEBP_SUPPORT #ifdef WEBP_SUPPORT
extern int TIFFInitWebP(TIFF *, int); extern int TIFFInitWebP(TIFF *, int);
#endif #endif
#ifdef VMS
extern const TIFFCodec _TIFFBuiltinCODECS[]; extern const TIFFCodec _TIFFBuiltinCODECS[];
#else extern void TIFFCIELab16ToXYZ(TIFFCIELabToRGB *, uint32_t l, int32_t a,
extern TIFFCodec _TIFFBuiltinCODECS[]; int32_t b, float *, float *, float *);
#endif
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 */

253
3rdparty/libtiff/uvcode.h vendored
View File

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