#include "tif_config.h"
#include <fcntl.h>
#include <sys/types.h>
#include <string.h>
#include <assert.h>
#include "tif_hash_set.h"
#include "tiffio.h"
#include "tif_dir.h"
#include <limits.h>

Include dependency graph for tiffiop.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	client_info

struct	TIFFOffsetAndDirNumber

union	TIFFHeaderUnion

struct	tiff

struct	TIFFOpenOptions

Macros
#define	TIFF_NON_EXISTENT_DIR_NUMBER UINT_MAX

#define	streq(a, b) (strcmp(a, b) == 0)

#define	strneq(a, b, n) (strncmp(a, b, n) == 0)

#define	TRUE 1

#define	FALSE 0

#define	TIFF_FILLORDER 0x00003U /* natural bit fill order for machine */

#define	TIFF_DIRTYHEADER 0x00004U /* header must be written on close */

#define	TIFF_DIRTYDIRECT 0x00008U /* current directory must be written */

#define	TIFF_BUFFERSETUP 0x00010U /* data buffers setup */

#define	TIFF_CODERSETUP 0x00020U /* encoder/decoder setup done */

#define	TIFF_BEENWRITING 0x00040U /* written 1+ scanlines to file */

#define	TIFF_SWAB 0x00080U /* byte swap file information */

#define	TIFF_NOBITREV 0x00100U /* inhibit bit reversal logic */

#define	TIFF_MYBUFFER 0x00200U /* my raw data buffer; free on close */

#define	TIFF_ISTILED 0x00400U /* file is tile, not strip- based */

#define	TIFF_MAPPED 0x00800U /* file is mapped into memory */

#define	TIFF_POSTENCODE 0x01000U /* need call to postencode routine */

#define	TIFF_INSUBIFD 0x02000U /* currently writing a subifd */

#define	TIFF_UPSAMPLED 0x04000U /* library is doing data up-sampling */

#define	TIFF_STRIPCHOP 0x08000U /* enable strip chopping support */

#define	TIFF_HEADERONLY 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_BIGTIFF 0x80000U /* read/write bigtiff */

#define	TIFF_BUF4WRITE 0x100000U /* rawcc bytes are for writing */

#define	TIFF_DIRTYSTRIP 0x200000U /* stripoffsets/stripbytecount dirty*/

#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_DEFERSTRILELOAD 0x1000000U /* defer strip/tile offset/bytecount array loading. */

#define	TIFF_LAZYSTRILELOAD

#define	TIFF_CHOPPEDUPARRAYS

#define	isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */

#define	isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0)

#define	isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0)

#define	isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0)

#define	isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0)

#define	TIFFReadFile(tif, buf, size) ((*(tif)->tif_readproc)((tif)->tif_clientdata, (buf), (size)))

#define	TIFFWriteFile(tif, buf, size) ((*(tif)->tif_writeproc)((tif)->tif_clientdata, (buf), (size)))

#define	TIFFSeekFile(tif, off, whence) ((*(tif)->tif_seekproc)((tif)->tif_clientdata, (off), (whence)))

#define	TIFFCloseFile(tif) ((*(tif)->tif_closeproc)((tif)->tif_clientdata))

#define	TIFFGetFileSize(tif) ((*(tif)->tif_sizeproc)((tif)->tif_clientdata))

#define	TIFFMapFileContents(tif, paddr, psize) ((*(tif)->tif_mapproc)((tif)->tif_clientdata, (paddr), (psize)))

#define	TIFFUnmapFileContents(tif, addr, size) ((*(tif)->tif_unmapproc)((tif)->tif_clientdata, (addr), (size)))

#define	ReadOK(tif, buf, size) (TIFFReadFile((tif), (buf), (size)) == (size))

#define	SeekOK(tif, off) _TIFFSeekOK(tif, off)

#define	WriteOK(tif, buf, size) (TIFFWriteFile((tif), (buf), (size)) == (size))

#define	TIFFhowmany_32(x, y)

#define	TIFFhowmany_32_maxuint_compat(x, y)

#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	TIFFhowmany_64(x, y) ((((uint64_t)(x)) + (((uint64_t)(y)) - 1)) / ((uint64_t)(y)))

#define	TIFFhowmany8_64(x) (((x)&0x07) ? ((uint64_t)(x) >> 3) + 1 : (uint64_t)(x) >> 3)

#define	TIFFroundup_64(x, y) (TIFFhowmany_64(x, y) * (y))

#define	TIFFSafeMultiply(t, v, m)

#define	TIFFmax(A, B) ((A) > (B) ? (A) : (B))

#define	TIFFmin(A, B) ((A) < (B) ? (A) : (B))

#define	TIFFArrayCount(a) (sizeof(a) / sizeof((a)[0]))

#define	fseek(stream, offset, whence) fseeko(stream, offset, whence)

#define	ftell(stream, offset, whence) ftello(stream, offset, whence)

#define	_TIFF_lseek_f(fildes, offset, whence) lseek(fildes, offset, whence)

#define	_TIFF_fseek_f(stream, offset, whence) fseek(stream, offset, whence)

#define	_TIFF_fstat_f(fildes, stat_buff) fstat(fildes, stat_buff)

#define	_TIFF_stat_s struct stat

#define	_TIFF_off_t off_t

#define	TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW

Typedefs
typedef struct client_info	TIFFClientInfoLink

typedef unsigned char	tidataval_t

typedef tidataval_t *	tidata_t

typedef void(*	TIFFVoidMethod) (TIFF *)

typedef int(*	TIFFBoolMethod) (TIFF *)

typedef int(*	TIFFPreMethod) (TIFF *, uint16_t)

typedef int(*	TIFFCodeMethod) (TIFF tif, uint8_t buf, tmsize_t size, uint16_t sample)

typedef int(*	TIFFSeekMethod) (TIFF *, uint32_t)

typedef void(*	TIFFPostMethod) (TIFF tif, uint8_t buf, tmsize_t size)

typedef uint32_t(*	TIFFStripMethod) (TIFF *, uint32_t)

typedef void(*	TIFFTileMethod) (TIFF , uint32_t , uint32_t *)

typedef struct TIFFOffsetAndDirNumber	TIFFOffsetAndDirNumber

typedef size_t	TIFFIOSize_t

Functions
int	_tiffDummyMapProc (thandle_t fd, void *pbase, toff_t psize)

void	_tiffDummyUnmapProc (thandle_t fd, void *base, toff_t size)

int	_TIFFgetMode (TIFFOpenOptions opts, thandle_t clientdata, const char mode, const char *module)

int	_TIFFNoRowEncode (TIFF tif, uint8_t pp, tmsize_t cc, uint16_t s)

int	_TIFFNoStripEncode (TIFF tif, uint8_t pp, tmsize_t cc, uint16_t s)

int	_TIFFNoTileEncode (TIFF , uint8_t pp, tmsize_t cc, uint16_t s)

int	_TIFFNoRowDecode (TIFF tif, uint8_t pp, tmsize_t cc, uint16_t s)

int	_TIFFNoStripDecode (TIFF tif, uint8_t pp, tmsize_t cc, uint16_t s)

int	_TIFFNoTileDecode (TIFF , uint8_t pp, tmsize_t cc, uint16_t s)

void	_TIFFNoPostDecode (TIFF tif, uint8_t buf, tmsize_t cc)

int	_TIFFNoPreCode (TIFF *tif, uint16_t s)

int	_TIFFNoSeek (TIFF *tif, uint32_t off)

void	_TIFFSwab16BitData (TIFF tif, uint8_t buf, tmsize_t cc)

void	_TIFFSwab24BitData (TIFF tif, uint8_t buf, tmsize_t cc)

void	_TIFFSwab32BitData (TIFF tif, uint8_t buf, tmsize_t cc)

void	_TIFFSwab64BitData (TIFF tif, uint8_t buf, tmsize_t cc)

int	TIFFFlushData1 (TIFF *tif)

int	TIFFDefaultDirectory (TIFF *tif)

void	_TIFFSetDefaultCompressionState (TIFF *tif)

int	_TIFFRewriteField (TIFF , uint16_t, TIFFDataType, tmsize_t, void )

int	TIFFSetCompressionScheme (TIFF *tif, int scheme)

int	TIFFSetDefaultCompressionState (TIFF *tif)

uint32_t	_TIFFDefaultStripSize (TIFF *tif, uint32_t s)

void	_TIFFDefaultTileSize (TIFF tif, uint32_t tw, uint32_t *th)

void	_TIFFsetByteArray (void *, const void , uint32_t)

void	_TIFFsetByteArrayExt (TIFF , void , const void , uint32_t)

void	_TIFFsetShortArray (uint16_t *, const uint16_t , uint32_t)

void	_TIFFsetShortArrayExt (TIFF , uint16_t , const uint16_t , uint32_t)

void	_TIFFsetLongArray (uint32_t *, const uint32_t , uint32_t)

void	_TIFFsetLongArrayExt (TIFF , uint32_t , const uint32_t , uint32_t)

void	_TIFFsetFloatArray (float *, const float , uint32_t)

void	_TIFFsetFloatArrayExt (TIFF , float , const float , uint32_t)

void	_TIFFsetDoubleArray (double *, const double , uint32_t)

void	_TIFFsetDoubleArrayExt (TIFF , double , const double , uint32_t)

void	_TIFFprintAscii (FILE , const char )

void	_TIFFprintAsciiTag (FILE , const char , const char *)

