vendor: OpenCV 5.0.0 snapshot at 40738fb16ceddb5fb3fea747585f7ce6abb0605b
This commit is contained in:
Gitea Mirror Bot
Vendored
+945
@@ -0,0 +1,945 @@
|
||||
/*
|
||||
* Copyright (c) 1988-1997 Sam Leffler
|
||||
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
|
||||
*
|
||||
* Permission to use, copy, modify, distribute, and sell this software and
|
||||
* its documentation for any purpose is hereby granted without fee, provided
|
||||
* that (i) the above copyright notices and this permission notice appear in
|
||||
* all copies of the software and related documentation, and (ii) the names of
|
||||
* Sam Leffler and Silicon Graphics may not be used in any advertising or
|
||||
* publicity relating to the software without the specific, prior written
|
||||
* permission of Sam Leffler and Silicon Graphics.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
|
||||
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
|
||||
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
|
||||
*
|
||||
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
|
||||
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
|
||||
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
|
||||
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
||||
* OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* TIFF Library.
|
||||
*/
|
||||
|
||||
#ifdef TIFF_DO_NOT_USE_NON_EXT_ALLOC_FUNCTIONS
|
||||
#undef TIFF_DO_NOT_USE_NON_EXT_ALLOC_FUNCTIONS
|
||||
#endif
|
||||
|
||||
#include "tiffiop.h"
|
||||
#include <assert.h>
|
||||
#include <limits.h>
|
||||
|
||||
/*
|
||||
* Dummy functions to fill the omitted client procedures.
|
||||
*/
|
||||
int _tiffDummyMapProc(thandle_t fd, void **pbase, toff_t *psize)
|
||||
{
|
||||
(void)fd;
|
||||
(void)pbase;
|
||||
(void)psize;
|
||||
return (0);
|
||||
}
|
||||
|
||||
void _tiffDummyUnmapProc(thandle_t fd, void *base, toff_t size)
|
||||
{
|
||||
(void)fd;
|
||||
(void)base;
|
||||
(void)size;
|
||||
}
|
||||
|
||||
int _TIFFgetMode(TIFFOpenOptions *opts, thandle_t clientdata, const char *mode,
|
||||
const char *module)
|
||||
{
|
||||
int m = -1;
|
||||
|
||||
switch (mode[0])
|
||||
{
|
||||
case 'r':
|
||||
m = O_RDONLY;
|
||||
if (mode[1] == '+')
|
||||
m = O_RDWR;
|
||||
break;
|
||||
case 'w':
|
||||
case 'a':
|
||||
m = O_RDWR | O_CREAT;
|
||||
if (mode[0] == 'w')
|
||||
m |= O_TRUNC;
|
||||
break;
|
||||
default:
|
||||
_TIFFErrorEarly(opts, clientdata, module, "\"%s\": Bad mode", mode);
|
||||
break;
|
||||
}
|
||||
return (m);
|
||||
}
|
||||
|
||||
TIFFOpenOptions *TIFFOpenOptionsAlloc()
|
||||
{
|
||||
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, which is the default, no other limit
|
||||
* that the underlying _TIFFmalloc() or
|
||||
* TIFFOpenOptionsSetMaxCumulatedMemAlloc() will be applied.
|
||||
*/
|
||||
void TIFFOpenOptionsSetMaxSingleMemAlloc(TIFFOpenOptions *opts,
|
||||
tmsize_t max_single_mem_alloc)
|
||||
{
|
||||
opts->max_single_mem_alloc = max_single_mem_alloc;
|
||||
}
|
||||
|
||||
/** Define a limit in bytes for the cumulated memory allocations done by libtiff
|
||||
* on a given TIFF handle.
|
||||
* If max_cumulated_mem_alloc is set to 0, which is the default, no other limit
|
||||
* that the underlying _TIFFmalloc() or
|
||||
* TIFFOpenOptionsSetMaxSingleMemAlloc() will be applied.
|
||||
*/
|
||||
void TIFFOpenOptionsSetMaxCumulatedMemAlloc(TIFFOpenOptions *opts,
|
||||
tmsize_t max_cumulated_mem_alloc)
|
||||
{
|
||||
opts->max_cumulated_mem_alloc = max_cumulated_mem_alloc;
|
||||
}
|
||||
|
||||
/** Whether a warning should be emitted when encountering a unknown tag.
|
||||
* Default is FALSE since libtiff 4.7.1
|
||||
*/
|
||||
void TIFFOpenOptionsSetWarnAboutUnknownTags(TIFFOpenOptions *opts,
|
||||
int warn_about_unknown_tags)
|
||||
{
|
||||
opts->warn_about_unknown_tags = warn_about_unknown_tags;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
static void _TIFFEmitErrorAboveMaxCumulatedMemAlloc(TIFF *tif,
|
||||
const char *pszFunction,
|
||||
tmsize_t s)
|
||||
{
|
||||
TIFFErrorExtR(tif, pszFunction,
|
||||
"Cumulated memory allocation of %" PRIu64 " + %" PRIu64
|
||||
" bytes is beyond the %" PRIu64
|
||||
" cumulated byte limit defined in open options",
|
||||
(uint64_t)tif->tif_cur_cumulated_mem_alloc, (uint64_t)s,
|
||||
(uint64_t)tif->tif_max_cumulated_mem_alloc);
|
||||
}
|
||||
|
||||
/* When allocating memory, we write at the beginning of the buffer it size.
|
||||
* This allows us to keep track of the total memory allocated when we
|
||||
* malloc/calloc/realloc and free. In theory we need just SIZEOF_SIZE_T bytes
|
||||
* for that, but on x86_64, allocations of more than 16 bytes are aligned on
|
||||
* 16 bytes. Hence using 2 * SIZEOF_SIZE_T.
|
||||
* It is critical that _TIFFmallocExt/_TIFFcallocExt/_TIFFreallocExt are
|
||||
* paired with _TIFFfreeExt.
|
||||
* CMakeLists.txt defines TIFF_DO_NOT_USE_NON_EXT_ALLOC_FUNCTIONS, which in
|
||||
* turn disables the definition of the non Ext version in tiffio.h
|
||||
*/
|
||||
#define LEADING_AREA_TO_STORE_ALLOC_SIZE (2 * SIZEOF_SIZE_T)
|
||||
|
||||
/** 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;
|
||||
}
|
||||
if (tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
|
||||
{
|
||||
if (s > tif->tif_max_cumulated_mem_alloc -
|
||||
tif->tif_cur_cumulated_mem_alloc ||
|
||||
s > TIFF_TMSIZE_T_MAX - LEADING_AREA_TO_STORE_ALLOC_SIZE)
|
||||
{
|
||||
_TIFFEmitErrorAboveMaxCumulatedMemAlloc(tif, "_TIFFmallocExt", s);
|
||||
return NULL;
|
||||
}
|
||||
void *ptr = _TIFFmalloc(LEADING_AREA_TO_STORE_ALLOC_SIZE + s);
|
||||
if (!ptr)
|
||||
return NULL;
|
||||
tif->tif_cur_cumulated_mem_alloc += s;
|
||||
memcpy(ptr, &s, sizeof(s));
|
||||
return (char *)ptr + LEADING_AREA_TO_STORE_ALLOC_SIZE;
|
||||
}
|
||||
return _TIFFmalloc(s);
|
||||
}
|
||||
|
||||
/** calloc() version that takes into account memory-specific open options */
|
||||
void *_TIFFcallocExt(TIFF *tif, tmsize_t nmemb, tmsize_t siz)
|
||||
{
|
||||
if (nmemb <= 0 || siz <= 0 || nmemb > TIFF_TMSIZE_T_MAX / siz)
|
||||
return NULL;
|
||||
if (tif != NULL && tif->tif_max_single_mem_alloc > 0)
|
||||
{
|
||||
if (nmemb * siz > tif->tif_max_single_mem_alloc)
|
||||
{
|
||||
_TIFFEmitErrorAboveMaxSingleMemAlloc(tif, "_TIFFcallocExt",
|
||||
nmemb * siz);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
if (tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
|
||||
{
|
||||
const tmsize_t s = nmemb * siz;
|
||||
if (s > tif->tif_max_cumulated_mem_alloc -
|
||||
tif->tif_cur_cumulated_mem_alloc ||
|
||||
s > TIFF_TMSIZE_T_MAX - LEADING_AREA_TO_STORE_ALLOC_SIZE)
|
||||
{
|
||||
_TIFFEmitErrorAboveMaxCumulatedMemAlloc(tif, "_TIFFcallocExt", s);
|
||||
return NULL;
|
||||
}
|
||||
void *ptr = _TIFFcalloc(LEADING_AREA_TO_STORE_ALLOC_SIZE + s, 1);
|
||||
if (!ptr)
|
||||
return NULL;
|
||||
tif->tif_cur_cumulated_mem_alloc += s;
|
||||
memcpy(ptr, &s, sizeof(s));
|
||||
return (char *)ptr + LEADING_AREA_TO_STORE_ALLOC_SIZE;
|
||||
}
|
||||
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;
|
||||
}
|
||||
if (tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
|
||||
{
|
||||
void *oldPtr = p;
|
||||
tmsize_t oldSize = 0;
|
||||
if (p)
|
||||
{
|
||||
oldPtr = (char *)p - LEADING_AREA_TO_STORE_ALLOC_SIZE;
|
||||
memcpy(&oldSize, oldPtr, sizeof(oldSize));
|
||||
assert(oldSize <= tif->tif_cur_cumulated_mem_alloc);
|
||||
}
|
||||
if (s > oldSize &&
|
||||
(s > tif->tif_max_cumulated_mem_alloc -
|
||||
(tif->tif_cur_cumulated_mem_alloc - oldSize) ||
|
||||
s > TIFF_TMSIZE_T_MAX - LEADING_AREA_TO_STORE_ALLOC_SIZE))
|
||||
{
|
||||
_TIFFEmitErrorAboveMaxCumulatedMemAlloc(tif, "_TIFFreallocExt",
|
||||
s - oldSize);
|
||||
return NULL;
|
||||
}
|
||||
void *newPtr =
|
||||
_TIFFrealloc(oldPtr, LEADING_AREA_TO_STORE_ALLOC_SIZE + s);
|
||||
if (newPtr == NULL)
|
||||
return NULL;
|
||||
tif->tif_cur_cumulated_mem_alloc -= oldSize;
|
||||
tif->tif_cur_cumulated_mem_alloc += s;
|
||||
memcpy(newPtr, &s, sizeof(s));
|
||||
return (char *)newPtr + LEADING_AREA_TO_STORE_ALLOC_SIZE;
|
||||
}
|
||||
return _TIFFrealloc(p, s);
|
||||
}
|
||||
|
||||
/** free() version that takes into account memory-specific open options */
|
||||
void _TIFFfreeExt(TIFF *tif, void *p)
|
||||
{
|
||||
if (p != NULL && tif != NULL && tif->tif_max_cumulated_mem_alloc > 0)
|
||||
{
|
||||
void *oldPtr = (char *)p - LEADING_AREA_TO_STORE_ALLOC_SIZE;
|
||||
tmsize_t oldSize;
|
||||
memcpy(&oldSize, oldPtr, sizeof(oldSize));
|
||||
assert(oldSize <= tif->tif_cur_cumulated_mem_alloc);
|
||||
tif->tif_cur_cumulated_mem_alloc -= oldSize;
|
||||
p = oldPtr;
|
||||
}
|
||||
_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;
|
||||
int m;
|
||||
const char *cp;
|
||||
|
||||
/* The following are configuration checks. They should be redundant, but
|
||||
* should not compile to any actual code in an optimised release build
|
||||
* anyway. If any of them fail, (makefile-based or other) configuration is
|
||||
* not correct */
|
||||
assert(sizeof(uint8_t) == 1);
|
||||
assert(sizeof(int8_t) == 1);
|
||||
assert(sizeof(uint16_t) == 2);
|
||||
assert(sizeof(int16_t) == 2);
|
||||
assert(sizeof(uint32_t) == 4);
|
||||
assert(sizeof(int32_t) == 4);
|
||||
assert(sizeof(uint64_t) == 8);
|
||||
assert(sizeof(int64_t) == 8);
|
||||
{
|
||||
union
|
||||
{
|
||||
uint8_t a8[2];
|
||||
uint16_t a16;
|
||||
} n;
|
||||
n.a8[0] = 1;
|
||||
n.a8[1] = 0;
|
||||
(void)n;
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
assert(n.a16 == 256);
|
||||
#else
|
||||
assert(n.a16 == 1);
|
||||
#endif
|
||||
}
|
||||
|
||||
m = _TIFFgetMode(opts, clientdata, mode, module);
|
||||
if (m == -1)
|
||||
goto bad2;
|
||||
tmsize_t size_to_alloc = (tmsize_t)(sizeof(TIFF) + strlen(name) + 1);
|
||||
if (opts && opts->max_single_mem_alloc > 0 &&
|
||||
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;
|
||||
}
|
||||
if (opts && opts->max_cumulated_mem_alloc > 0 &&
|
||||
size_to_alloc > opts->max_cumulated_mem_alloc)
|
||||
{
|
||||
_TIFFErrorEarly(opts, clientdata, module,
|
||||
"%s: Memory allocation of %" PRIu64
|
||||
" bytes is beyond the %" PRIu64
|
||||
" cumulated byte limit defined in open options",
|
||||
name, (uint64_t)size_to_alloc,
|
||||
(uint64_t)opts->max_cumulated_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;
|
||||
}
|
||||
_TIFFmemset(tif, 0, sizeof(*tif));
|
||||
tif->tif_name = (char *)tif + sizeof(TIFF);
|
||||
strcpy(tif->tif_name, name);
|
||||
tif->tif_mode = m & ~(O_CREAT | O_TRUNC);
|
||||
tif->tif_curdir = TIFF_NON_EXISTENT_DIR_NUMBER; /* non-existent directory */
|
||||
tif->tif_curdircount = TIFF_NON_EXISTENT_DIR_NUMBER;
|
||||
tif->tif_curoff = 0;
|
||||
tif->tif_curstrip = (uint32_t)-1; /* invalid strip */
|
||||
tif->tif_row = (uint32_t)-1; /* read/write pre-increment */
|
||||
tif->tif_clientdata = clientdata;
|
||||
tif->tif_readproc = readproc;
|
||||
tif->tif_writeproc = writeproc;
|
||||
tif->tif_seekproc = seekproc;
|
||||
tif->tif_closeproc = closeproc;
|
||||
tif->tif_sizeproc = sizeproc;
|
||||
tif->tif_mapproc = mapproc ? mapproc : _tiffDummyMapProc;
|
||||
tif->tif_unmapproc = unmapproc ? unmapproc : _tiffDummyUnmapProc;
|
||||
if (opts)
|
||||
{
|
||||
tif->tif_errorhandler = opts->errorhandler;
|
||||
tif->tif_errorhandler_user_data = opts->errorhandler_user_data;
|
||||
tif->tif_warnhandler = opts->warnhandler;
|
||||
tif->tif_warnhandler_user_data = opts->warnhandler_user_data;
|
||||
tif->tif_max_single_mem_alloc = opts->max_single_mem_alloc;
|
||||
tif->tif_max_cumulated_mem_alloc = opts->max_cumulated_mem_alloc;
|
||||
tif->tif_warn_about_unknown_tags = opts->warn_about_unknown_tags;
|
||||
}
|
||||
|
||||
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 */
|
||||
/*
|
||||
* Default is to return data MSB2LSB and enable the
|
||||
* use of memory-mapped files and strip chopping when
|
||||
* a file is opened read-only.
|
||||
*/
|
||||
tif->tif_flags = FILLORDER_MSB2LSB;
|
||||
if (m == O_RDONLY)
|
||||
tif->tif_flags |= TIFF_MAPPED;
|
||||
|
||||
#ifdef STRIPCHOP_DEFAULT
|
||||
if (m == O_RDONLY || m == O_RDWR)
|
||||
tif->tif_flags |= STRIPCHOP_DEFAULT;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Process library-specific flags in the open mode string.
|
||||
* The following flags may be used to control intrinsic library
|
||||
* behavior that may or may not be desirable (usually for
|
||||
* compatibility with some application that claims to support
|
||||
* TIFF but only supports some brain dead idea of what the
|
||||
* vendor thinks TIFF is):
|
||||
*
|
||||
* 'l' use little-endian byte order for creating a file
|
||||
* 'b' use big-endian byte order for creating a file
|
||||
* 'L' read/write information using LSB2MSB bit order
|
||||
* 'B' read/write information using MSB2LSB bit order
|
||||
* 'H' read/write information using host bit order
|
||||
* 'M' enable use of memory-mapped files when supported
|
||||
* 'm' disable use of memory-mapped files
|
||||
* 'C' enable strip chopping support when reading
|
||||
* 'c' disable strip chopping support
|
||||
* 'h' read TIFF header only, do not load the first IFD
|
||||
* '4' ClassicTIFF for creating a file (default)
|
||||
* '8' BigTIFF for creating a file
|
||||
* 'D' enable use of deferred strip/tile offset/bytecount array loading.
|
||||
* 'O' on-demand loading of values instead of whole array loading (implies
|
||||
* D)
|
||||
*
|
||||
* The use of the 'l' and 'b' flags is strongly discouraged.
|
||||
* These flags are provided solely because numerous vendors,
|
||||
* typically on the PC, do not correctly support TIFF; they
|
||||
* only support the Intel little-endian byte order. This
|
||||
* support is not configured by default because it supports
|
||||
* the violation of the TIFF spec that says that readers *MUST*
|
||||
* support both byte orders. It is strongly recommended that
|
||||
* you not use this feature except to deal with busted apps
|
||||
* that write invalid TIFF. And even in those cases you should
|
||||
* bang on the vendors to fix their software.
|
||||
*
|
||||
* The 'L', 'B', and 'H' flags are intended for applications
|
||||
* that can optimize operations on data by using a particular
|
||||
* bit order. By default the library returns data in MSB2LSB
|
||||
* bit order for compatibility with older versions of this
|
||||
* library. Returning data in the bit order of the native CPU
|
||||
* makes the most sense but also requires applications to check
|
||||
* the value of the FillOrder tag; something they probably do
|
||||
* not do right now.
|
||||
*
|
||||
* The 'M' and 'm' flags are provided because some virtual memory
|
||||
* systems exhibit poor behavior when large images are mapped.
|
||||
* These options permit clients to control the use of memory-mapped
|
||||
* files on a per-file basis.
|
||||
*
|
||||
* The 'C' and 'c' flags are provided because the library support
|
||||
* for chopping up large strips into multiple smaller strips is not
|
||||
* application-transparent and as such can cause problems. The 'c'
|
||||
* option permits applications that only want to look at the tags,
|
||||
* for example, to get the unadulterated TIFF tag information.
|
||||
*/
|
||||
for (cp = mode; *cp; cp++)
|
||||
switch (*cp)
|
||||
{
|
||||
case 'b':
|
||||
#ifndef WORDS_BIGENDIAN
|
||||
if (m & O_CREAT)
|
||||
tif->tif_flags |= TIFF_SWAB;
|
||||
#endif
|
||||
break;
|
||||
case 'l':
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
if ((m & O_CREAT))
|
||||
tif->tif_flags |= TIFF_SWAB;
|
||||
#endif
|
||||
break;
|
||||
case 'B':
|
||||
tif->tif_flags =
|
||||
(tif->tif_flags & ~TIFF_FILLORDER) | FILLORDER_MSB2LSB;
|
||||
break;
|
||||
case 'L':
|
||||
tif->tif_flags =
|
||||
(tif->tif_flags & ~TIFF_FILLORDER) | FILLORDER_LSB2MSB;
|
||||
break;
|
||||
case 'H':
|
||||
TIFFWarningExtR(tif, name,
|
||||
"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;
|
||||
case 'M':
|
||||
if (m == O_RDONLY)
|
||||
tif->tif_flags |= TIFF_MAPPED;
|
||||
break;
|
||||
case 'm':
|
||||
if (m == O_RDONLY)
|
||||
tif->tif_flags &= ~TIFF_MAPPED;
|
||||
break;
|
||||
case 'C':
|
||||
if (m == O_RDONLY)
|
||||
tif->tif_flags |= TIFF_STRIPCHOP;
|
||||
break;
|
||||
case 'c':
|
||||
if (m == O_RDONLY)
|
||||
tif->tif_flags &= ~TIFF_STRIPCHOP;
|
||||
break;
|
||||
case 'h':
|
||||
tif->tif_flags |= TIFF_HEADERONLY;
|
||||
break;
|
||||
case '8':
|
||||
if (m & O_CREAT)
|
||||
tif->tif_flags |= TIFF_BIGTIFF;
|
||||
break;
|
||||
case 'D':
|
||||
tif->tif_flags |= TIFF_DEFERSTRILELOAD;
|
||||
break;
|
||||
case 'O':
|
||||
if (m == O_RDONLY)
|
||||
tif->tif_flags |=
|
||||
(TIFF_LAZYSTRILELOAD | TIFF_DEFERSTRILELOAD);
|
||||
break;
|
||||
}
|
||||
|
||||
#ifdef DEFER_STRILE_LOAD
|
||||
/* Compatibility with old DEFER_STRILE_LOAD compilation flag */
|
||||
/* Probably unneeded, since to the best of my knowledge (E. Rouault) */
|
||||
/* GDAL was the only user of this, and will now use the new 'D' flag */
|
||||
tif->tif_flags |= TIFF_DEFERSTRILELOAD;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Read in TIFF header.
|
||||
*/
|
||||
if ((m & O_TRUNC) ||
|
||||
!ReadOK(tif, &tif->tif_header, sizeof(TIFFHeaderClassic)))
|
||||
{
|
||||
if (tif->tif_mode == O_RDONLY)
|
||||
{
|
||||
TIFFErrorExtR(tif, name, "Cannot read TIFF header");
|
||||
goto bad;
|
||||
}
|
||||
/*
|
||||
* Setup header and write.
|
||||
*/
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
tif->tif_header.common.tiff_magic =
|
||||
(tif->tif_flags & TIFF_SWAB) ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
|
||||
#else
|
||||
tif->tif_header.common.tiff_magic =
|
||||
(tif->tif_flags & TIFF_SWAB) ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
|
||||
#endif
|
||||
TIFFHeaderUnion tif_header_swapped;
|
||||
if (!(tif->tif_flags & TIFF_BIGTIFF))
|
||||
{
|
||||
tif->tif_header.common.tiff_version = TIFF_VERSION_CLASSIC;
|
||||
tif->tif_header.classic.tiff_diroff = 0;
|
||||
tif->tif_header_size = sizeof(TIFFHeaderClassic);
|
||||
/* Swapped copy for writing */
|
||||
_TIFFmemcpy(&tif_header_swapped, &tif->tif_header,
|
||||
sizeof(TIFFHeaderUnion));
|
||||
if (tif->tif_flags & TIFF_SWAB)
|
||||
TIFFSwabShort(&tif_header_swapped.common.tiff_version);
|
||||
}
|
||||
else
|
||||
{
|
||||
tif->tif_header.common.tiff_version = TIFF_VERSION_BIG;
|
||||
tif->tif_header.big.tiff_offsetsize = 8;
|
||||
tif->tif_header.big.tiff_unused = 0;
|
||||
tif->tif_header.big.tiff_diroff = 0;
|
||||
tif->tif_header_size = sizeof(TIFFHeaderBig);
|
||||
/* Swapped copy for writing */
|
||||
_TIFFmemcpy(&tif_header_swapped, &tif->tif_header,
|
||||
sizeof(TIFFHeaderUnion));
|
||||
if (tif->tif_flags & TIFF_SWAB)
|
||||
{
|
||||
TIFFSwabShort(&tif_header_swapped.common.tiff_version);
|
||||
TIFFSwabShort(&tif_header_swapped.big.tiff_offsetsize);
|
||||
}
|
||||
}
|
||||
/*
|
||||
* The doc for "fopen" for some STD_C_LIBs says that if you
|
||||
* open a file for modify ("+"), then you must fseek (or
|
||||
* fflush?) between any freads and fwrites. This is not
|
||||
* necessary on most systems, but has been shown to be needed
|
||||
* on Solaris.
|
||||
*/
|
||||
TIFFSeekFile(tif, 0, SEEK_SET);
|
||||
if (!WriteOK(tif, &tif_header_swapped,
|
||||
(tmsize_t)(tif->tif_header_size)))
|
||||
{
|
||||
TIFFErrorExtR(tif, name, "Error writing TIFF header");
|
||||
goto bad;
|
||||
}
|
||||
/*
|
||||
* Setup default directory.
|
||||
*/
|
||||
if (!TIFFDefaultDirectory(tif))
|
||||
goto bad;
|
||||
tif->tif_diroff = 0;
|
||||
tif->tif_lastdiroff = 0;
|
||||
tif->tif_setdirectory_force_absolute = FALSE;
|
||||
/* tif_curdircount = 0 means 'empty file opened for writing, but no IFD
|
||||
* written yet' */
|
||||
tif->tif_curdircount = 0;
|
||||
return (tif);
|
||||
}
|
||||
|
||||
/*
|
||||
* Setup the byte order handling according to the opened file for reading.
|
||||
*/
|
||||
if (tif->tif_header.common.tiff_magic != TIFF_BIGENDIAN &&
|
||||
tif->tif_header.common.tiff_magic != TIFF_LITTLEENDIAN
|
||||
#if MDI_SUPPORT
|
||||
&&
|
||||
#if HOST_BIGENDIAN
|
||||
tif->tif_header.common.tiff_magic != MDI_BIGENDIAN
|
||||
#else
|
||||
tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN
|
||||
#endif
|
||||
)
|
||||
{
|
||||
TIFFErrorExtR(tif, name,
|
||||
"Not a TIFF or MDI file, bad magic number %" PRIu16
|
||||
" (0x%" PRIx16 ")",
|
||||
#else
|
||||
)
|
||||
{
|
||||
TIFFErrorExtR(tif, name,
|
||||
"Not a TIFF file, bad magic number %" PRIu16
|
||||
" (0x%" PRIx16 ")",
|
||||
#endif
|
||||
tif->tif_header.common.tiff_magic,
|
||||
tif->tif_header.common.tiff_magic);
|
||||
goto bad;
|
||||
}
|
||||
if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN)
|
||||
{
|
||||
#ifndef WORDS_BIGENDIAN
|
||||
tif->tif_flags |= TIFF_SWAB;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef WORDS_BIGENDIAN
|
||||
tif->tif_flags |= TIFF_SWAB;
|
||||
#endif
|
||||
}
|
||||
if (tif->tif_flags & TIFF_SWAB)
|
||||
TIFFSwabShort(&tif->tif_header.common.tiff_version);
|
||||
if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC) &&
|
||||
(tif->tif_header.common.tiff_version != TIFF_VERSION_BIG))
|
||||
{
|
||||
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);
|
||||
goto bad;
|
||||
}
|
||||
if (tif->tif_header.common.tiff_version == TIFF_VERSION_CLASSIC)
|
||||
{
|
||||
if (tif->tif_flags & TIFF_SWAB)
|
||||
TIFFSwabLong(&tif->tif_header.classic.tiff_diroff);
|
||||
tif->tif_header_size = sizeof(TIFFHeaderClassic);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!ReadOK(tif,
|
||||
((uint8_t *)(&tif->tif_header) + sizeof(TIFFHeaderClassic)),
|
||||
(sizeof(TIFFHeaderBig) - sizeof(TIFFHeaderClassic))))
|
||||
{
|
||||
TIFFErrorExtR(tif, name, "Cannot read TIFF header");
|
||||
goto bad;
|
||||
}
|
||||
if (tif->tif_flags & TIFF_SWAB)
|
||||
{
|
||||
TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
|
||||
TIFFSwabLong8(&tif->tif_header.big.tiff_diroff);
|
||||
}
|
||||
if (tif->tif_header.big.tiff_offsetsize != 8)
|
||||
{
|
||||
TIFFErrorExtR(tif, name,
|
||||
"Not a TIFF file, bad BigTIFF offsetsize %" PRIu16
|
||||
" (0x%" PRIx16 ")",
|
||||
tif->tif_header.big.tiff_offsetsize,
|
||||
tif->tif_header.big.tiff_offsetsize);
|
||||
goto bad;
|
||||
}
|
||||
if (tif->tif_header.big.tiff_unused != 0)
|
||||
{
|
||||
TIFFErrorExtR(tif, name,
|
||||
"Not a TIFF file, bad BigTIFF unused %" PRIu16
|
||||
" (0x%" PRIx16 ")",
|
||||
tif->tif_header.big.tiff_unused,
|
||||
tif->tif_header.big.tiff_unused);
|
||||
goto bad;
|
||||
}
|
||||
tif->tif_header_size = sizeof(TIFFHeaderBig);
|
||||
tif->tif_flags |= TIFF_BIGTIFF;
|
||||
}
|
||||
tif->tif_flags |= TIFF_MYBUFFER;
|
||||
tif->tif_rawcp = tif->tif_rawdata = 0;
|
||||
tif->tif_rawdatasize = 0;
|
||||
tif->tif_rawdataoff = 0;
|
||||
tif->tif_rawdataloaded = 0;
|
||||
|
||||
switch (mode[0])
|
||||
{
|
||||
case 'r':
|
||||
if (!(tif->tif_flags & TIFF_BIGTIFF))
|
||||
tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff;
|
||||
else
|
||||
tif->tif_nextdiroff = tif->tif_header.big.tiff_diroff;
|
||||
/*
|
||||
* Try to use a memory-mapped file if the client
|
||||
* has not explicitly suppressed usage with the
|
||||
* 'm' flag in the open mode (see above).
|
||||
*/
|
||||
if (tif->tif_flags & TIFF_MAPPED)
|
||||
{
|
||||
toff_t n;
|
||||
if (TIFFMapFileContents(tif, (void **)(&tif->tif_base), &n))
|
||||
{
|
||||
tif->tif_size = (tmsize_t)n;
|
||||
assert((toff_t)tif->tif_size == n);
|
||||
}
|
||||
else
|
||||
tif->tif_flags &= ~TIFF_MAPPED;
|
||||
}
|
||||
/*
|
||||
* Sometimes we do not want to read the first directory (for
|
||||
* example, it may be broken) and want to proceed to other
|
||||
* directories. I this case we use the TIFF_HEADERONLY flag to open
|
||||
* file and return immediately after reading TIFF header.
|
||||
* However, the pointer to TIFFSetField() and TIFFGetField()
|
||||
* (i.e. tif->tif_tagmethods.vsetfield and
|
||||
* tif->tif_tagmethods.vgetfield) need to be initialized, which is
|
||||
* done in TIFFDefaultDirectory().
|
||||
*/
|
||||
if (tif->tif_flags & TIFF_HEADERONLY)
|
||||
{
|
||||
if (!TIFFDefaultDirectory(tif))
|
||||
goto bad;
|
||||
return (tif);
|
||||
}
|
||||
|
||||
/*
|
||||
* Setup initial directory.
|
||||
*/
|
||||
if (TIFFReadDirectory(tif))
|
||||
{
|
||||
return (tif);
|
||||
}
|
||||
break;
|
||||
case 'a':
|
||||
/*
|
||||
* New directories are automatically append
|
||||
* to the end of the directory chain when they
|
||||
* are written out (see TIFFWriteDirectory).
|
||||
*/
|
||||
if (!TIFFDefaultDirectory(tif))
|
||||
goto bad;
|
||||
return (tif);
|
||||
}
|
||||
bad:
|
||||
tif->tif_mode = O_RDONLY; /* XXX avoid flush */
|
||||
TIFFCleanup(tif);
|
||||
bad2:
|
||||
return ((TIFF *)0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Query functions to access private data.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Return open file's name.
|
||||
*/
|
||||
const char *TIFFFileName(TIFF *tif) { return (tif->tif_name); }
|
||||
|
||||
/*
|
||||
* Set the file name.
|
||||
*/
|
||||
const char *TIFFSetFileName(TIFF *tif, const char *name)
|
||||
{
|
||||
const char *old_name = tif->tif_name;
|
||||
tif->tif_name = (char *)name;
|
||||
return (old_name);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return open file's I/O descriptor.
|
||||
*/
|
||||
int TIFFFileno(TIFF *tif) { return (tif->tif_fd); }
|
||||
|
||||
/*
|
||||
* Set open file's I/O descriptor, and return previous value.
|
||||
*/
|
||||
int TIFFSetFileno(TIFF *tif, int fd)
|
||||
{
|
||||
int old_fd = tif->tif_fd;
|
||||
tif->tif_fd = fd;
|
||||
return old_fd;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return open file's clientdata.
|
||||
*/
|
||||
thandle_t TIFFClientdata(TIFF *tif) { return (tif->tif_clientdata); }
|
||||
|
||||
/*
|
||||
* Set open file's clientdata, and return previous value.
|
||||
*/
|
||||
thandle_t TIFFSetClientdata(TIFF *tif, thandle_t newvalue)
|
||||
{
|
||||
thandle_t m = tif->tif_clientdata;
|
||||
tif->tif_clientdata = newvalue;
|
||||
return m;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return read/write mode.
|
||||
*/
|
||||
int TIFFGetMode(TIFF *tif) { return (tif->tif_mode); }
|
||||
|
||||
/*
|
||||
* Return read/write mode.
|
||||
*/
|
||||
int TIFFSetMode(TIFF *tif, int mode)
|
||||
{
|
||||
int old_mode = tif->tif_mode;
|
||||
tif->tif_mode = mode;
|
||||
return (old_mode);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return nonzero if file is organized in
|
||||
* tiles; zero if organized as strips.
|
||||
*/
|
||||
int TIFFIsTiled(TIFF *tif) { return (isTiled(tif)); }
|
||||
|
||||
/*
|
||||
* Return current row being read/written.
|
||||
*/
|
||||
uint32_t TIFFCurrentRow(TIFF *tif) { return (tif->tif_row); }
|
||||
|
||||
/*
|
||||
* Return index of the current directory.
|
||||
*/
|
||||
tdir_t TIFFCurrentDirectory(TIFF *tif) { return (tif->tif_curdir); }
|
||||
|
||||
/*
|
||||
* Return current strip.
|
||||
*/
|
||||
uint32_t TIFFCurrentStrip(TIFF *tif) { return (tif->tif_curstrip); }
|
||||
|
||||
/*
|
||||
* Return current tile.
|
||||
*/
|
||||
uint32_t TIFFCurrentTile(TIFF *tif) { return (tif->tif_curtile); }
|
||||
|
||||
/*
|
||||
* Return nonzero if the file has byte-swapped data.
|
||||
*/
|
||||
int TIFFIsByteSwapped(TIFF *tif) { return ((tif->tif_flags & TIFF_SWAB) != 0); }
|
||||
|
||||
/*
|
||||
* Return nonzero if the data is returned up-sampled.
|
||||
*/
|
||||
int TIFFIsUpSampled(TIFF *tif) { return (isUpSampled(tif)); }
|
||||
|
||||
/*
|
||||
* Return nonzero if the data is returned in MSB-to-LSB bit order.
|
||||
*/
|
||||
int TIFFIsMSB2LSB(TIFF *tif) { return (isFillOrder(tif, FILLORDER_MSB2LSB)); }
|
||||
|
||||
/*
|
||||
* Return nonzero if given file was written in big-endian order.
|
||||
*/
|
||||
int TIFFIsBigEndian(TIFF *tif)
|
||||
{
|
||||
return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return nonzero if given file is BigTIFF style.
|
||||
*/
|
||||
int TIFFIsBigTIFF(TIFF *tif) { return ((tif->tif_flags & TIFF_BIGTIFF) != 0); }
|
||||
|
||||
/*
|
||||
* Return pointer to file read method.
|
||||
*/
|
||||
TIFFReadWriteProc TIFFGetReadProc(TIFF *tif) { return (tif->tif_readproc); }
|
||||
|
||||
/*
|
||||
* Return pointer to file write method.
|
||||
*/
|
||||
TIFFReadWriteProc TIFFGetWriteProc(TIFF *tif) { return (tif->tif_writeproc); }
|
||||
|
||||
/*
|
||||
* Return pointer to file seek method.
|
||||
*/
|
||||
TIFFSeekProc TIFFGetSeekProc(TIFF *tif) { return (tif->tif_seekproc); }
|
||||
|
||||
/*
|
||||
* Return pointer to file close method.
|
||||
*/
|
||||
TIFFCloseProc TIFFGetCloseProc(TIFF *tif) { return (tif->tif_closeproc); }
|
||||
|
||||
/*
|
||||
* Return pointer to file size requesting method.
|
||||
*/
|
||||
TIFFSizeProc TIFFGetSizeProc(TIFF *tif) { return (tif->tif_sizeproc); }
|
||||
|
||||
/*
|
||||
* Return pointer to memory mapping method.
|
||||
*/
|
||||
TIFFMapFileProc TIFFGetMapFileProc(TIFF *tif) { return (tif->tif_mapproc); }
|
||||
|
||||
/*
|
||||
* Return pointer to memory unmapping method.
|
||||
*/
|
||||
TIFFUnmapFileProc TIFFGetUnmapFileProc(TIFF *tif)
|
||||
{
|
||||
return (tif->tif_unmapproc);
|
||||
}
|
||||
Reference in New Issue
Block a user