void	_TIFFErrorEarly (TIFFOpenOptions opts, thandle_t clientdata, const char module, const char *fmt,...) TIFF_ATTRIBUTE((__format__(__printf__

void uint32_t	_TIFFMultiply32 (TIFF , uint32_t, uint32_t, const char )

uint64_t	_TIFFMultiply64 (TIFF , uint64_t, uint64_t, const char )

tmsize_t	_TIFFMultiplySSize (TIFF , tmsize_t, tmsize_t, const char )

tmsize_t	_TIFFCastUInt64ToSSize (TIFF , uint64_t, const char )

void *	_TIFFCheckMalloc (TIFF , tmsize_t, tmsize_t, const char )

void *	_TIFFCheckRealloc (TIFF , void , tmsize_t, tmsize_t, const char *)

float	_TIFFClampDoubleToFloat (double)

uint32_t	_TIFFClampDoubleToUInt32 (double)

void	_TIFFCleanupIFDOffsetAndNumberMaps (TIFF *tif)

tmsize_t	_TIFFReadEncodedStripAndAllocBuffer (TIFF tif, uint32_t strip, void *buf, tmsize_t bufsizetoalloc, tmsize_t size_to_read)

tmsize_t	_TIFFReadEncodedTileAndAllocBuffer (TIFF tif, uint32_t tile, void *buf, tmsize_t bufsizetoalloc, tmsize_t size_to_read)

tmsize_t	_TIFFReadTileAndAllocBuffer (TIFF tif, void *buf, tmsize_t bufsizetoalloc, uint32_t x, uint32_t y, uint32_t z, uint16_t s)

int	_TIFFSeekOK (TIFF *tif, toff_t off)

int	TIFFInitDumpMode (TIFF *, int)

int	TIFFInitPackBits (TIFF *, int)

int	TIFFInitCCITTRLE (TIFF *, int)

int	TIFFInitCCITTRLEW (TIFF *, int)

int	TIFFInitCCITTFax3 (TIFF *, int)

int	TIFFInitCCITTFax4 (TIFF *, int)

int	TIFFInitThunderScan (TIFF *, int)

int	TIFFInitNeXT (TIFF *, int)

int	TIFFInitLZW (TIFF *, int)

int	TIFFInitJPEG (TIFF *, int)

int	TIFFJPEGIsFullStripRequired (TIFF *)

int	TIFFInitZIP (TIFF *, int)

int	TIFFInitPixarLog (TIFF *, int)

int	TIFFInitSGILog (TIFF *, int)

void	TIFFCIELab16ToXYZ (TIFFCIELabToRGB , uint32_t l, int32_t a, int32_t b, float , float , float )

void *	_TIFFmallocExt (TIFF *tif, tmsize_t s)

void *	_TIFFcallocExt (TIFF *tif, tmsize_t nmemb, tmsize_t siz)

void *	_TIFFreallocExt (TIFF tif, void p, tmsize_t s)

void	_TIFFfreeExt (TIFF tif, void p)

Variables
TIFFErrorHandler	_TIFFwarningHandler

TIFFErrorHandler	_TIFFerrorHandler

TIFFErrorHandlerExt	_TIFFwarningHandlerExt

TIFFErrorHandlerExt	_TIFFerrorHandlerExt

const TIFFCodec	_TIFFBuiltinCODECS []

Macro Definition Documentation

◆ _TIFF_fseek_f

#define _TIFF_fseek_f	(	stream,
		offset,
		whence
	)	fseek(stream, offset, whence)

Definition at line 377 of file tiffiop.h.

◆ _TIFF_fstat_f

#define _TIFF_fstat_f	(	fildes,
		stat_buff
	)	fstat(fildes, stat_buff)

Definition at line 378 of file tiffiop.h.

◆ _TIFF_lseek_f

#define _TIFF_lseek_f	(	fildes,
		offset,
		whence
	)	lseek(fildes, offset, whence)

Definition at line 375 of file tiffiop.h.

◆ _TIFF_off_t

#define _TIFF_off_t off_t

Definition at line 382 of file tiffiop.h.

◆ _TIFF_stat_s

#define _TIFF_stat_s struct stat

Definition at line 381 of file tiffiop.h.

◆ FALSE

#define FALSE 0

Definition at line 71 of file tiffiop.h.

◆ fseek

#define fseek	(	stream,
		offset,
		whence
	)	fseeko(stream, offset, whence)

Definition at line 354 of file tiffiop.h.

◆ ftell

#define ftell	(	stream,
		offset,
		whence
	)	ftello(stream, offset, whence)

Definition at line 355 of file tiffiop.h.

◆ isFillOrder

#define isFillOrder	(	tif,
		o
	)	(((tif)->tif_flags & (o)) != 0)

Definition at line 276 of file tiffiop.h.

◆ isMapped

#define isMapped ( tif ) (((tif)->tif_flags & TIFF_MAPPED) != 0)

Definition at line 275 of file tiffiop.h.

◆ isPseudoTag

#define isPseudoTag ( t ) (t > 0xffff) /* is tag value normal or pseudo */

Definition at line 272 of file tiffiop.h.

◆ isTiled

#define isTiled ( tif ) (((tif)->tif_flags & TIFF_ISTILED) != 0)

Definition at line 274 of file tiffiop.h.

◆ isUpSampled

#define isUpSampled ( tif ) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0)

Definition at line 277 of file tiffiop.h.

◆ ReadOK

#define ReadOK	(	tif,
		buf,
		size
	)	(TIFFReadFile((tif), (buf), (size)) == (size))

Definition at line 295 of file tiffiop.h.

◆ SeekOK

#define SeekOK	(	tif,
		off
	)	_TIFFSeekOK(tif, off)

Definition at line 298 of file tiffiop.h.

◆ streq

#define streq	(	a,
		b
	)	(strcmp(a, b) == 0)

Definition at line 66 of file tiffiop.h.

◆ strneq

#define strneq	(	a,
		b,
		n
	)	(strncmp(a, b, n) == 0)

Definition at line 67 of file tiffiop.h.

◆ TIFF_BEENWRITING

#define TIFF_BEENWRITING 0x00040U /* written 1+ scanlines to file */

Definition at line 123 of file tiffiop.h.

◆ TIFF_BIGTIFF

#define TIFF_BIGTIFF 0x80000U /* read/write bigtiff */

Definition at line 138 of file tiffiop.h.

◆ TIFF_BUF4WRITE

#define TIFF_BUF4WRITE 0x100000U /* rawcc bytes are for writing */

Definition at line 139 of file tiffiop.h.

◆ TIFF_BUFFERMMAP

#define TIFF_BUFFERMMAP 0x800000U /* read buffer (tif_rawdata) points into mmap() memory */

Definition at line 142 of file tiffiop.h.

◆ TIFF_BUFFERSETUP

#define TIFF_BUFFERSETUP 0x00010U /* data buffers setup */

Definition at line 121 of file tiffiop.h.

◆ TIFF_CHOPPEDUPARRAYS

#define TIFF_CHOPPEDUPARRAYS

Value:

0x4000000U /* set when allocChoppedUpStripArrays() has modified strip \

array */

Definition at line 148 of file tiffiop.h.

◆ TIFF_CODERSETUP

#define TIFF_CODERSETUP 0x00020U /* encoder/decoder setup done */

Definition at line 122 of file tiffiop.h.

◆ TIFF_DEFERSTRILELOAD

#define TIFF_DEFERSTRILELOAD 0x1000000U /* defer strip/tile offset/bytecount array loading. */

Definition at line 144 of file tiffiop.h.

◆ TIFF_DIRTYDIRECT

#define TIFF_DIRTYDIRECT 0x00008U /* current directory must be written */

Definition at line 120 of file tiffiop.h.

◆ TIFF_DIRTYHEADER

#define TIFF_DIRTYHEADER 0x00004U /* header must be written on close */

Definition at line 119 of file tiffiop.h.

◆ TIFF_DIRTYSTRIP

#define TIFF_DIRTYSTRIP 0x200000U /* stripoffsets/stripbytecount dirty*/

Definition at line 140 of file tiffiop.h.

◆ TIFF_FILLORDER

#define TIFF_FILLORDER 0x00003U /* natural bit fill order for machine */

Definition at line 118 of file tiffiop.h.

◆ TIFF_HEADERONLY

#define TIFF_HEADERONLY 0x10000U /* read header only, do not process the first directory */

Definition at line 133 of file tiffiop.h.

◆ TIFF_INCUSTOMIFD

#define TIFF_INCUSTOMIFD 0x40000U /* currently writing a custom IFD */

Definition at line 137 of file tiffiop.h.

◆ TIFF_INSUBIFD

#define TIFF_INSUBIFD 0x02000U /* currently writing a subifd */

Definition at line 130 of file tiffiop.h.

◆ TIFF_ISTILED

#define TIFF_ISTILED 0x00400U /* file is tile, not strip- based */

Definition at line 127 of file tiffiop.h.

◆ TIFF_LAZYSTRILELOAD

#define TIFF_LAZYSTRILELOAD

Value:

    0x2000000U /* lazy/ondemand loading of strip/tile offset/bytecount values. \
                  Only used if TIFF_DEFERSTRILELOAD is set and in read-only    \
                  mode */

Definition at line 146 of file tiffiop.h.

◆ TIFF_MAPPED

#define TIFF_MAPPED 0x00800U /* file is mapped into memory */

Definition at line 128 of file tiffiop.h.

◆ TIFF_MYBUFFER

#define TIFF_MYBUFFER 0x00200U /* my raw data buffer; free on close */

Definition at line 126 of file tiffiop.h.

◆ TIFF_NOBITREV

#define TIFF_NOBITREV 0x00100U /* inhibit bit reversal logic */

Definition at line 125 of file tiffiop.h.

◆ TIFF_NON_EXISTENT_DIR_NUMBER

#define TIFF_NON_EXISTENT_DIR_NUMBER UINT_MAX

Definition at line 64 of file tiffiop.h.

◆ TIFF_NOREADRAW

#define TIFF_NOREADRAW 0x20000U /* skip reading of raw uncompressed image data */

Definition at line 135 of file tiffiop.h.

◆ TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW

#define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW

Definition at line 393 of file tiffiop.h.

◆ TIFF_PERSAMPLE

#define TIFF_PERSAMPLE 0x400000U /* get/set per sample tags as arrays */

Definition at line 141 of file tiffiop.h.

◆ TIFF_POSTENCODE

#define TIFF_POSTENCODE 0x01000U /* need call to postencode routine */

Definition at line 129 of file tiffiop.h.

◆ TIFF_STRIPCHOP

#define TIFF_STRIPCHOP 0x08000U /* enable strip chopping support */

Definition at line 132 of file tiffiop.h.

◆ TIFF_SWAB

#define TIFF_SWAB 0x00080U /* byte swap file information */

Definition at line 124 of file tiffiop.h.

◆ TIFF_UPSAMPLED

#define TIFF_UPSAMPLED 0x04000U /* library is doing data up-sampling */

Definition at line 131 of file tiffiop.h.

◆ TIFFArrayCount

#define TIFFArrayCount ( a ) (sizeof(a) / sizeof((a)[0]))

Definition at line 333 of file tiffiop.h.

◆ TIFFCloseFile

#define TIFFCloseFile ( tif ) ((*(tif)->tif_closeproc)((tif)->tif_clientdata))

Definition at line 284 of file tiffiop.h.

◆ TIFFGetFileSize

#define TIFFGetFileSize ( tif ) ((*(tif)->tif_sizeproc)((tif)->tif_clientdata))

Definition at line 285 of file tiffiop.h.

◆ TIFFhowmany8_32

#define TIFFhowmany8_32 ( x ) (((x)&0x07) ? ((uint32_t)(x) >> 3) + 1 : (uint32_t)(x) >> 3)

Definition at line 314 of file tiffiop.h.

◆ TIFFhowmany8_64

#define TIFFhowmany8_64 ( x ) (((x)&0x07) ? ((uint64_t)(x) >> 3) + 1 : (uint64_t)(x) >> 3)

Definition at line 319 of file tiffiop.h.

◆ TIFFhowmany_32

#define TIFFhowmany_32	(	x,
		y
	)

Value:

    (((uint32_t)x < (0xffffffff - (uint32_t)(y - 1)))                          \
         ? ((((uint32_t)(x)) + (((uint32_t)(y)) - 1)) / ((uint32_t)(y)))       \
         : 0U)

Definition at line 305 of file tiffiop.h.

◆ TIFFhowmany_32_maxuint_compat

#define TIFFhowmany_32_maxuint_compat	(	x,
		y
	)

Value:

(((uint32_t)(x) / (uint32_t)(y)) + \

((((uint32_t)(x) % (uint32_t)(y)) != 0) ? 1 : 0))

Definition at line 311 of file tiffiop.h.

◆ TIFFhowmany_64

#define TIFFhowmany_64	(	x,
		y
	)	((((uint64_t)(x)) + (((uint64_t)(y)) - 1)) / ((uint64_t)(y)))

Definition at line 317 of file tiffiop.h.

◆ TIFFMapFileContents

#define TIFFMapFileContents	(	tif,
		paddr,
		psize
	)	((*(tif)->tif_mapproc)((tif)->tif_clientdata, (paddr), (psize)))

Definition at line 286 of file tiffiop.h.

◆ TIFFmax

#define TIFFmax	(	A,
		B
	)	((A) > (B) ? (A) : (B))

Definition at line 330 of file tiffiop.h.

◆ TIFFmin

#define TIFFmin	(	A,
		B
	)	((A) < (B) ? (A) : (B))

Definition at line 331 of file tiffiop.h.

◆ TIFFReadFile

#define TIFFReadFile	(	tif,
		buf,
		size
	)	((*(tif)->tif_readproc)((tif)->tif_clientdata, (buf), (size)))

Definition at line 278 of file tiffiop.h.

◆ TIFFroundup_32

#define TIFFroundup_32	(	x,
		y
	)	(TIFFhowmany_32(x, y) * (y))

Definition at line 316 of file tiffiop.h.

◆ TIFFroundup_64

#define TIFFroundup_64	(	x,
		y
	)	(TIFFhowmany_64(x, y) * (y))

Definition at line 321 of file tiffiop.h.

◆ TIFFSafeMultiply

#define TIFFSafeMultiply	(	t,
		v,
		m
	)

Value:

    ((((t)(m) != (t)0) && (((t)(((v) * (m)) / (m))) == (t)(v)))                \
         ? (t)((v) * (m))                                                      \
         : (t)0)

Definition at line 325 of file tiffiop.h.

◆ TIFFSeekFile

#define TIFFSeekFile	(	tif,
		off,
		whence
	)	((*(tif)->tif_seekproc)((tif)->tif_clientdata, (off), (whence)))

Definition at line 282 of file tiffiop.h.

◆ TIFFUnmapFileContents

#define TIFFUnmapFileContents	(	tif,
		addr,
		size
	)	((*(tif)->tif_unmapproc)((tif)->tif_clientdata, (addr), (size)))

Definition at line 288 of file tiffiop.h.

◆ TIFFWriteFile

#define TIFFWriteFile	(	tif,
		buf,
		size
	)	((*(tif)->tif_writeproc)((tif)->tif_clientdata, (buf), (size)))

Definition at line 280 of file tiffiop.h.

◆ TRUE

#define TRUE 1

Definition at line 70 of file tiffiop.h.

◆ WriteOK

#define WriteOK	(	tif,
		buf,
		size
	)	(TIFFWriteFile((tif), (buf), (size)) == (size))

Definition at line 301 of file tiffiop.h.

Typedef Documentation

◆ tidata_t

typedef tidataval_t* tidata_t

Definition at line 86 of file tiffiop.h.

◆ tidataval_t

typedef unsigned char tidataval_t

Definition at line 85 of file tiffiop.h.

◆ TIFFBoolMethod

typedef int(* TIFFBoolMethod) (TIFF *)

Definition at line 89 of file tiffiop.h.

◆ TIFFClientInfoLink

typedef struct client_info TIFFClientInfoLink

◆ TIFFCodeMethod

typedef int(* TIFFCodeMethod) (TIFF *tif, uint8_t *buf, tmsize_t size, uint16_t sample)

Definition at line 91 of file tiffiop.h.

◆ TIFFIOSize_t

typedef size_t TIFFIOSize_t

Definition at line 374 of file tiffiop.h.

◆ TIFFOffsetAndDirNumber

typedef struct TIFFOffsetAndDirNumber TIFFOffsetAndDirNumber

Definition at line 103 of file tiffiop.h.

◆ TIFFPostMethod

typedef void(* TIFFPostMethod) (TIFF *tif, uint8_t *buf, tmsize_t size)

Definition at line 94 of file tiffiop.h.

◆ TIFFPreMethod

typedef int(* TIFFPreMethod) (TIFF *, uint16_t)

Definition at line 90 of file tiffiop.h.

◆ TIFFSeekMethod

typedef int(* TIFFSeekMethod) (TIFF *, uint32_t)

Definition at line 93 of file tiffiop.h.

◆ TIFFStripMethod

typedef uint32_t(* TIFFStripMethod) (TIFF *, uint32_t)

Definition at line 95 of file tiffiop.h.

◆ TIFFTileMethod

typedef void(* TIFFTileMethod) (TIFF *, uint32_t *, uint32_t *)

Definition at line 96 of file tiffiop.h.

◆ TIFFVoidMethod

typedef void(* TIFFVoidMethod) (TIFF *)

Definition at line 88 of file tiffiop.h.

Function Documentation

◆ _TIFFcallocExt()

void * _TIFFcallocExt	(	TIFF *	tif,
		tmsize_t	nmemb,
		tmsize_t	siz
	)

calloc() version that takes into account memory-specific open options

Definition at line 201 of file tif_open.c.

{
    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);
}

Referenced by TIFFReadBufferSetup(), and TIFFReadDirectory().

◆ _TIFFCastUInt64ToSSize()

tmsize_t _TIFFCastUInt64ToSSize	(	TIFF *	tif,
		uint64_t	val,
		const char *	module
	)

Definition at line 84 of file tif_aux.c.

{
    if (val > (uint64_t)TIFF_TMSIZE_T_MAX)
    {
        if (tif != NULL && module != NULL)
        {
            TIFFErrorExtR(tif, module, "Integer overflow");
        }
        return 0;
    }
    return (tmsize_t)val;
}

Referenced by TIFFRasterScanlineSize(), TIFFReadRawStrip(), TIFFReadRawTile(), TIFFScanlineSize(), TIFFStripSize(), TIFFTileRowSize(), TIFFTileSize(), TIFFVStripSize(), and TIFFVTileSize().

◆ _TIFFCheckMalloc()

void * _TIFFCheckMalloc	(	TIFF *	tif,
		tmsize_t	nmemb,
		tmsize_t	elem_size,
		const char *	what
	)

Definition at line 122 of file tif_aux.c.

{
    return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what);
}

Referenced by _TIFFMergeFields(), _TIFFRewriteField(), _TIFFVSetField(), allocChoppedUpStripArrays(), EstimateStripByteCounts(), TIFFFetchDirectory(), TIFFFetchStripThing(), TIFFMergeFieldInfo(), TIFFReadDirEntryArrayWithLimit(), and TIFFSetupStrips().

◆ _TIFFCheckRealloc()

void * _TIFFCheckRealloc	(	TIFF *	tif,
		void *	buffer,
		tmsize_t	nmemb,
		tmsize_t	elem_size,
		const char *	what
	)

Definition at line 97 of file tif_aux.c.

{
    void *cp = NULL;
    tmsize_t count = _TIFFMultiplySSize(tif, nmemb, elem_size, NULL);
    /*
     * Check for integer overflow.
     */
    if (count != 0)
    {
        cp = _TIFFreallocExt(tif, buffer, count);
    }
 
    if (cp == NULL)
    {
        TIFFErrorExtR(tif, tif->tif_name,
                      "Failed to allocate memory for %s "
                      "(%" TIFF_SSIZE_FORMAT " elements of %" TIFF_SSIZE_FORMAT
                      " bytes each)",
                      what, nmemb, elem_size);
    }
 
    return cp;
}

Referenced by _TIFFCheckMalloc(), _TIFFMergeFields(), and TIFFMergeFieldInfo().

◆ _TIFFClampDoubleToFloat()

float _TIFFClampDoubleToFloat ( double val )

Definition at line 391 of file tif_aux.c.

{
    if (val > FLT_MAX)
        return FLT_MAX;
    if (val < -FLT_MAX)
        return -FLT_MAX;
    return (float)val;
}

Referenced by _TIFFVSetField(), and TIFFWriteDirectoryTagSampleformatArray().

◆ _TIFFClampDoubleToUInt32()

uint32_t _TIFFClampDoubleToUInt32 ( double val )

Definition at line 400 of file tif_aux.c.

{
    if (val < 0)
        return 0;
    if (val > 0xFFFFFFFFU || val != val)
        return 0xFFFFFFFFU;
    return (uint32_t)val;
}

◆ _TIFFCleanupIFDOffsetAndNumberMaps()

void _TIFFCleanupIFDOffsetAndNumberMaps ( TIFF * tif )

Definition at line 127 of file tif_close.c.

{
    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;
    }
}

Referenced by TIFFCleanup(), TIFFCreateCustomDirectory(), TIFFSetDirectory(), TIFFSetSubDirectory(), and TIFFUnlinkDirectory().

◆ _TIFFDefaultStripSize()

uint32_t _TIFFDefaultStripSize	(	TIFF *	tif,
		uint32_t	s
	)

Definition at line 223 of file tif_strip.c.

{
    if ((int32_t)s < 1)
    {
        /*
         * If RowsPerStrip is unspecified, try to break the
         * image up into strips that are approximately
         * STRIP_SIZE_DEFAULT bytes long.
         */
        uint64_t scanlinesize;
        uint64_t rows;
        scanlinesize = TIFFScanlineSize64(tif);
        if (scanlinesize == 0)
            scanlinesize = 1;
        rows = (uint64_t)STRIP_SIZE_DEFAULT / scanlinesize;
        if (rows == 0)
            rows = 1;
        else if (rows > 0xFFFFFFFF)
            rows = 0xFFFFFFFF;
        s = (uint32_t)rows;
    }
    return (s);
}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFDefaultTileSize()

void _TIFFDefaultTileSize	(	TIFF *	tif,
		uint32_t *	tw,
		uint32_t *	th
	)

Definition at line 272 of file tif_tile.c.

{
    (void)tif;
    if (*(int32_t *)tw < 1)
        *tw = 256;
    if (*(int32_t *)th < 1)
        *th = 256;
    /* roundup to a multiple of 16 per the spec */
    if (*tw & 0xf)
        *tw = TIFFroundup_32(*tw, 16);
    if (*th & 0xf)
        *th = TIFFroundup_32(*th, 16);
}

Referenced by _TIFFSetDefaultCompressionState().

◆ _tiffDummyMapProc()

int _tiffDummyMapProc	(	thandle_t	fd,
		void **	pbase,
		toff_t *	psize
	)

Definition at line 40 of file tif_open.c.

{
    (void)fd;
    (void)pbase;
    (void)psize;
    return (0);
}

Referenced by TIFFClientOpenExt(), and TIFFFdOpenExt().

◆ _tiffDummyUnmapProc()

void _tiffDummyUnmapProc	(	thandle_t	fd,
		void *	base,
		toff_t	size
	)

Definition at line 48 of file tif_open.c.

{
    (void)fd;
    (void)base;
    (void)size;
}

Referenced by TIFFClientOpenExt(), and TIFFFdOpenExt().

◆ _TIFFErrorEarly()

void _TIFFErrorEarly	(	TIFFOpenOptions *	opts,
		thandle_t	clientdata,
		const char *	module,
		const char *	fmt,
			...
	)

◆ _TIFFfreeExt()

void _TIFFfreeExt	(	TIFF *	tif,
		void *	p
	)

free() version that takes into account memory-specific open options

Definition at line 275 of file tif_open.c.

{
    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);
}

◆ _TIFFgetMode()

int _TIFFgetMode	(	TIFFOpenOptions *	opts,
		thandle_t	clientdata,
		const char *	mode,
		const char *	module
	)

Definition at line 55 of file tif_open.c.

{
    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);
}

Referenced by TIFFClientOpenExt(), TIFFOpenExt(), and TIFFOpenWExt().

◆ _TIFFmallocExt()

void * _TIFFmallocExt	(	TIFF *	tif,
		tmsize_t	s
	)

malloc() version that takes into account memory-specific open options

Definition at line 173 of file tif_open.c.

{
    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);
}

◆ _TIFFMultiply32()

void uint32_t _TIFFMultiply32	(	TIFF *	tif,
		uint32_t	first,
		uint32_t	second,
		const char *	where
	)

Definition at line 35 of file tif_aux.c.

{
    if (second && first > UINT32_MAX / second)
    {
        TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
        return 0;
    }
 
    return first * second;
}

Referenced by TIFFNumberOfStrips(), and TIFFNumberOfTiles().

◆ _TIFFMultiply64()

uint64_t _TIFFMultiply64	(	TIFF *	tif,
		uint64_t	first,
		uint64_t	second,
		const char *	where
	)

Definition at line 47 of file tif_aux.c.

{
    if (second && first > UINT64_MAX / second)
    {
        TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
        return 0;
    }
 
    return first * second;
}

Referenced by TIFFRasterScanlineSize64(), TIFFScanlineSize64(), TIFFTileRowSize64(), TIFFVStripSize64(), and TIFFVTileSize64().

◆ _TIFFMultiplySSize()

tmsize_t _TIFFMultiplySSize	(	TIFF *	tif,
		tmsize_t	first,
		tmsize_t	second,
		const char *	where
	)

Definition at line 59 of file tif_aux.c.

{
    if (first <= 0 || second <= 0)
    {
        if (tif != NULL && where != NULL)
        {
            TIFFErrorExtR(tif, where,
                          "Invalid argument to _TIFFMultiplySSize() in %s",
                          where);
        }
        return 0;
    }
 
    if (first > TIFF_TMSIZE_T_MAX / second)
    {
        if (tif != NULL && where != NULL)
        {
            TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
        }
        return 0;
    }
    return first * second;
}

Referenced by _TIFFCheckRealloc(), gtStripSeparate(), gtTileSeparate(), and setByteArray().

◆ _TIFFNoPostDecode()

void _TIFFNoPostDecode	(	TIFF *	tif,
		uint8_t *	buf,
		tmsize_t	cc
	)

Definition at line 1648 of file tif_read.c.

{
    (void)tif;
    (void)buf;
    (void)cc;
}

Referenced by _TIFFVSetField(), PredictorSetupDecode(), PredictorSetupEncode(), and TIFFDefaultDirectory().

◆ _TIFFNoPreCode()

int _TIFFNoPreCode	(	TIFF *	tif,
		uint16_t	s
	)

Definition at line 128 of file tif_compress.c.

{
    (void)tif;
    (void)s;
    return (1);
}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoRowDecode()

int _TIFFNoRowDecode	(	TIFF *	tif,
		uint8_t *	pp,
		tmsize_t	cc,
		uint16_t	s
	)

Definition at line 96 of file tif_compress.c.

{
    (void)pp;
    (void)cc;
    (void)s;
    return (TIFFNoDecode(tif, "scanline"));
}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoRowEncode()

int _TIFFNoRowEncode	(	TIFF *	tif,
		uint8_t *	pp,
		tmsize_t	cc,
		uint16_t	s
	)

Definition at line 51 of file tif_compress.c.

{
    (void)pp;
    (void)cc;
    (void)s;
    return (TIFFNoEncode(tif, "scanline"));
}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoSeek()

int _TIFFNoSeek	(	TIFF *	tif,
		uint32_t	off
	)

Definition at line 120 of file tif_compress.c.

{
    (void)off;
    TIFFErrorExtR(tif, tif->tif_name,
                  "Compression algorithm does not support random access");
    return (0);
}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoStripDecode()

int _TIFFNoStripDecode	(	TIFF *	tif,
		uint8_t *	pp,
		tmsize_t	cc,
		uint16_t	s
	)

Definition at line 104 of file tif_compress.c.

{
    (void)pp;
    (void)cc;
    (void)s;
    return (TIFFNoDecode(tif, "strip"));
}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoStripEncode()

int _TIFFNoStripEncode	(	TIFF *	tif,
		uint8_t *	pp,
		tmsize_t	cc,
		uint16_t	s
	)

Definition at line 59 of file tif_compress.c.

{
    (void)pp;
    (void)cc;
    (void)s;
    return (TIFFNoEncode(tif, "strip"));
}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoTileDecode()

int _TIFFNoTileDecode	(	TIFF *	tif,
		uint8_t *	pp,
		tmsize_t	cc,
		uint16_t	s
	)

Definition at line 112 of file tif_compress.c.

{
    (void)pp;
    (void)cc;
    (void)s;
    return (TIFFNoDecode(tif, "tile"));
}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoTileEncode()

int _TIFFNoTileEncode	(	TIFF *	tif,
		uint8_t *	pp,
		tmsize_t	cc,
		uint16_t	s
	)

Definition at line 67 of file tif_compress.c.

{
    (void)pp;
    (void)cc;
    (void)s;
    return (TIFFNoEncode(tif, "tile"));
}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFprintAscii()

void _TIFFprintAscii	(	FILE *	fd,
		const char *	cp
	)

Definition at line 725 of file tif_print.c.

{
    _TIFFprintAsciiBounded(fd, cp, strlen(cp));
}

Referenced by _TIFFprintAsciiTag().

◆ _TIFFprintAsciiTag()

void _TIFFprintAsciiTag	(	FILE *	fd,
		const char *	name,
		const char *	value
	)

Definition at line 751 of file tif_print.c.

{
    fprintf(fd, "  %s: \"", name);
    _TIFFprintAscii(fd, value);
    fprintf(fd, "\"\n");
}

◆ _TIFFReadEncodedStripAndAllocBuffer()

tmsize_t _TIFFReadEncodedStripAndAllocBuffer	(	TIFF *	tif,
		uint32_t	strip,
		void **	buf,
		tmsize_t	bufsizetoalloc,
		tmsize_t	size_to_read
	)

Definition at line 584 of file tif_read.c.

{
    tmsize_t this_stripsize;
    uint16_t plane;
 
    if (*buf != NULL)
    {
        return TIFFReadEncodedStrip(tif, strip, *buf, size_to_read);
    }
 
    this_stripsize = TIFFReadEncodedStripGetStripSize(tif, strip, &plane);
    if (this_stripsize == ((tmsize_t)(-1)))
        return ((tmsize_t)(-1));
 
    if ((size_to_read != (tmsize_t)(-1)) && (size_to_read < this_stripsize))
        this_stripsize = size_to_read;
    if (!TIFFFillStrip(tif, strip))
        return ((tmsize_t)(-1));
 
    *buf = _TIFFmallocExt(tif, bufsizetoalloc);
    if (*buf == NULL)
    {
        TIFFErrorExtR(tif, TIFFFileName(tif), "No space for strip buffer");
        return ((tmsize_t)(-1));
    }
    _TIFFmemset(*buf, 0, bufsizetoalloc);
 
    if ((*tif->tif_decodestrip)(tif, *buf, this_stripsize, plane) <= 0)
        return ((tmsize_t)(-1));
    (*tif->tif_postdecode)(tif, *buf, this_stripsize);
    return (this_stripsize);
}

Referenced by gtStripContig(), and gtStripSeparate().

◆ _TIFFReadEncodedTileAndAllocBuffer()

tmsize_t _TIFFReadEncodedTileAndAllocBuffer	(	TIFF *	tif,
		uint32_t	tile,
		void **	buf,
		tmsize_t	bufsizetoalloc,
		tmsize_t	size_to_read
	)

Definition at line 1029 of file tif_read.c.

{
    static const char module[] = "_TIFFReadEncodedTileAndAllocBuffer";
    TIFFDirectory *td = &tif->tif_dir;
    tmsize_t tilesize = tif->tif_tilesize;
 
    if (*buf != NULL)
    {
        return TIFFReadEncodedTile(tif, tile, *buf, size_to_read);
    }
 
    if (!TIFFCheckRead(tif, 1))
        return ((tmsize_t)(-1));
    if (tile >= td->td_nstrips)
    {
        TIFFErrorExtR(tif, module,
                      "%" PRIu32 ": Tile out of range, max %" PRIu32, tile,
                      td->td_nstrips);
        return ((tmsize_t)(-1));
    }
 
    if (!TIFFFillTile(tif, tile))
        return ((tmsize_t)(-1));
 
    /* Sanity checks to avoid excessive memory allocation */
    /* Cf https://gitlab.com/libtiff/libtiff/-/issues/479 */
    if (td->td_compression == COMPRESSION_NONE)
    {
        if (tif->tif_rawdatasize != tilesize)
        {
            TIFFErrorExtR(tif, TIFFFileName(tif),
                          "Invalid tile byte count for tile %u. "
                          "Expected %" PRIu64 ", got %" PRIu64,
                          tile, (uint64_t)tilesize,
                          (uint64_t)tif->tif_rawdatasize);
            return ((tmsize_t)(-1));
        }
    }
    else
    {
        /* Max compression ratio experimentally determined. Might be fragile...
         * Only apply this heuristics to situations where the memory allocation
         * would be big, to avoid breaking nominal use cases.
         */
        const int maxCompressionRatio =
            td->td_compression == COMPRESSION_ZSTD ? 33000
            : td->td_compression == COMPRESSION_JXL
                ?
                /* Evaluated on a 8000x8000 tile */
                25000 * (td->td_planarconfig == PLANARCONFIG_CONTIG
                             ? td->td_samplesperpixel
                             : 1)
                : td->td_compression == COMPRESSION_LZMA ? 7000 : 1000;
        if (bufsizetoalloc > 100 * 1000 * 1000 &&
            tif->tif_rawdatasize < tilesize / maxCompressionRatio)
        {
            TIFFErrorExtR(tif, TIFFFileName(tif),
                          "Likely invalid tile byte count for tile %u. "
                          "Uncompressed tile size is %" PRIu64 ", "
                          "compressed one is %" PRIu64,
                          tile, (uint64_t)tilesize,
                          (uint64_t)tif->tif_rawdatasize);
            return ((tmsize_t)(-1));
        }
    }
 
    *buf = _TIFFmallocExt(tif, bufsizetoalloc);
    if (*buf == NULL)
    {
        TIFFErrorExtR(tif, TIFFFileName(tif), "No space for tile buffer");
        return ((tmsize_t)(-1));
    }
    _TIFFmemset(*buf, 0, bufsizetoalloc);
 
    if (size_to_read == (tmsize_t)(-1))
        size_to_read = tilesize;
    else if (size_to_read > tilesize)
        size_to_read = tilesize;
    if ((*tif->tif_decodetile)(tif, (uint8_t *)*buf, size_to_read,
                               (uint16_t)(tile / td->td_stripsperimage)))
    {
        (*tif->tif_postdecode)(tif, (uint8_t *)*buf, size_to_read);
        return (size_to_read);
    }
    else
        return ((tmsize_t)(-1));
}

Referenced by _TIFFReadTileAndAllocBuffer().

◆ _TIFFReadTileAndAllocBuffer()

tmsize_t _TIFFReadTileAndAllocBuffer	(	TIFF *	tif,
		void **	buf,
		tmsize_t	bufsizetoalloc,
		uint32_t	x,
		uint32_t	y,
		uint32_t	z,
		uint16_t	s
	)

Definition at line 1012 of file tif_read.c.

{
    if (!TIFFCheckRead(tif, 1) || !TIFFCheckTile(tif, x, y, z, s))
        return ((tmsize_t)(-1));
    return (_TIFFReadEncodedTileAndAllocBuffer(
        tif, TIFFComputeTile(tif, x, y, z, s), buf, bufsizetoalloc,
        (tmsize_t)(-1)));
}

Referenced by gtTileContig(), and gtTileSeparate().

◆ _TIFFreallocExt()

void * _TIFFreallocExt	(	TIFF *	tif,
		void *	p,
		tmsize_t	s
	)

realloc() version that takes into account memory-specific open options

Definition at line 235 of file tif_open.c.

{
    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);
}

Referenced by _TIFFCheckRealloc(), _TIFFFetchStrileValue(), _TIFFVSetField(), TIFFGetConfiguredCODECs(), TIFFGrowStrips(), TIFFReadAndRealloc(), and TIFFReadDirEntryDataAndRealloc().

◆ _TIFFRewriteField()

int _TIFFRewriteField	(	TIFF *	tif,
		uint16_t	tag,
		TIFFDataType	in_datatype,
		tmsize_t	count,
		void *	data
	)

Definition at line 3377 of file tif_dirwrite.c.

{
    static const char module[] = "TIFFResetField";
    /* const TIFFField* fip = NULL; */
    uint16_t dircount;
    tmsize_t dirsize;
    uint8_t direntry_raw[20];
    uint16_t entry_tag = 0;
    uint16_t entry_type = 0;
    uint64_t entry_count = 0;
    uint64_t entry_offset = 0;
    int value_in_entry = 0;
    uint64_t read_offset;
    uint8_t *buf_to_write = NULL;
    TIFFDataType datatype;
 
    /* -------------------------------------------------------------------- */
    /*      Find field definition.                                          */
    /* -------------------------------------------------------------------- */
    /*fip =*/TIFFFindField(tif, tag, TIFF_ANY);
 
    /* -------------------------------------------------------------------- */
    /*      Do some checking this is a straight forward case.               */
    /* -------------------------------------------------------------------- */
    if (isMapped(tif))
    {
        TIFFErrorExtR(tif, module,
                      "Memory mapped files not currently supported for "
                      "this operation.");
        return 0;
    }
 
    if (tif->tif_diroff == 0)
    {
        TIFFErrorExtR(
            tif, module,
            "Attempt to reset field on directory not already on disk.");
        return 0;
    }
 
    /* -------------------------------------------------------------------- */
    /*      Read the directory entry count.                                 */
    /* -------------------------------------------------------------------- */
    if (!SeekOK(tif, tif->tif_diroff))
    {
        TIFFErrorExtR(tif, module, "%s: Seek error accessing TIFF directory",
                      tif->tif_name);
        return 0;
    }
 
    read_offset = tif->tif_diroff;
 
    if (!(tif->tif_flags & TIFF_BIGTIFF))
    {
        if (!ReadOK(tif, &dircount, sizeof(uint16_t)))
        {
            TIFFErrorExtR(tif, module, "%s: Can not read TIFF directory count",
                          tif->tif_name);
            return 0;
        }
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabShort(&dircount);
        dirsize = 12;
        read_offset += 2;
    }
    else
    {
        uint64_t dircount64;
        if (!ReadOK(tif, &dircount64, sizeof(uint64_t)))
        {
            TIFFErrorExtR(tif, module, "%s: Can not read TIFF directory count",
                          tif->tif_name);
            return 0;
        }
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong8(&dircount64);
        dircount = (uint16_t)dircount64;
        dirsize = 20;
        read_offset += 8;
    }
 
    /* -------------------------------------------------------------------- */
    /*      Read through directory to find target tag.                      */
    /* -------------------------------------------------------------------- */
    while (dircount > 0)
    {
        if (!ReadOK(tif, direntry_raw, dirsize))
        {
            TIFFErrorExtR(tif, module, "%s: Can not read TIFF directory entry.",
                          tif->tif_name);
            return 0;
        }
 
        memcpy(&entry_tag, direntry_raw + 0, sizeof(uint16_t));
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabShort(&entry_tag);
 
        if (entry_tag == tag)
            break;
 
        read_offset += dirsize;
    }
 
    if (entry_tag != tag)
    {
        TIFFErrorExtR(tif, module, "%s: Could not find tag %" PRIu16 ".",
                      tif->tif_name, tag);
        return 0;
    }
 
    /* -------------------------------------------------------------------- */
    /*      Extract the type, count and offset for this entry.              */
    /* -------------------------------------------------------------------- */
    memcpy(&entry_type, direntry_raw + 2, sizeof(uint16_t));
    if (tif->tif_flags & TIFF_SWAB)
        TIFFSwabShort(&entry_type);
 
    if (!(tif->tif_flags & TIFF_BIGTIFF))
    {
        uint32_t value;
 
        memcpy(&value, direntry_raw + 4, sizeof(uint32_t));
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong(&value);
        entry_count = value;
 
        memcpy(&value, direntry_raw + 8, sizeof(uint32_t));
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong(&value);
        entry_offset = value;
    }
    else
    {
        memcpy(&entry_count, direntry_raw + 4, sizeof(uint64_t));
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong8(&entry_count);
 
        memcpy(&entry_offset, direntry_raw + 12, sizeof(uint64_t));
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong8(&entry_offset);
    }
 
    /* -------------------------------------------------------------------- */
    /*      When a dummy tag was written due to TIFFDeferStrileArrayWriting() */
    /* -------------------------------------------------------------------- */
    if (entry_offset == 0 && entry_count == 0 && entry_type == 0)
    {
        if (tag == TIFFTAG_TILEOFFSETS || tag == TIFFTAG_STRIPOFFSETS)
        {
            entry_type =
                (tif->tif_flags & TIFF_BIGTIFF) ? TIFF_LONG8 : TIFF_LONG;
        }
        else
        {
            int write_aslong8 = 1;
            if (count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS)
            {
                write_aslong8 = WriteAsLong8(tif, TIFFStripSize64(tif));
            }
            else if (count > 1 && tag == TIFFTAG_TILEBYTECOUNTS)
            {
                write_aslong8 = WriteAsLong8(tif, TIFFTileSize64(tif));
            }
            if (write_aslong8)
            {
                entry_type = TIFF_LONG8;
            }
            else
            {
                int write_aslong4 = 1;
                if (count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS)
                {
                    write_aslong4 = WriteAsLong4(tif, TIFFStripSize64(tif));
                }
                else if (count > 1 && tag == TIFFTAG_TILEBYTECOUNTS)
                {
                    write_aslong4 = WriteAsLong4(tif, TIFFTileSize64(tif));
                }
                if (write_aslong4)
                {
                    entry_type = TIFF_LONG;
                }
                else
                {
                    entry_type = TIFF_SHORT;
                }
            }
        }
    }
 
    /* -------------------------------------------------------------------- */
    /*      What data type do we want to write this as?                     */
    /* -------------------------------------------------------------------- */
    if (TIFFDataWidth(in_datatype) == 8 && !(tif->tif_flags & TIFF_BIGTIFF))
    {
        if (in_datatype == TIFF_LONG8)
            datatype = entry_type == TIFF_SHORT ? TIFF_SHORT : TIFF_LONG;
        else if (in_datatype == TIFF_SLONG8)
            datatype = TIFF_SLONG;
        else if (in_datatype == TIFF_IFD8)
            datatype = TIFF_IFD;
        else
            datatype = in_datatype;
    }
    else
    {
        if (in_datatype == TIFF_LONG8 &&
            (entry_type == TIFF_SHORT || entry_type == TIFF_LONG ||
             entry_type == TIFF_LONG8))
            datatype = entry_type;
        else if (in_datatype == TIFF_SLONG8 &&
                 (entry_type == TIFF_SLONG || entry_type == TIFF_SLONG8))
            datatype = entry_type;
        else if (in_datatype == TIFF_IFD8 &&
                 (entry_type == TIFF_IFD || entry_type == TIFF_IFD8))
            datatype = entry_type;
        else
            datatype = in_datatype;
    }
 
    /* -------------------------------------------------------------------- */
    /*      Prepare buffer of actual data to write.  This includes          */
    /*      swabbing as needed.                                             */
    /* -------------------------------------------------------------------- */
    buf_to_write = (uint8_t *)_TIFFCheckMalloc(
        tif, count, TIFFDataWidth(datatype), "for field buffer.");
    if (!buf_to_write)
        return 0;
 
    if (datatype == in_datatype)
        memcpy(buf_to_write, data, count * TIFFDataWidth(datatype));
    else if (datatype == TIFF_SLONG && in_datatype == TIFF_SLONG8)
    {
        tmsize_t i;
 
        for (i = 0; i < count; i++)
        {
            ((int32_t *)buf_to_write)[i] = (int32_t)((int64_t *)data)[i];
            if ((int64_t)((int32_t *)buf_to_write)[i] != ((int64_t *)data)[i])
            {
                _TIFFfreeExt(tif, buf_to_write);
                TIFFErrorExtR(tif, module,
                              "Value exceeds 32bit range of output type.");
                return 0;
            }
        }
    }
    else if ((datatype == TIFF_LONG && in_datatype == TIFF_LONG8) ||
             (datatype == TIFF_IFD && in_datatype == TIFF_IFD8))
    {
        tmsize_t i;
 
        for (i = 0; i < count; i++)
        {
            ((uint32_t *)buf_to_write)[i] = (uint32_t)((uint64_t *)data)[i];
            if ((uint64_t)((uint32_t *)buf_to_write)[i] !=
                ((uint64_t *)data)[i])
            {
                _TIFFfreeExt(tif, buf_to_write);
                TIFFErrorExtR(tif, module,
                              "Value exceeds 32bit range of output type.");
                return 0;
            }
        }
    }
    else if (datatype == TIFF_SHORT && in_datatype == TIFF_LONG8)
    {
        tmsize_t i;
 
        for (i = 0; i < count; i++)
        {
            ((uint16_t *)buf_to_write)[i] = (uint16_t)((uint64_t *)data)[i];
            if ((uint64_t)((uint16_t *)buf_to_write)[i] !=
                ((uint64_t *)data)[i])
            {
                _TIFFfreeExt(tif, buf_to_write);
                TIFFErrorExtR(tif, module,
                              "Value exceeds 16bit range of output type.");
                return 0;
            }
        }
    }
    else
    {
        TIFFErrorExtR(tif, module, "Unhandled type conversion.");
        return 0;
    }
 
    if (TIFFDataWidth(datatype) > 1 && (tif->tif_flags & TIFF_SWAB))
    {
        if (TIFFDataWidth(datatype) == 2)
            TIFFSwabArrayOfShort((uint16_t *)buf_to_write, count);
        else if (TIFFDataWidth(datatype) == 4)
            TIFFSwabArrayOfLong((uint32_t *)buf_to_write, count);
        else if (TIFFDataWidth(datatype) == 8)
            TIFFSwabArrayOfLong8((uint64_t *)buf_to_write, count);
    }
 
    /* -------------------------------------------------------------------- */
    /*      Is this a value that fits into the directory entry?             */
    /* -------------------------------------------------------------------- */
    if (!(tif->tif_flags & TIFF_BIGTIFF))
    {
        if (TIFFDataWidth(datatype) * count <= 4)
        {
            entry_offset = read_offset + 8;
            value_in_entry = 1;
        }
    }
    else
    {
        if (TIFFDataWidth(datatype) * count <= 8)
        {
            entry_offset = read_offset + 12;
            value_in_entry = 1;
        }
    }
 
    if ((tag == TIFFTAG_TILEOFFSETS || tag == TIFFTAG_STRIPOFFSETS) &&
        tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
        tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
        tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0)
    {
        tif->tif_dir.td_stripoffset_entry.tdir_type = datatype;
        tif->tif_dir.td_stripoffset_entry.tdir_count = count;
    }
    else if ((tag == TIFFTAG_TILEBYTECOUNTS ||
              tag == TIFFTAG_STRIPBYTECOUNTS) &&
             tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
             tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
             tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0)
    {
        tif->tif_dir.td_stripbytecount_entry.tdir_type = datatype;
        tif->tif_dir.td_stripbytecount_entry.tdir_count = count;
    }
 
    /* -------------------------------------------------------------------- */
    /*      If the tag type, and count match, then we just write it out     */
    /*      over the old values without altering the directory entry at     */
    /*      all.                                                            */
    /* -------------------------------------------------------------------- */
    if (entry_count == (uint64_t)count && entry_type == (uint16_t)datatype)
    {
        if (!SeekOK(tif, entry_offset))
        {
            _TIFFfreeExt(tif, buf_to_write);
            TIFFErrorExtR(tif, module,
                          "%s: Seek error accessing TIFF directory",
                          tif->tif_name);
            return 0;
        }
        if (!WriteOK(tif, buf_to_write, count * TIFFDataWidth(datatype)))
        {
            _TIFFfreeExt(tif, buf_to_write);
            TIFFErrorExtR(tif, module, "Error writing directory link");
            return (0);
        }
 
        _TIFFfreeExt(tif, buf_to_write);
        return 1;
    }
 
    /* -------------------------------------------------------------------- */
    /*      Otherwise, we write the new tag data at the end of the file.    */
    /* -------------------------------------------------------------------- */
    if (!value_in_entry)
    {
        entry_offset = TIFFSeekFile(tif, 0, SEEK_END);
 
        if (!WriteOK(tif, buf_to_write, count * TIFFDataWidth(datatype)))
        {
            _TIFFfreeExt(tif, buf_to_write);
            TIFFErrorExtR(tif, module, "Error writing directory link");
            return (0);
        }
    }
    else
    {
        if (count * TIFFDataWidth(datatype) == 4)
        {
            uint32_t value;
            memcpy(&value, buf_to_write, count * TIFFDataWidth(datatype));
            entry_offset = value;
        }
        else
        {
            memcpy(&entry_offset, buf_to_write,
                   count * TIFFDataWidth(datatype));
        }
    }
 
    _TIFFfreeExt(tif, buf_to_write);
    buf_to_write = 0;
 
    /* -------------------------------------------------------------------- */
    /*      Adjust the directory entry.                                     */
    /* -------------------------------------------------------------------- */
    entry_type = datatype;
    entry_count = (uint64_t)count;
    memcpy(direntry_raw + 2, &entry_type, sizeof(uint16_t));
    if (tif->tif_flags & TIFF_SWAB)
        TIFFSwabShort((uint16_t *)(direntry_raw + 2));
 
    if (!(tif->tif_flags & TIFF_BIGTIFF))
    {
        uint32_t value;
 
        value = (uint32_t)entry_count;
        memcpy(direntry_raw + 4, &value, sizeof(uint32_t));
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong((uint32_t *)(direntry_raw + 4));
 
        value = (uint32_t)entry_offset;
        memcpy(direntry_raw + 8, &value, sizeof(uint32_t));
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong((uint32_t *)(direntry_raw + 8));
    }
    else
    {
        memcpy(direntry_raw + 4, &entry_count, sizeof(uint64_t));
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong8((uint64_t *)(direntry_raw + 4));
 
        memcpy(direntry_raw + 12, &entry_offset, sizeof(uint64_t));
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong8((uint64_t *)(direntry_raw + 12));
    }
 
    /* -------------------------------------------------------------------- */
    /*      Write the directory entry out to disk.                          */
    /* -------------------------------------------------------------------- */
    if (!SeekOK(tif, read_offset))
    {
        TIFFErrorExtR(tif, module, "%s: Seek error accessing TIFF directory",
                      tif->tif_name);
        return 0;
    }
 
    if (!WriteOK(tif, direntry_raw, dirsize))
    {
        TIFFErrorExtR(tif, module, "%s: Can not write TIFF directory entry.",
                      tif->tif_name);
        return 0;
    }
 
    return 1;
}

Referenced by TIFFForceStrileArrayWriting().

◆ _TIFFSeekOK()

int _TIFFSeekOK	(	TIFF *	tif,
		toff_t	off
	)

Definition at line 409 of file tif_aux.c.

{
    /* Huge offsets, especially -1 / UINT64_MAX, can cause issues */
    /* See http://bugzilla.maptools.org/show_bug.cgi?id=2726 */
    return off <= (~(uint64_t)0) / 2 && TIFFSeekFile(tif, off, SEEK_SET) == off;
}

◆ _TIFFsetByteArray()

void _TIFFsetByteArray	(	void **	vpp,
		const void *	vp,
		uint32_t	n
	)

Definition at line 60 of file tif_dir.c.

{
    setByteArray(NULL, vpp, vp, n, 1);
}

◆ _TIFFsetByteArrayExt()

void _TIFFsetByteArrayExt	(	TIFF *	tif,
		void **	vpp,
		const void *	vp,
		uint32_t	n
	)

Definition at line 64 of file tif_dir.c.

{
    setByteArray(tif, vpp, vp, n, 1);
}

◆ _TIFFSetDefaultCompressionState()

void _TIFFSetDefaultCompressionState ( TIFF * tif )

Definition at line 142 of file tif_compress.c.

{
    tif->tif_fixuptags = _TIFFNoFixupTags;
    tif->tif_decodestatus = TRUE;
    tif->tif_setupdecode = _TIFFtrue;
    tif->tif_predecode = _TIFFNoPreCode;
    tif->tif_decoderow = _TIFFNoRowDecode;
    tif->tif_decodestrip = _TIFFNoStripDecode;
    tif->tif_decodetile = _TIFFNoTileDecode;
    tif->tif_encodestatus = TRUE;
    tif->tif_setupencode = _TIFFtrue;
    tif->tif_preencode = _TIFFNoPreCode;
    tif->tif_postencode = _TIFFtrue;
    tif->tif_encoderow = _TIFFNoRowEncode;
    tif->tif_encodestrip = _TIFFNoStripEncode;
    tif->tif_encodetile = _TIFFNoTileEncode;
    tif->tif_close = _TIFFvoid;
    tif->tif_seek = _TIFFNoSeek;
    tif->tif_cleanup = _TIFFvoid;
    tif->tif_defstripsize = _TIFFDefaultStripSize;
    tif->tif_deftilesize = _TIFFDefaultTileSize;
    tif->tif_flags &= ~(TIFF_NOBITREV | TIFF_NOREADRAW);
}

Referenced by TIFFClientOpenExt(), and TIFFSetCompressionScheme().

◆ _TIFFsetDoubleArray()

void _TIFFsetDoubleArray	(	double **	dpp,
		const double *	dp,
		uint32_t	n
	)

Definition at line 109 of file tif_dir.c.

{
    setByteArray(NULL, (void **)dpp, dp, n, sizeof(double));
}

◆ _TIFFsetDoubleArrayExt()

void _TIFFsetDoubleArrayExt	(	TIFF *	tif,
		double **	dpp,
		const double *	dp,
		uint32_t	n
	)

Definition at line 113 of file tif_dir.c.

{
    setByteArray(tif, (void **)dpp, dp, n, sizeof(double));
}

Referenced by _TIFFVSetField().

◆ _TIFFsetFloatArray()

void _TIFFsetFloatArray	(	float **	fpp,
		const float *	fp,
		uint32_t	n
	)

Definition at line 100 of file tif_dir.c.

{
    setByteArray(NULL, (void **)fpp, fp, n, sizeof(float));
}

◆ _TIFFsetFloatArrayExt()

void _TIFFsetFloatArrayExt	(	TIFF *	tif,
		float **	fpp,
		const float *	fp,
		uint32_t	n
	)

Definition at line 104 of file tif_dir.c.

{
    setByteArray(tif, (void **)fpp, fp, n, sizeof(float));
}

Referenced by _TIFFVSetField().

◆ _TIFFsetLongArray()

void _TIFFsetLongArray	(	uint32_t **	lpp,
		const uint32_t *	lp,
		uint32_t	n
	)

Definition at line 84 of file tif_dir.c.

{
    setByteArray(NULL, (void **)lpp, lp, n, sizeof(uint32_t));
}

◆ _TIFFsetLongArrayExt()

void _TIFFsetLongArrayExt	(	TIFF *	tif,
		uint32_t **	lpp,
		const uint32_t *	lp,
		uint32_t	n
	)

Definition at line 88 of file tif_dir.c.

{
    setByteArray(tif, (void **)lpp, lp, n, sizeof(uint32_t));
}

◆ _TIFFsetShortArray()

void _TIFFsetShortArray	(	uint16_t **	wpp,
		const uint16_t *	wp,
		uint32_t	n
	)

Definition at line 74 of file tif_dir.c.

{
    setByteArray(NULL, (void **)wpp, wp, n, sizeof(uint16_t));
}

◆ _TIFFsetShortArrayExt()

void _TIFFsetShortArrayExt	(	TIFF *	tif,
		uint16_t **	wpp,
		const uint16_t *	wp,
		uint32_t	n
	)

Definition at line 78 of file tif_dir.c.

{
    setByteArray(tif, (void **)wpp, wp, n, sizeof(uint16_t));
}

Referenced by _TIFFVSetField(), setExtraSamples(), and TIFFReadDirectory().

◆ _TIFFSwab16BitData()

void _TIFFSwab16BitData	(	TIFF *	tif,
		uint8_t *	buf,
		tmsize_t	cc
	)

Definition at line 1655 of file tif_read.c.

{
    (void)tif;
    assert((cc & 1) == 0);
    TIFFSwabArrayOfShort((uint16_t *)buf, cc / 2);
}

Referenced by _TIFFVSetField().

◆ _TIFFSwab24BitData()

void _TIFFSwab24BitData	(	TIFF *	tif,
		uint8_t *	buf,
		tmsize_t	cc
	)

Definition at line 1662 of file tif_read.c.

{
    (void)tif;
    assert((cc % 3) == 0);
    TIFFSwabArrayOfTriples((uint8_t *)buf, cc / 3);
}

Referenced by _TIFFVSetField().

◆ _TIFFSwab32BitData()

void _TIFFSwab32BitData	(	TIFF *	tif,
		uint8_t *	buf,
		tmsize_t	cc
	)

Definition at line 1669 of file tif_read.c.

{
    (void)tif;
    assert((cc & 3) == 0);
    TIFFSwabArrayOfLong((uint32_t *)buf, cc / 4);
}

Referenced by _TIFFVSetField().

◆ _TIFFSwab64BitData()

void _TIFFSwab64BitData	(	TIFF *	tif,
		uint8_t *	buf,
		tmsize_t	cc
	)

Definition at line 1676 of file tif_read.c.

{
    (void)tif;
    assert((cc & 7) == 0);
    TIFFSwabArrayOfDouble((double *)buf, cc / 8);
}

Referenced by _TIFFVSetField().

◆ TIFFCIELab16ToXYZ()

void TIFFCIELab16ToXYZ	(	TIFFCIELabToRGB *	cielab,
		uint32_t	l,
		int32_t	a,
		int32_t	b,
		float *	X,
		float *	Y,
		float *	Z
	)

Definition at line 55 of file tif_color.c.

{
    float L = (float)l * 100.0F / 65535.0F;
    float cby, tmp;
 
    if (L < 8.856F)
    {
        *Y = (L * cielab->Y0) / 903.292F;
        cby = 7.787F * (*Y / cielab->Y0) + 16.0F / 116.0F;
    }
    else
    {
        cby = (L + 16.0F) / 116.0F;
        *Y = cielab->Y0 * cby * cby * cby;
    }
 
    tmp = (float)a / 256.0F / 500.0F + cby;
    if (tmp < 0.2069F)
        *X = cielab->X0 * (tmp - 0.13793F) / 7.787F;
    else
        *X = cielab->X0 * tmp * tmp * tmp;
 
    tmp = cby - (float)b / 256.0F / 200.0F;
    if (tmp < 0.2069F)
        *Z = cielab->Z0 * (tmp - 0.13793F) / 7.787F;
    else
        *Z = cielab->Z0 * tmp * tmp * tmp;
}

Referenced by DECLAREContigPutFunc(), and TIFFCIELabToXYZ().

◆ TIFFDefaultDirectory()

int TIFFDefaultDirectory ( TIFF * tif )

Definition at line 1752 of file tif_dir.c.

{
    register TIFFDirectory *td = &tif->tif_dir;
    const TIFFFieldArray *tiffFieldArray;
 
    tiffFieldArray = _TIFFGetFields();
    _TIFFSetupFields(tif, tiffFieldArray);
 
    _TIFFmemset(td, 0, sizeof(*td));
    td->td_fillorder = FILLORDER_MSB2LSB;
    td->td_bitspersample = 1;
    td->td_threshholding = THRESHHOLD_BILEVEL;
    td->td_orientation = ORIENTATION_TOPLEFT;
    td->td_samplesperpixel = 1;
    td->td_rowsperstrip = (uint32_t)-1;
    td->td_tilewidth = 0;
    td->td_tilelength = 0;
    td->td_tiledepth = 1;
#ifdef STRIPBYTECOUNTSORTED_UNUSED
    td->td_stripbytecountsorted = 1; /* Our own arrays always sorted. */
#endif
    td->td_resolutionunit = RESUNIT_INCH;
    td->td_sampleformat = SAMPLEFORMAT_UINT;
    td->td_imagedepth = 1;
    td->td_ycbcrsubsampling[0] = 2;
    td->td_ycbcrsubsampling[1] = 2;
    td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
    tif->tif_postdecode = _TIFFNoPostDecode;
    tif->tif_foundfield = NULL;
    tif->tif_tagmethods.vsetfield = _TIFFVSetField;
    tif->tif_tagmethods.vgetfield = _TIFFVGetField;
    tif->tif_tagmethods.printdir = NULL;
    /* additional default values */
    td->td_planarconfig = PLANARCONFIG_CONTIG;
    td->td_compression = COMPRESSION_NONE;
    td->td_subfiletype = 0;
    td->td_minsamplevalue = 0;
    /* td_bitspersample=1 is always set in TIFFDefaultDirectory().
     * Therefore, td_maxsamplevalue has to be re-calculated in
     * TIFFGetFieldDefaulted(). */
    td->td_maxsamplevalue = 1; /* Default for td_bitspersample=1 */
    td->td_extrasamples = 0;
    td->td_sampleinfo = NULL;
 
    /*
     *  Give client code a chance to install their own
     *  tag extensions & methods, prior to compression overloads,
     *  but do some prior cleanup first.
     * (http://trac.osgeo.org/gdal/ticket/5054)
     */
    if (tif->tif_nfieldscompat > 0)
    {
        uint32_t i;
 
        for (i = 0; i < tif->tif_nfieldscompat; i++)
        {
            if (tif->tif_fieldscompat[i].allocated_size)
                _TIFFfreeExt(tif, tif->tif_fieldscompat[i].fields);
        }
        _TIFFfreeExt(tif, tif->tif_fieldscompat);
        tif->tif_nfieldscompat = 0;
        tif->tif_fieldscompat = NULL;
    }
    if (_TIFFextender)
        (*_TIFFextender)(tif);
    (void)TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
    /*
     * NB: The directory is marked dirty as a result of setting
     * up the default compression scheme.  However, this really
     * isn't correct -- we want TIFF_DIRTYDIRECT to be set only
     * if the user does something.  We could just do the setup
     * by hand, but it seems better to use the normal mechanism
     * (i.e. TIFFSetField).
     */
    tif->tif_flags &= ~TIFF_DIRTYDIRECT;
 
    /*
     * As per http://bugzilla.remotesensing.org/show_bug.cgi?id=19
     * we clear the ISTILED flag when setting up a new directory.
     * Should we also be clearing stuff like INSUBIFD?
     */
    tif->tif_flags &= ~TIFF_ISTILED;
 
    return (1);
}

Referenced by TIFFClientOpenExt(), TIFFCreateCustomDirectory(), TIFFCreateDirectory(), TIFFReadCustomDirectory(), TIFFReadDirectory(), and TIFFUnlinkDirectory().

◆ TIFFFlushData1()

int TIFFFlushData1 ( TIFF * tif )

Definition at line 931 of file tif_write.c.

{
    if (tif->tif_rawcc > 0 && tif->tif_flags & TIFF_BUF4WRITE)
    {
        if (!isFillOrder(tif, tif->tif_dir.td_fillorder) &&
            (tif->tif_flags & TIFF_NOBITREV) == 0)
            TIFFReverseBits((uint8_t *)tif->tif_rawdata, tif->tif_rawcc);
        if (!TIFFAppendToStrip(
                tif, isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip,
                tif->tif_rawdata, tif->tif_rawcc))
        {
            /* We update those variables even in case of error since there's */
            /* code that doesn't really check the return code of this */
            /* function */
            tif->tif_rawcc = 0;
            tif->tif_rawcp = tif->tif_rawdata;
            return (0);
        }
        tif->tif_rawcc = 0;
        tif->tif_rawcp = tif->tif_rawdata;
    }
    return (1);
}

Referenced by DumpModeEncode(), TIFFFlushData(), and TIFFWriteDirectorySec().

◆ TIFFInitCCITTFax3()

int TIFFInitCCITTFax3	(	TIFF *	,
		int
	)

◆ TIFFInitCCITTFax4()

int TIFFInitCCITTFax4	(	TIFF *	,
		int
	)

◆ TIFFInitCCITTRLE()

int TIFFInitCCITTRLE	(	TIFF *	,
		int
	)

◆ TIFFInitCCITTRLEW()

int TIFFInitCCITTRLEW	(	TIFF *	,
		int
	)

◆ TIFFInitDumpMode()

int TIFFInitDumpMode	(	TIFF *	tif,
		int	scheme
	)

Definition at line 110 of file tif_dumpmode.c.

{
    (void)scheme;
    tif->tif_fixuptags = DumpFixupTags;
    tif->tif_decoderow = DumpModeDecode;
    tif->tif_decodestrip = DumpModeDecode;
    tif->tif_decodetile = DumpModeDecode;
    tif->tif_encoderow = DumpModeEncode;
    tif->tif_encodestrip = DumpModeEncode;
    tif->tif_encodetile = DumpModeEncode;
    tif->tif_seek = DumpModeSeek;
    return (1);
}

◆ TIFFInitJPEG()

int TIFFInitJPEG	(	TIFF *	,
		int
	)

◆ TIFFInitLZW()

int TIFFInitLZW	(	TIFF *	,
		int
	)

◆ TIFFInitNeXT()

int TIFFInitNeXT	(	TIFF *	,
		int
	)

◆ TIFFInitPackBits()

int TIFFInitPackBits	(	TIFF *	,
		int
	)

◆ TIFFInitPixarLog()

int TIFFInitPixarLog	(	TIFF *	,
		int
	)

◆ TIFFInitSGILog()

int TIFFInitSGILog	(	TIFF *	,
		int
	)

◆ TIFFInitThunderScan()

int TIFFInitThunderScan	(	TIFF *	,
		int
	)

◆ TIFFInitZIP()

int TIFFInitZIP	(	TIFF *	,
		int
	)

◆ TIFFJPEGIsFullStripRequired()

int TIFFJPEGIsFullStripRequired ( TIFF * )

Referenced by TIFFFillStripPartial().

◆ TIFFSetCompressionScheme()

int TIFFSetCompressionScheme	(	TIFF *	tif,
		int	scheme
	)

Definition at line 166 of file tif_compress.c.

{
    const TIFFCodec *c = TIFFFindCODEC((uint16_t)scheme);
 
    _TIFFSetDefaultCompressionState(tif);
    /*
     * Don't treat an unknown compression scheme as an error.
     * This permits applications to open files with data that
     * the library does not have builtin support for, but which
     * may still be meaningful.
     */
    return (c ? (*c->init)(tif, scheme) : 1);
}

Referenced by _TIFFVSetField().

◆ TIFFSetDefaultCompressionState()

int TIFFSetDefaultCompressionState ( TIFF * tif )

Variable Documentation

◆ _TIFFBuiltinCODECS

const TIFFCodec _TIFFBuiltinCODECS[]

extern

Definition at line 86 of file tif_codec.c.

Referenced by TIFFFindCODEC(), and TIFFGetConfiguredCODECs().

◆ _TIFFerrorHandler

TIFFErrorHandler _TIFFerrorHandler

extern

Definition at line 382 of file tif_unix.c.

Referenced by _TIFFErrorEarly(), TIFFError(), TIFFErrorExt(), TIFFErrorExtR(), and TIFFSetErrorHandler().

◆ _TIFFerrorHandlerExt

TIFFErrorHandlerExt _TIFFerrorHandlerExt

extern

Definition at line 30 of file tif_error.c.

Referenced by _TIFFErrorEarly(), TIFFError(), TIFFErrorExt(), TIFFErrorExtR(), and TIFFSetErrorHandlerExt().

◆ _TIFFwarningHandler

TIFFErrorHandler _TIFFwarningHandler

extern

Definition at line 373 of file tif_unix.c.

Referenced by TIFFSetWarningHandler(), TIFFWarning(), TIFFWarningExt(), and TIFFWarningExtR().

◆ _TIFFwarningHandlerExt

TIFFErrorHandlerExt _TIFFwarningHandlerExt

extern

Definition at line 30 of file tif_warning.c.

Referenced by TIFFSetWarningHandlerExt(), TIFFWarning(), TIFFWarningExt(), and TIFFWarningExtR().

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ _TIFF_fseek_f

◆ _TIFF_fstat_f

◆ _TIFF_lseek_f

◆ _TIFF_off_t

◆ _TIFF_stat_s

◆ FALSE

◆ fseek

◆ ftell

◆ isFillOrder

◆ isMapped

◆ isPseudoTag

◆ isTiled

◆ isUpSampled

◆ ReadOK

◆ SeekOK

◆ streq

◆ strneq

◆ TIFF_BEENWRITING

◆ TIFF_BIGTIFF

◆ TIFF_BUF4WRITE

◆ TIFF_BUFFERMMAP

◆ TIFF_BUFFERSETUP

◆ TIFF_CHOPPEDUPARRAYS

◆ TIFF_CODERSETUP

◆ TIFF_DEFERSTRILELOAD

◆ TIFF_DIRTYDIRECT

◆ TIFF_DIRTYHEADER

◆ TIFF_DIRTYSTRIP

◆ TIFF_FILLORDER

◆ TIFF_HEADERONLY

◆ TIFF_INCUSTOMIFD

◆ TIFF_INSUBIFD

◆ TIFF_ISTILED

◆ TIFF_LAZYSTRILELOAD

◆ TIFF_MAPPED

◆ TIFF_MYBUFFER

◆ TIFF_NOBITREV

◆ TIFF_NON_EXISTENT_DIR_NUMBER

◆ TIFF_NOREADRAW

◆ TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW

◆ TIFF_PERSAMPLE

◆ TIFF_POSTENCODE

◆ TIFF_STRIPCHOP

◆ TIFF_SWAB

◆ TIFF_UPSAMPLED

◆ TIFFArrayCount

◆ TIFFCloseFile

◆ TIFFGetFileSize

◆ TIFFhowmany8_32

◆ TIFFhowmany8_64

◆ TIFFhowmany_32

◆ TIFFhowmany_32_maxuint_compat

◆ TIFFhowmany_64

◆ TIFFMapFileContents

◆ TIFFmax

◆ TIFFmin

◆ TIFFReadFile

◆ TIFFroundup_32

◆ TIFFroundup_64

◆ TIFFSafeMultiply

◆ TIFFSeekFile

◆ TIFFUnmapFileContents

◆ TIFFWriteFile

◆ TRUE

◆ WriteOK

Typedef Documentation

◆ tidata_t

◆ tidataval_t

◆ TIFFBoolMethod

◆ TIFFClientInfoLink

◆ TIFFCodeMethod

◆ TIFFIOSize_t

◆ TIFFOffsetAndDirNumber

◆ TIFFPostMethod