#include "tiff.h"
#include "tiffvers.h"
#include <stdio.h>
#include <stdarg.h>

Include dependency graph for tiffio.h:

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

Classes
struct	TIFFDisplay

struct	TIFFYCbCrToRGB

struct	TIFFCIELabToRGB

struct	_TIFFRGBAImage

struct	TIFFCodec

struct	TIFFTagMethods

struct	TIFFFieldInfo

Macros
#define	TIFFPRINT_NONE 0x0 /* no extra info */

#define	TIFFPRINT_STRIPS 0x1 /* strips/tiles info */

#define	TIFFPRINT_CURVES 0x2 /* color/gray response curves */

#define	TIFFPRINT_COLORMAP 0x4 /* colormap */

#define	TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */

#define	TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */

#define	TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */

#define	D65_X0 (95.0470F)

#define	D65_Y0 (100.0F)

#define	D65_Z0 (108.8827F)

#define	D50_X0 (96.4250F)

#define	D50_Y0 (100.0F)

#define	D50_Z0 (82.4680F)

#define	CIELABTORGB_TABLE_RANGE 1500

#define	TIFFGetR(abgr) ((abgr) & 0xff)

#define	TIFFGetG(abgr) (((abgr) >> 8) & 0xff)

#define	TIFFGetB(abgr) (((abgr) >> 16) & 0xff)

#define	TIFFGetA(abgr) (((abgr) >> 24) & 0xff)

#define	LOGLUV_PUBLIC 1

#define	__attribute__(x) /nothing/

#define	TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */

#define	TIFF_VARIABLE -1 /* marker for variable length tags */

#define	TIFF_SPP -2 /* marker for SamplesPerPixel tags */

#define	TIFF_VARIABLE2 -3 /* marker for uint32 var-length tags */

#define	FIELD_CUSTOM 65

#define	U_NEU 0.210526316

#define	V_NEU 0.473684211

#define	UVSCALE 410.

Typedefs
typedef struct tiff	TIFF

typedef TIFF_SSIZE_T	tmsize_t

typedef uint64	toff_t

typedef uint32	ttag_t

typedef uint16	tdir_t

typedef uint16	tsample_t

typedef uint32	tstrile_t

typedef tstrile_t	tstrip_t

typedef tstrile_t	ttile_t

typedef tmsize_t	tsize_t

typedef void *	tdata_t

typedef void *	thandle_t

typedef unsigned char	TIFFRGBValue

typedef struct _TIFFRGBAImage	TIFFRGBAImage

typedef void(*	tileContigRoutine) (TIFFRGBAImage , uint32 , uint32, uint32, uint32, uint32, int32, int32, unsigned char *)

typedef void(*	tileSeparateRoutine) (TIFFRGBAImage , uint32 , uint32, uint32, uint32, uint32, int32, int32, unsigned char , unsigned char , unsigned char , unsigned char )

typedef int(*	TIFFInitMethod) (TIFF *, int)

typedef void(*	TIFFErrorHandler) (const char , const char , va_list)

typedef void(*	TIFFErrorHandlerExt) (thandle_t, const char , const char , va_list)

typedef tmsize_t(*	TIFFReadWriteProc) (thandle_t, void *, tmsize_t)

typedef toff_t(*	TIFFSeekProc) (thandle_t, toff_t, int)

typedef int(*	TIFFCloseProc) (thandle_t)

typedef toff_t(*	TIFFSizeProc) (thandle_t)

typedef int(*	TIFFMapFileProc) (thandle_t, void *base, toff_t size)

typedef void(*	TIFFUnmapFileProc) (thandle_t, void *base, toff_t size)

typedef void(*	TIFFExtendProc) (TIFF *)

typedef struct _TIFFField	TIFFField

typedef struct _TIFFFieldArray	TIFFFieldArray

typedef int(*	TIFFVSetMethod) (TIFF *, uint32, va_list)

typedef int(*	TIFFVGetMethod) (TIFF *, uint32, va_list)

typedef void(*	TIFFPrintMethod) (TIFF , FILE , long)

Functions
const char *	TIFFGetVersion (void)

const TIFFCodec *	TIFFFindCODEC (uint16)

TIFFCodec *	TIFFRegisterCODEC (uint16, const char *, TIFFInitMethod)

void	TIFFUnRegisterCODEC (TIFFCodec *)

int	TIFFIsCODECConfigured (uint16)

TIFFCodec *	TIFFGetConfiguredCODECs (void)

void *	_TIFFmalloc (tmsize_t s)

void *	_TIFFcalloc (tmsize_t nmemb, tmsize_t siz)

void *	_TIFFrealloc (void *p, tmsize_t s)

void	_TIFFmemset (void *p, int v, tmsize_t c)

void	_TIFFmemcpy (void d, const void s, tmsize_t c)

int	_TIFFmemcmp (const void p1, const void p2, tmsize_t c)

void	_TIFFfree (void *p)

int	TIFFGetTagListCount (TIFF *)

uint32	TIFFGetTagListEntry (TIFF *, int tag_index)

const TIFFField *	TIFFFindField (TIFF *, uint32, TIFFDataType)

const TIFFField *	TIFFFieldWithTag (TIFF *, uint32)

const TIFFField *	TIFFFieldWithName (TIFF , const char )

uint32	TIFFFieldTag (const TIFFField *)

const char *	TIFFFieldName (const TIFFField *)

TIFFDataType	TIFFFieldDataType (const TIFFField *)

int	TIFFFieldPassCount (const TIFFField *)

int	TIFFFieldReadCount (const TIFFField *)

int	TIFFFieldWriteCount (const TIFFField *)

TIFFTagMethods *	TIFFAccessTagMethods (TIFF *)

void *	TIFFGetClientInfo (TIFF , const char )

void	TIFFSetClientInfo (TIFF , void , const char *)

void	TIFFCleanup (TIFF *tif)

void	TIFFClose (TIFF *tif)

int	TIFFFlush (TIFF *tif)

int	TIFFFlushData (TIFF *tif)

int	TIFFGetField (TIFF *tif, uint32 tag,...)

int	TIFFVGetField (TIFF *tif, uint32 tag, va_list ap)

int	TIFFGetFieldDefaulted (TIFF *tif, uint32 tag,...)

int	TIFFVGetFieldDefaulted (TIFF *tif, uint32 tag, va_list ap)

int	TIFFReadDirectory (TIFF *tif)

int	TIFFReadCustomDirectory (TIFF tif, toff_t diroff, const TIFFFieldArray infoarray)

int	TIFFReadEXIFDirectory (TIFF *tif, toff_t diroff)

uint64	TIFFScanlineSize64 (TIFF *tif)

tmsize_t	TIFFScanlineSize (TIFF *tif)

uint64	TIFFRasterScanlineSize64 (TIFF *tif)

tmsize_t	TIFFRasterScanlineSize (TIFF *tif)

uint64	TIFFStripSize64 (TIFF *tif)

tmsize_t	TIFFStripSize (TIFF *tif)

uint64	TIFFRawStripSize64 (TIFF *tif, uint32 strip)

tmsize_t	TIFFRawStripSize (TIFF *tif, uint32 strip)

uint64	TIFFVStripSize64 (TIFF *tif, uint32 nrows)

tmsize_t	TIFFVStripSize (TIFF *tif, uint32 nrows)

uint64	TIFFTileRowSize64 (TIFF *tif)

tmsize_t	TIFFTileRowSize (TIFF *tif)

uint64	TIFFTileSize64 (TIFF *tif)

tmsize_t	TIFFTileSize (TIFF *tif)

uint64	TIFFVTileSize64 (TIFF *tif, uint32 nrows)

tmsize_t	TIFFVTileSize (TIFF *tif, uint32 nrows)

uint32	TIFFDefaultStripSize (TIFF *tif, uint32 request)

void	TIFFDefaultTileSize (TIFF , uint32 , uint32 *)

int	TIFFFileno (TIFF *)

int	TIFFSetFileno (TIFF *, int)

thandle_t	TIFFClientdata (TIFF *)

thandle_t	TIFFSetClientdata (TIFF *, thandle_t)

int	TIFFGetMode (TIFF *)

int	TIFFSetMode (TIFF *, int)

int	TIFFIsTiled (TIFF *)

int	TIFFIsByteSwapped (TIFF *)

int	TIFFIsUpSampled (TIFF *)

int	TIFFIsMSB2LSB (TIFF *)

int	TIFFIsBigEndian (TIFF *)

TIFFReadWriteProc	TIFFGetReadProc (TIFF *)

TIFFReadWriteProc	TIFFGetWriteProc (TIFF *)

TIFFSeekProc	TIFFGetSeekProc (TIFF *)

TIFFCloseProc	TIFFGetCloseProc (TIFF *)

TIFFSizeProc	TIFFGetSizeProc (TIFF *)

TIFFMapFileProc	TIFFGetMapFileProc (TIFF *)

TIFFUnmapFileProc	TIFFGetUnmapFileProc (TIFF *)

uint32	TIFFCurrentRow (TIFF *)

uint16	TIFFCurrentDirectory (TIFF *)

uint16	TIFFNumberOfDirectories (TIFF *)

uint64	TIFFCurrentDirOffset (TIFF *)

uint32	TIFFCurrentStrip (TIFF *)

uint32	TIFFCurrentTile (TIFF *tif)

int	TIFFReadBufferSetup (TIFF tif, void bp, tmsize_t size)

int	TIFFWriteBufferSetup (TIFF tif, void bp, tmsize_t size)

int	TIFFSetupStrips (TIFF *)

int	TIFFWriteCheck (TIFF , int, const char )

void	TIFFFreeDirectory (TIFF *)

int	TIFFCreateDirectory (TIFF *)

int	TIFFCreateCustomDirectory (TIFF , const TIFFFieldArray )

int	TIFFCreateEXIFDirectory (TIFF *)

int	TIFFLastDirectory (TIFF *)

int	TIFFSetDirectory (TIFF *, uint16)

int	TIFFSetSubDirectory (TIFF *, uint64)

int	TIFFUnlinkDirectory (TIFF *, uint16)

int	TIFFSetField (TIFF *, uint32,...)

int	TIFFVSetField (TIFF *, uint32, va_list)

int	TIFFUnsetField (TIFF *, uint32)

int	TIFFWriteDirectory (TIFF *)

int	TIFFWriteCustomDirectory (TIFF , uint64 )

int	TIFFCheckpointDirectory (TIFF *)

int	TIFFRewriteDirectory (TIFF *)

int	TIFFDeferStrileArrayWriting (TIFF *)

int	TIFFForceStrileArrayWriting (TIFF *)

void	TIFFPrintDirectory (TIFF , FILE , long)

int	TIFFReadScanline (TIFF tif, void buf, uint32 row, uint16 sample)

int	TIFFWriteScanline (TIFF tif, void buf, uint32 row, uint16 sample)

int	TIFFReadRGBAImage (TIFF , uint32, uint32, uint32 , int)

int	TIFFReadRGBAImageOriented (TIFF , uint32, uint32, uint32 , int, int)

int	TIFFReadRGBAStrip (TIFF , uint32, uint32 )

int	TIFFReadRGBATile (TIFF , uint32, uint32, uint32 )

int	TIFFReadRGBAStripExt (TIFF , uint32, uint32 , int stop_on_error)

int	TIFFReadRGBATileExt (TIFF , uint32, uint32, uint32 , int stop_on_error)

int	TIFFRGBAImageOK (TIFF *, char[1024])

int	TIFFRGBAImageBegin (TIFFRGBAImage , TIFF , int, char[1024])

int	TIFFRGBAImageGet (TIFFRGBAImage , uint32 , uint32, uint32)

void	TIFFRGBAImageEnd (TIFFRGBAImage *)

TIFF *	TIFFOpen (const char , const char )

TIFF *	TIFFFdOpen (int, const char , const char )

TIFF *	TIFFClientOpen (const char , const char , thandle_t, TIFFReadWriteProc, TIFFReadWriteProc, TIFFSeekProc, TIFFCloseProc, TIFFSizeProc, TIFFMapFileProc, TIFFUnmapFileProc)

const char *	TIFFFileName (TIFF *)

const char *	TIFFSetFileName (TIFF , const char )

void	TIFFError (const char , const char ,...) __attribute__((__format__(__printf__

void void	TIFFErrorExt (thandle_t, const char , const char ,...) __attribute__((__format__(__printf__

void void void	TIFFWarning (const char , const char ,...) __attribute__((__format__(__printf__

void void void void	TIFFWarningExt (thandle_t, const char , const char ,...) __attribute__((__format__(__printf__

void void void void TIFFErrorHandler	TIFFSetErrorHandler (TIFFErrorHandler)

TIFFErrorHandlerExt	TIFFSetErrorHandlerExt (TIFFErrorHandlerExt)

TIFFErrorHandler	TIFFSetWarningHandler (TIFFErrorHandler)

TIFFErrorHandlerExt	TIFFSetWarningHandlerExt (TIFFErrorHandlerExt)

TIFFExtendProc	TIFFSetTagExtender (TIFFExtendProc)

uint32	TIFFComputeTile (TIFF *tif, uint32 x, uint32 y, uint32 z, uint16 s)

int	TIFFCheckTile (TIFF *tif, uint32 x, uint32 y, uint32 z, uint16 s)

uint32	TIFFNumberOfTiles (TIFF *)

tmsize_t	TIFFReadTile (TIFF tif, void buf, uint32 x, uint32 y, uint32 z, uint16 s)

tmsize_t	TIFFWriteTile (TIFF tif, void buf, uint32 x, uint32 y, uint32 z, uint16 s)

uint32	TIFFComputeStrip (TIFF *, uint32, uint16)

uint32	TIFFNumberOfStrips (TIFF *)

tmsize_t	TIFFReadEncodedStrip (TIFF tif, uint32 strip, void buf, tmsize_t size)

tmsize_t	TIFFReadRawStrip (TIFF tif, uint32 strip, void buf, tmsize_t size)

tmsize_t	TIFFReadEncodedTile (TIFF tif, uint32 tile, void buf, tmsize_t size)

tmsize_t	TIFFReadRawTile (TIFF tif, uint32 tile, void buf, tmsize_t size)

int	TIFFReadFromUserBuffer (TIFF tif, uint32 strile, void inbuf, tmsize_t insize, void *outbuf, tmsize_t outsize)

tmsize_t	TIFFWriteEncodedStrip (TIFF tif, uint32 strip, void data, tmsize_t cc)

tmsize_t	TIFFWriteRawStrip (TIFF tif, uint32 strip, void data, tmsize_t cc)

tmsize_t	TIFFWriteEncodedTile (TIFF tif, uint32 tile, void data, tmsize_t cc)

tmsize_t	TIFFWriteRawTile (TIFF tif, uint32 tile, void data, tmsize_t cc)

int	TIFFDataWidth (TIFFDataType)

void	TIFFSetWriteOffset (TIFF *tif, toff_t off)

void	TIFFSwabShort (uint16 *)

void	TIFFSwabLong (uint32 *)

void	TIFFSwabLong8 (uint64 *)

void	TIFFSwabFloat (float *)

void	TIFFSwabDouble (double *)

void	TIFFSwabArrayOfShort (uint16 *wp, tmsize_t n)

void	TIFFSwabArrayOfTriples (uint8 *tp, tmsize_t n)

void	TIFFSwabArrayOfLong (uint32 *lp, tmsize_t n)

void	TIFFSwabArrayOfLong8 (uint64 *lp, tmsize_t n)

void	TIFFSwabArrayOfFloat (float *fp, tmsize_t n)

void	TIFFSwabArrayOfDouble (double *dp, tmsize_t n)

void	TIFFReverseBits (uint8 *cp, tmsize_t n)

const unsigned char *	TIFFGetBitRevTable (int)

uint64	TIFFGetStrileOffset (TIFF *tif, uint32 strile)

uint64	TIFFGetStrileByteCount (TIFF *tif, uint32 strile)

uint64	TIFFGetStrileOffsetWithErr (TIFF tif, uint32 strile, int pbErr)

uint64	TIFFGetStrileByteCountWithErr (TIFF tif, uint32 strile, int pbErr)

double	LogL16toY (int)

double	LogL10toY (int)

void	XYZtoRGB24 (float , uint8 )

int	uv_decode (double , double , int)

void	LogLuv24toXYZ (uint32, float *)

void	LogLuv32toXYZ (uint32, float *)

int	LogL16fromY (double, int)

int	LogL10fromY (double, int)

int	uv_encode (double, double, int)

uint32	LogLuv24fromXYZ (float *, int)

uint32	LogLuv32fromXYZ (float *, int)

int	TIFFCIELabToRGBInit (TIFFCIELabToRGB , const TIFFDisplay , float *)

void	TIFFCIELabToXYZ (TIFFCIELabToRGB , uint32, int32, int32, float , float , float )

void	TIFFXYZToRGB (TIFFCIELabToRGB , float, float, float, uint32 , uint32 , uint32 )

int	TIFFYCbCrToRGBInit (TIFFYCbCrToRGB , float , float *)

void	TIFFYCbCrtoRGB (TIFFYCbCrToRGB , uint32, int32, int32, uint32 , uint32 , uint32 )

int	TIFFMergeFieldInfo (TIFF *, const TIFFFieldInfo[], uint32)

Macro Definition Documentation

◆ attribute

#define __attribute__ ( x ) /*nothing*/

Definition at line 265 of file tiffio.h.

◆ CIELABTORGB_TABLE_RANGE

#define CIELABTORGB_TABLE_RANGE 1500

Definition at line 165 of file tiffio.h.

◆ D50_X0

#define D50_X0 (96.4250F)

Definition at line 130 of file tiffio.h.

◆ D50_Y0

#define D50_Y0 (100.0F)

Definition at line 131 of file tiffio.h.

◆ D50_Z0

#define D50_Z0 (82.4680F)

Definition at line 132 of file tiffio.h.

◆ D65_X0

#define D65_X0 (95.0470F)

Definition at line 126 of file tiffio.h.

◆ D65_Y0

#define D65_Y0 (100.0F)

Definition at line 127 of file tiffio.h.

◆ D65_Z0

#define D65_Z0 (108.8827F)

Definition at line 128 of file tiffio.h.

◆ FIELD_CUSTOM

#define FIELD_CUSTOM 65

Definition at line 312 of file tiffio.h.

◆ LOGLUV_PUBLIC

#define LOGLUV_PUBLIC 1

Definition at line 261 of file tiffio.h.

◆ TIFF_ANY

#define TIFF_ANY TIFF_NOTYPE /* for field descriptor searching */

Definition at line 307 of file tiffio.h.

◆ TIFF_SPP

#define TIFF_SPP -2 /* marker for SamplesPerPixel tags */

Definition at line 309 of file tiffio.h.

◆ TIFF_VARIABLE

#define TIFF_VARIABLE -1 /* marker for variable length tags */

Definition at line 308 of file tiffio.h.

◆ TIFF_VARIABLE2

#define TIFF_VARIABLE2 -3 /* marker for uint32 var-length tags */

Definition at line 310 of file tiffio.h.

◆ TIFFGetA

#define TIFFGetA ( abgr ) (((abgr) >> 24) & 0xff)

Definition at line 240 of file tiffio.h.

◆ TIFFGetB

#define TIFFGetB ( abgr ) (((abgr) >> 16) & 0xff)

Definition at line 239 of file tiffio.h.

◆ TIFFGetG

#define TIFFGetG ( abgr ) (((abgr) >> 8) & 0xff)

Definition at line 238 of file tiffio.h.

◆ TIFFGetR

#define TIFFGetR ( abgr ) ((abgr) & 0xff)

Definition at line 237 of file tiffio.h.

◆ TIFFPRINT_COLORMAP

#define TIFFPRINT_COLORMAP 0x4 /* colormap */

Definition at line 116 of file tiffio.h.

◆ TIFFPRINT_CURVES

#define TIFFPRINT_CURVES 0x2 /* color/gray response curves */

Definition at line 115 of file tiffio.h.

◆ TIFFPRINT_JPEGACTABLES

#define TIFFPRINT_JPEGACTABLES 0x200 /* JPEG AC tables */

Definition at line 118 of file tiffio.h.

◆ TIFFPRINT_JPEGDCTABLES

#define TIFFPRINT_JPEGDCTABLES 0x200 /* JPEG DC tables */

Definition at line 119 of file tiffio.h.

◆ TIFFPRINT_JPEGQTABLES

#define TIFFPRINT_JPEGQTABLES 0x100 /* JPEG Q matrices */

Definition at line 117 of file tiffio.h.

◆ TIFFPRINT_NONE

#define TIFFPRINT_NONE 0x0 /* no extra info */

Definition at line 113 of file tiffio.h.

◆ TIFFPRINT_STRIPS

#define TIFFPRINT_STRIPS 0x1 /* strips/tiles info */

Definition at line 114 of file tiffio.h.

◆ U_NEU

#define U_NEU 0.210526316

Definition at line 502 of file tiffio.h.

◆ UVSCALE

#define UVSCALE 410.

Definition at line 504 of file tiffio.h.

◆ V_NEU

#define V_NEU 0.473684211

Definition at line 503 of file tiffio.h.

Typedef Documentation

◆ tdata_t

typedef void* tdata_t

Definition at line 76 of file tiffio.h.

◆ tdir_t

typedef uint16 tdir_t

Definition at line 70 of file tiffio.h.

◆ thandle_t

typedef void* thandle_t

Definition at line 104 of file tiffio.h.

◆ TIFF

typedef struct tiff TIFF

Definition at line 38 of file tiffio.h.

◆ TIFFCloseProc

typedef int(* TIFFCloseProc) (thandle_t)

Definition at line 275 of file tiffio.h.

◆ TIFFErrorHandler

typedef void(* TIFFErrorHandler) (const char *, const char *, va_list)

Definition at line 271 of file tiffio.h.

◆ TIFFErrorHandlerExt

typedef void(* TIFFErrorHandlerExt) (thandle_t, const char *, const char *, va_list)

Definition at line 272 of file tiffio.h.

◆ TIFFExtendProc

typedef void(* TIFFExtendProc) (TIFF *)

Definition at line 279 of file tiffio.h.

◆ TIFFField

typedef struct _TIFFField TIFFField

Definition at line 314 of file tiffio.h.

◆ TIFFFieldArray

typedef struct _TIFFFieldArray TIFFFieldArray

Definition at line 315 of file tiffio.h.

◆ TIFFInitMethod

typedef int(* TIFFInitMethod) (TIFF *, int)

Definition at line 249 of file tiffio.h.

◆ TIFFMapFileProc

typedef int(* TIFFMapFileProc) (thandle_t, void **base, toff_t *size)

Definition at line 277 of file tiffio.h.

◆ TIFFPrintMethod

typedef void(* TIFFPrintMethod) (TIFF *, FILE *, long)

Definition at line 330 of file tiffio.h.

◆ TIFFReadWriteProc

typedef tmsize_t(* TIFFReadWriteProc) (thandle_t, void *, tmsize_t)

Definition at line 273 of file tiffio.h.

◆ TIFFRGBAImage

typedef struct _TIFFRGBAImage TIFFRGBAImage

Definition at line 177 of file tiffio.h.

◆ TIFFRGBValue

typedef unsigned char TIFFRGBValue

Definition at line 136 of file tiffio.h.

◆ TIFFSeekProc

typedef toff_t(* TIFFSeekProc) (thandle_t, toff_t, int)

Definition at line 274 of file tiffio.h.

◆ TIFFSizeProc

typedef toff_t(* TIFFSizeProc) (thandle_t)

Definition at line 276 of file tiffio.h.

◆ TIFFUnmapFileProc

typedef void(* TIFFUnmapFileProc) (thandle_t, void *base, toff_t size)

Definition at line 278 of file tiffio.h.

◆ TIFFVGetMethod

typedef int(* TIFFVGetMethod) (TIFF *, uint32, va_list)

Definition at line 329 of file tiffio.h.

◆ TIFFVSetMethod

typedef int(* TIFFVSetMethod) (TIFF *, uint32, va_list)

Definition at line 328 of file tiffio.h.

◆ tileContigRoutine

typedef void(* tileContigRoutine) (TIFFRGBAImage *, uint32 *, uint32, uint32, uint32, uint32, int32, int32, unsigned char *)

Definition at line 188 of file tiffio.h.

◆ tileSeparateRoutine

typedef void(* tileSeparateRoutine) (TIFFRGBAImage *, uint32 *, uint32, uint32, uint32, uint32, int32, int32, unsigned char *, unsigned char *, unsigned char *, unsigned char *)

Definition at line 191 of file tiffio.h.

◆ tmsize_t

typedef TIFF_SSIZE_T tmsize_t

Definition at line 65 of file tiffio.h.

◆ toff_t

typedef uint64 toff_t

Definition at line 66 of file tiffio.h.

◆ tsample_t

typedef uint16 tsample_t

Definition at line 71 of file tiffio.h.

◆ tsize_t

typedef tmsize_t tsize_t

Definition at line 75 of file tiffio.h.

◆ tstrile_t

typedef uint32 tstrile_t

Definition at line 72 of file tiffio.h.

◆ tstrip_t

typedef tstrile_t tstrip_t

Definition at line 73 of file tiffio.h.

◆ ttag_t

typedef uint32 ttag_t

Definition at line 69 of file tiffio.h.

◆ ttile_t

typedef tstrile_t ttile_t

Definition at line 74 of file tiffio.h.

Function Documentation

◆ _TIFFcalloc()

void * _TIFFcalloc	(	tmsize_t	nmemb,
		tmsize_t	siz
	)

Definition at line 317 of file tif_unix.c.

{
    if( nmemb == 0 || siz == 0 )
        return ((void *) NULL);
 
    return calloc((size_t) nmemb, (size_t)siz);
}

Referenced by TIFFReadBufferSetup(), and TIFFReadDirectory().

◆ _TIFFfree()

void _TIFFfree ( void * p )

Definition at line 326 of file tif_unix.c.

{
    free(p);
}

◆ _TIFFmalloc()

void * _TIFFmalloc ( tmsize_t s )

Definition at line 309 of file tif_unix.c.

{
        if (s == 0)
                return ((void *) NULL);
 
    return (malloc((size_t) s));
}

◆ _TIFFmemcmp()

int _TIFFmemcmp	(	const void *	p1,
		const void *	p2,
		tmsize_t	c
	)

Definition at line 350 of file tif_unix.c.

{
    return (memcmp(p1, p2, (size_t) c));
}

Referenced by TIFFWriteDirectoryTagTransferfunction().

◆ _TIFFmemcpy()

void _TIFFmemcpy	(	void *	d,
		const void *	s,
		tmsize_t	c
	)

Definition at line 344 of file tif_unix.c.

{
    memcpy(d, s, (size_t) c);
}

Referenced by _TIFFVSetField(), DumpModeDecode(), DumpModeEncode(), fpAcc(), fpDiff(), setByteArray(), TIFFAdvanceDirectory(), TIFFCIELabToRGBInit(), TIFFDefaultTransferFunction(), TIFFFetchDirectory(), TIFFFetchNormalTag(), TIFFFetchStripThing(), TIFFGetConfiguredCODECs(), TIFFReadDirectory(), TIFFReadDirEntryArrayWithLimit(), TIFFReadDirEntryData(), TIFFReadRawStrip1(), TIFFReadRawTile1(), TIFFRGBAImageBegin(), TIFFWriteDirectorySec(), TIFFWriteDirectoryTagColormap(), TIFFWriteDirectoryTagData(), and TIFFWriteDirectoryTagTransferfunction().

◆ _TIFFmemset()

void _TIFFmemset	(	void *	p,
		int	v,
		tmsize_t	c
	)

Definition at line 338 of file tif_unix.c.

{
    memset(p, v, (size_t) c);
}

Referenced by _TIFFCreateAnonField(), _TIFFFillStrilesInternal(), _TIFFReadEncodedStripAndAllocBuffer(), _TIFFReadEncodedTileAndAllocBuffer(), _TIFFVSetField(), TIFFClientOpen(), TIFFDefaultDirectory(), TIFFFetchStripThing(), TIFFFreeDirectory(), TIFFGetConfiguredCODECs(), TIFFGrowStrips(), TIFFReadCustomDirectory(), TIFFReadRGBATileExt(), TIFFSetupStrips(), and TIFFYCbCrToRGBInit().

◆ _TIFFrealloc()

void * _TIFFrealloc	(	void *	p,
		tmsize_t	s
	)

Definition at line 332 of file tif_unix.c.

{
    return (realloc(p, (size_t) s));
}

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

◆ LogL10fromY()

int LogL10fromY	(	double	,
		int
	)

◆ LogL10toY()

double LogL10toY ( int )

◆ LogL16fromY()

int LogL16fromY	(	double	,
		int
	)

◆ LogL16toY()

double LogL16toY ( int )

◆ LogLuv24fromXYZ()

uint32 LogLuv24fromXYZ	(	float *	,
		int
	)

◆ LogLuv24toXYZ()

void LogLuv24toXYZ	(	uint32	,
		float *
	)

◆ LogLuv32fromXYZ()

uint32 LogLuv32fromXYZ	(	float *	,
		int
	)

◆ LogLuv32toXYZ()

void LogLuv32toXYZ	(	uint32	,
		float *
	)

◆ TIFFAccessTagMethods()

TIFFTagMethods * TIFFAccessTagMethods ( TIFF * tif )

Definition at line 58 of file tif_extension.c.

{
    return &(tif->tif_tagmethods);
}

◆ TIFFCheckpointDirectory()

int TIFFCheckpointDirectory ( TIFF * tif )

Definition at line 237 of file tif_dirwrite.c.

{
    int rc;
    /* Setup the strips arrays, if they haven't already been. */
    if (tif->tif_dir.td_stripoffset_p == NULL)
        (void) TIFFSetupStrips(tif);
    rc = TIFFWriteDirectorySec(tif,TRUE,FALSE,NULL);
    (void) TIFFSetWriteOffset(tif, TIFFSeekFile(tif, 0, SEEK_END));
    return rc;
}

◆ TIFFCheckTile()

int TIFFCheckTile	(	TIFF *	tif,
		uint32	x,
		uint32	y,
		uint32	z,
		uint16	s
	)

Definition at line 73 of file tif_tile.c.

{
    TIFFDirectory *td = &tif->tif_dir;
 
    if (x >= td->td_imagewidth) {
        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                 "%lu: Col out of range, max %lu",
                 (unsigned long) x,
                 (unsigned long) (td->td_imagewidth - 1));
        return (0);
    }
    if (y >= td->td_imagelength) {
        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                 "%lu: Row out of range, max %lu",
                 (unsigned long) y,
                 (unsigned long) (td->td_imagelength - 1));
        return (0);
    }
    if (z >= td->td_imagedepth) {
        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                 "%lu: Depth out of range, max %lu",
                 (unsigned long) z,
                 (unsigned long) (td->td_imagedepth - 1));
        return (0);
    }
    if (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
        s >= td->td_samplesperpixel) {
        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                 "%lu: Sample out of range, max %lu",
                 (unsigned long) s,
                 (unsigned long) (td->td_samplesperpixel - 1));
        return (0);
    }
    return (1);
}

Referenced by _TIFFReadTileAndAllocBuffer(), TIFFReadTile(), and TIFFWriteTile().

◆ TIFFCIELabToRGBInit()

int TIFFCIELabToRGBInit	(	TIFFCIELabToRGB *	cielab,
		const TIFFDisplay *	display,
		float *	refWhite
	)

Definition at line 123 of file tif_color.c.

{
    int i;
    double dfGamma;
 
    cielab->range = CIELABTORGB_TABLE_RANGE;
 
    _TIFFmemcpy(&cielab->display, display, sizeof(TIFFDisplay));
 
    /* Red */
    dfGamma = 1.0 / cielab->display.d_gammaR ;
    cielab->rstep =
        (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
    for(i = 0; i <= cielab->range; i++) {
        cielab->Yr2r[i] = cielab->display.d_Vrwr
            * ((float)pow((double)i / cielab->range, dfGamma));
    }
 
    /* Green */
    dfGamma = 1.0 / cielab->display.d_gammaG ;
    cielab->gstep =
        (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
    for(i = 0; i <= cielab->range; i++) {
        cielab->Yg2g[i] = cielab->display.d_Vrwg
            * ((float)pow((double)i / cielab->range, dfGamma));
    }
 
    /* Blue */
    dfGamma = 1.0 / cielab->display.d_gammaB ;
    cielab->bstep =
        (cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
    for(i = 0; i <= cielab->range; i++) {
        cielab->Yb2b[i] = cielab->display.d_Vrwb
            * ((float)pow((double)i / cielab->range, dfGamma));
    }
 
    /* Init reference white point */
    cielab->X0 = refWhite[0];
    cielab->Y0 = refWhite[1];
    cielab->Z0 = refWhite[2];
 
    return 0;
}

Referenced by initCIELabConversion().

◆ TIFFCIELabToXYZ()

void TIFFCIELabToXYZ	(	TIFFCIELabToRGB *	cielab,
		uint32	l,
		int32	a,
		int32	b,
		float *	X,
		float *	Y,
		float *	Z
	)

Definition at line 44 of file tif_color.c.

{
    float L = (float)l * 100.0F / 255.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 / 500.0F + cby;
    if( tmp < 0.2069F )
        *X = cielab->X0 * (tmp - 0.13793F) / 7.787F;
    else    
        *X = cielab->X0 * tmp * tmp * tmp;
 
    tmp = cby - (float)b / 200.0F;
    if( tmp < 0.2069F )
        *Z = cielab->Z0 * (tmp - 0.13793F) / 7.787F;
    else    
        *Z = cielab->Z0 * tmp * tmp * tmp;
}

Referenced by DECLAREContigPutFunc().

◆ TIFFCleanup()

void TIFFCleanup ( TIFF * tif )

Auxiliary function to free the TIFF structure. Given structure will be completely freed, so you should save opened file handle and pointer to the close procedure in external variables before calling _TIFFCleanup(), if you will need these ones to close the file.

Parameters

tif	A TIFF pointer.

Definition at line 46 of file tif_close.c.

{
    /*
         * Flush buffered data and directory (if dirty).
         */
    if (tif->tif_mode != O_RDONLY)
        TIFFFlush(tif);
    (*tif->tif_cleanup)(tif);
    TIFFFreeDirectory(tif);
 
    if (tif->tif_dirlist)
        _TIFFfree(tif->tif_dirlist);
 
    /*
         * Clean up client info links.
         */
    while( tif->tif_clientinfo )
    {
        TIFFClientInfoLink *psLink = tif->tif_clientinfo;
 
        tif->tif_clientinfo = psLink->next;
        _TIFFfree( psLink->name );
        _TIFFfree( psLink );
    }
 
    if (tif->tif_rawdata && (tif->tif_flags&TIFF_MYBUFFER))
        _TIFFfree(tif->tif_rawdata);
    if (isMapped(tif))
        TIFFUnmapFileContents(tif, tif->tif_base, (toff_t)tif->tif_size);
 
    /*
         * Clean up custom fields.
         */
    if (tif->tif_fields && tif->tif_nfields > 0) {
        uint32 i;
 
        for (i = 0; i < tif->tif_nfields; i++) {
            TIFFField *fld = tif->tif_fields[i];
            if (fld->field_bit == FIELD_CUSTOM &&
                strncmp("Tag ", fld->field_name, 4) == 0) {
                _TIFFfree(fld->field_name);
                _TIFFfree(fld);
            }
        }
 
        _TIFFfree(tif->tif_fields);
    }
 
        if (tif->tif_nfieldscompat > 0) {
                uint32 i;
 
                for (i = 0; i < tif->tif_nfieldscompat; i++) {
                        if (tif->tif_fieldscompat[i].allocated_size)
                                _TIFFfree(tif->tif_fieldscompat[i].fields);
                }
                _TIFFfree(tif->tif_fieldscompat);
        }
 
    _TIFFfree(tif);
}

Referenced by TIFFClientOpen(), and TIFFClose().

◆ TIFFClientdata()

thandle_t TIFFClientdata ( TIFF * tif )

Definition at line 553 of file tif_open.c.

{
    return (tif->tif_clientdata);
}

◆ TIFFClientOpen()

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
	)

Definition at line 71 of file tif_open.c.

{
    static const char module[] = "TIFFClientOpen";
    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)==1);
    assert(sizeof(int8)==1);
    assert(sizeof(uint16)==2);
    assert(sizeof(int16)==2);
    assert(sizeof(uint32)==4);
    assert(sizeof(int32)==4);
    assert(sizeof(uint64)==8);
    assert(sizeof(int64)==8);
    assert(sizeof(tmsize_t)==sizeof(void*));
    {
        union{
            uint8 a8[2];
            uint16 a16;
        } n;
        n.a8[0]=1;
        n.a8[1]=0;
        #ifdef WORDS_BIGENDIAN
        assert(n.a16==256);
        #else
        assert(n.a16==1);
        #endif
    }
 
    m = _TIFFgetMode(mode, module);
    if (m == -1)
        goto bad2;
    tif = (TIFF *)_TIFFmalloc((tmsize_t)(sizeof (TIFF) + strlen(name) + 1));
    if (tif == NULL) {
        TIFFErrorExt(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 = (uint16) -1;      /* non-existent directory */
    tif->tif_curoff = 0;
    tif->tif_curstrip = (uint32) -1;    /* invalid strip */
    tif->tif_row = (uint32) -1;     /* read/write pre-increment */
    tif->tif_clientdata = clientdata;
    if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc) {
        TIFFErrorExt(clientdata, module,
            "One of the client procedures is NULL pointer.");
        _TIFFfree(tif);
        goto bad2;
    }
    tif->tif_readproc = readproc;
    tif->tif_writeproc = writeproc;
    tif->tif_seekproc = seekproc;
    tif->tif_closeproc = closeproc;
    tif->tif_sizeproc = sizeproc;
    if (mapproc)
        tif->tif_mapproc = mapproc;
    else
        tif->tif_mapproc = _tiffDummyMapProc;
    if (unmapproc)
        tif->tif_unmapproc = unmapproc;
    else
        tif->tif_unmapproc = _tiffDummyUnmapProc;
    _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
     * behaviour 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 behaviour 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':
                tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
                    HOST_FILLORDER;
                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) {
            TIFFErrorExt(tif->tif_clientdata, 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
        if (!(tif->tif_flags&TIFF_BIGTIFF))
        {
            tif->tif_header.common.tiff_version = TIFF_VERSION_CLASSIC;
            tif->tif_header.classic.tiff_diroff = 0;
            if (tif->tif_flags & TIFF_SWAB)
                TIFFSwabShort(&tif->tif_header.common.tiff_version);
            tif->tif_header_size = sizeof(TIFFHeaderClassic);
        }
        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;
            if (tif->tif_flags & TIFF_SWAB)
            {
                TIFFSwabShort(&tif->tif_header.common.tiff_version);
                TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
            }
            tif->tif_header_size = sizeof (TIFFHeaderBig);
        }
        /*
         * 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->tif_header, (tmsize_t)(tif->tif_header_size))) {
            TIFFErrorExt(tif->tif_clientdata, name,
                "Error writing TIFF header");
            goto bad;
        }
        /*
         * Setup the byte order handling.
         */
        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
        }
        /*
         * Setup default directory.
         */
        if (!TIFFDefaultDirectory(tif))
            goto bad;
        tif->tif_diroff = 0;
        tif->tif_dirlist = NULL;
        tif->tif_dirlistsize = 0;
        tif->tif_dirnumber = 0;
        return (tif);
    }
    /*
     * Setup the byte order handling.
     */
    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
        ) {
        TIFFErrorExt(tif->tif_clientdata, name,
            "Not a TIFF or MDI file, bad magic number %d (0x%x)",
        #else
        ) {
        TIFFErrorExt(tif->tif_clientdata, name,
            "Not a TIFF file, bad magic number %d (0x%x)",
        #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)) {
        TIFFErrorExt(tif->tif_clientdata, name,
            "Not a TIFF file, bad version number %d (0x%x)",
            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*)(&tif->tif_header) + sizeof(TIFFHeaderClassic)), (sizeof(TIFFHeaderBig)-sizeof(TIFFHeaderClassic))))
        {
            TIFFErrorExt(tif->tif_clientdata, 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)
        {
            TIFFErrorExt(tif->tif_clientdata, name,
                "Not a TIFF file, bad BigTIFF offsetsize %d (0x%x)",
                tif->tif_header.big.tiff_offsetsize,
                tif->tif_header.big.tiff_offsetsize);
            goto bad;
        }
        if (tif->tif_header.big.tiff_unused != 0)
        {
            TIFFErrorExt(tif->tif_clientdata, name,
                "Not a TIFF file, bad BigTIFF unused %d (0x%x)",
                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.
             */
            if (tif->tif_flags & TIFF_HEADERONLY)
                return (tif);
 
            /*
             * Setup initial directory.
             */
            if (TIFFReadDirectory(tif)) {
                tif->tif_rawcc = (tmsize_t)-1;
                tif->tif_flags |= TIFF_BUFFERSETUP;
                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);
}

Referenced by _tiffStreamOpen(), tiff_open_stream(), and TIFFFdOpen().

◆ TIFFClose()

void TIFFClose ( TIFF * tif )

Close a previously opened TIFF file.

TIFFClose closes a file that was previously opened with TIFFOpen(). Any buffered data are flushed to the file, including the contents of the current directory (if modified); and all resources are reclaimed.

Parameters

tif	A TIFF pointer.

Definition at line 122 of file tif_close.c.

{
    TIFFCloseProc closeproc = tif->tif_closeproc;
    thandle_t fd = tif->tif_clientdata;
 
    TIFFCleanup(tif);
    (void) (*closeproc)(fd);
}

Referenced by tiff_decoder_destroy(), tiff_decoder_initialize(), tiff_encoder_commit_file(), and tiff_encoder_destroy().

◆ TIFFComputeStrip()

uint32 TIFFComputeStrip	(	TIFF *	tif,
		uint32	row,
		uint16	sample
	)

Definition at line 36 of file tif_strip.c.

{
    static const char module[] = "TIFFComputeStrip";
    TIFFDirectory *td = &tif->tif_dir;
    uint32 strip;
 
    strip = row / td->td_rowsperstrip;
    if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
        if (sample >= td->td_samplesperpixel) {
            TIFFErrorExt(tif->tif_clientdata, module,
                "%lu: Sample out of range, max %lu",
                (unsigned long) sample, (unsigned long) td->td_samplesperpixel);
            return (0);
        }
        strip += (uint32)sample*td->td_stripsperimage;
    }
    return (strip);
}

Referenced by gtStripContig(), and gtStripSeparate().

◆ TIFFComputeTile()

uint32 TIFFComputeTile	(	TIFF *	tif,
		uint32	x,
		uint32	y,
		uint32	z,
		uint16	s
	)

Definition at line 36 of file tif_tile.c.

{
    TIFFDirectory *td = &tif->tif_dir;
    uint32 dx = td->td_tilewidth;
    uint32 dy = td->td_tilelength;
    uint32 dz = td->td_tiledepth;
    uint32 tile = 1;
 
    if (td->td_imagedepth == 1)
        z = 0;
    if (dx == (uint32) -1)
        dx = td->td_imagewidth;
    if (dy == (uint32) -1)
        dy = td->td_imagelength;
    if (dz == (uint32) -1)
        dz = td->td_imagedepth;
    if (dx != 0 && dy != 0 && dz != 0) {
        uint32 xpt = TIFFhowmany_32(td->td_imagewidth, dx);
        uint32 ypt = TIFFhowmany_32(td->td_imagelength, dy);
        uint32 zpt = TIFFhowmany_32(td->td_imagedepth, dz);
 
        if (td->td_planarconfig == PLANARCONFIG_SEPARATE) 
            tile = (xpt*ypt*zpt)*s +
                 (xpt*ypt)*(z/dz) +
                 xpt*(y/dy) +
                 x/dx;
        else
            tile = (xpt*ypt)*(z/dz) + xpt*(y/dy) + x/dx;
    }
    return (tile);
}

Referenced by _TIFFReadTileAndAllocBuffer(), TIFFReadTile(), and TIFFWriteTile().

◆ TIFFCreateCustomDirectory()

int TIFFCreateCustomDirectory	(	TIFF *	tif,
		const TIFFFieldArray *	infoarray
	)

Definition at line 1340 of file tif_dir.c.

{
    TIFFDefaultDirectory(tif);
 
    /*
     * Reset the field definitions to match the application provided list. 
     * Hopefully TIFFDefaultDirectory() won't have done anything irreversable
     * based on it's assumption this is an image directory.
     */
    _TIFFSetupFields(tif, infoarray);
 
    tif->tif_diroff = 0;
    tif->tif_nextdiroff = 0;
    tif->tif_curoff = 0;
    tif->tif_row = (uint32) -1;
    tif->tif_curstrip = (uint32) -1;
 
    return 0;
}

Referenced by TIFFCreateEXIFDirectory().

◆ TIFFCreateDirectory()

int TIFFCreateDirectory ( TIFF * tif )

Definition at line 1327 of file tif_dir.c.

{
    TIFFDefaultDirectory(tif);
    tif->tif_diroff = 0;
    tif->tif_nextdiroff = 0;
    tif->tif_curoff = 0;
    tif->tif_row = (uint32) -1;
    tif->tif_curstrip = (uint32) -1;
 
    return 0;
}

Referenced by TIFFWriteDirectorySec().

◆ TIFFCreateEXIFDirectory()

int TIFFCreateEXIFDirectory ( TIFF * tif )

Definition at line 1361 of file tif_dir.c.

{
    const TIFFFieldArray* exifFieldArray;
    exifFieldArray = _TIFFGetExifFields();
    return TIFFCreateCustomDirectory(tif, exifFieldArray);
}

◆ TIFFCurrentDirectory()

uint16 TIFFCurrentDirectory ( TIFF * tif )

Definition at line 612 of file tif_open.c.

{
    return (tif->tif_curdir);
}

◆ TIFFCurrentDirOffset()

uint64 TIFFCurrentDirOffset ( TIFF * tif )

Definition at line 1666 of file tif_dir.c.

{
    return (tif->tif_diroff);
}

Referenced by tiff_decoder_get_metadata_blocks().

◆ TIFFCurrentRow()

uint32 TIFFCurrentRow ( TIFF * tif )

Definition at line 603 of file tif_open.c.

{
    return (tif->tif_row);
}

◆ TIFFCurrentStrip()

uint32 TIFFCurrentStrip ( TIFF * tif )

Definition at line 621 of file tif_open.c.

{
    return (tif->tif_curstrip);
}

◆ TIFFCurrentTile()

uint32 TIFFCurrentTile ( TIFF * tif )

Definition at line 630 of file tif_open.c.

{
    return (tif->tif_curtile);
}

◆ TIFFDataWidth()

int TIFFDataWidth ( TIFFDataType type )

Definition at line 438 of file tif_dirinfo.c.

{
    switch(type)
    {
        case 0:  /* nothing */
        case TIFF_BYTE:
        case TIFF_ASCII:
        case TIFF_SBYTE:
        case TIFF_UNDEFINED:
            return 1;
        case TIFF_SHORT:
        case TIFF_SSHORT:
            return 2;
        case TIFF_LONG:
        case TIFF_SLONG:
        case TIFF_FLOAT:
        case TIFF_IFD:
            return 4;
        case TIFF_RATIONAL:
        case TIFF_SRATIONAL:
        case TIFF_DOUBLE:
        case TIFF_LONG8:
        case TIFF_SLONG8:
        case TIFF_IFD8:
            return 8;
        default:
            return 0; /* will return 0 for unknown types */
    }
}

Referenced by _TIFFRewriteField(), EstimateStripByteCounts(), and TIFFReadDirEntryArrayWithLimit().

◆ TIFFDefaultStripSize()

uint32 TIFFDefaultStripSize	(	TIFF *	tif,
		uint32	request
	)

Definition at line 217 of file tif_strip.c.

{
    return (*tif->tif_defstripsize)(tif, request);
}

◆ TIFFDefaultTileSize()

void TIFFDefaultTileSize	(	TIFF *	tif,
		uint32 *	tw,
		uint32 *	th
	)

Definition at line 272 of file tif_tile.c.

{
    (*tif->tif_deftilesize)(tif, tw, th);
}

◆ TIFFDeferStrileArrayWriting()

int TIFFDeferStrileArrayWriting ( TIFF * tif )

Definition at line 210 of file tif_dirwrite.c.

{
    static const char module[] = "TIFFDeferStrileArrayWriting";
    if (tif->tif_mode == O_RDONLY)
    {
        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                     "File opened in read-only mode");
        return 0;
    }
    if( tif->tif_diroff != 0 )
    {
        TIFFErrorExt(tif->tif_clientdata, module,
                     "Directory has already been written");
        return 0;
    }
 
    tif->tif_dir.td_deferstrilearraywriting = TRUE;
    return 1;
}

◆ TIFFError()

void TIFFError	(	const char *	,
		const char *	,
			...
	)

◆ TIFFErrorExt()

void void TIFFErrorExt	(	thandle_t	,
		const char *	,
		const char *	,
			...
	)

◆ TIFFFdOpen()

TIFF * TIFFFdOpen	(	int	fd,
		const char *	name,
		const char *	mode
	)

Definition at line 203 of file tif_unix.c.

{
    TIFF* tif;
 
    fd_as_handle_union_t fdh;
    fdh.fd = fd;
    tif = TIFFClientOpen(name, mode,
        fdh.h,
        _tiffReadProc, _tiffWriteProc,
        _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
        _tiffMapProc, _tiffUnmapProc);
    if (tif)
        tif->tif_fd = fd;
    return (tif);
}

Referenced by TIFFOpen(), and TIFFOpenW().

◆ TIFFFieldDataType()

TIFFDataType TIFFFieldDataType ( const TIFFField * fip )

Definition at line 594 of file tif_dirinfo.c.

{
    return fip->field_type;
}

◆ TIFFFieldName()

const char * TIFFFieldName ( const TIFFField * fip )

Definition at line 588 of file tif_dirinfo.c.

{
    return fip->field_name;
}

◆ TIFFFieldPassCount()

int TIFFFieldPassCount ( const TIFFField * fip )

Definition at line 600 of file tif_dirinfo.c.

{
    return fip->field_passcount;
}

◆ TIFFFieldReadCount()

int TIFFFieldReadCount ( const TIFFField * fip )

Definition at line 606 of file tif_dirinfo.c.

{
    return fip->field_readcount;
}

◆ TIFFFieldTag()

uint32 TIFFFieldTag ( const TIFFField * fip )

Definition at line 582 of file tif_dirinfo.c.

{
    return fip->field_tag;
}

Referenced by TIFFWriteDirectorySec().

◆ TIFFFieldWithName()

const TIFFField * TIFFFieldWithName	(	TIFF *	tif,
		const char *	field_name
	)

Definition at line 570 of file tif_dirinfo.c.

{
    const TIFFField* fip =
        _TIFFFindFieldByName(tif, field_name, TIFF_ANY);
    if (!fip) {
        TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithName",
                 "Internal error, unknown tag %s", field_name);
    }
    return (fip);
}

◆ TIFFFieldWithTag()

const TIFFField * TIFFFieldWithTag	(	TIFF *	tif,
		uint32	tag
	)

Definition at line 558 of file tif_dirinfo.c.

{
    const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY);
    if (!fip) {
        TIFFErrorExt(tif->tif_clientdata, "TIFFFieldWithTag",
                 "Internal error, unknown tag 0x%x",
                 (unsigned int) tag);
    }
    return (fip);
}

Referenced by _TIFFVSetField(), CheckDirCount(), TIFFFetchStripThing(), TIFFPrintDirectory(), TIFFReadDirectory(), and TIFFUnsetField().

◆ TIFFFieldWriteCount()

int TIFFFieldWriteCount ( const TIFFField * fip )

Definition at line 612 of file tif_dirinfo.c.

{
    return fip->field_writecount;
}

◆ TIFFFileName()

const char * TIFFFileName ( TIFF * tif )

Definition at line 513 of file tif_open.c.

{
    return (tif->tif_name);
}

Referenced by _TIFFReadEncodedStripAndAllocBuffer(), _TIFFReadEncodedTileAndAllocBuffer(), buildMap(), gtStripContig(), gtStripSeparate(), gtTileContig(), makebwmap(), makecmap(), setupMap(), TIFFReadRGBAImageOriented(), TIFFReadRGBAStripExt(), TIFFReadRGBATileExt(), and TIFFRGBAImageGet().

◆ TIFFFileno()

int TIFFFileno ( TIFF * tif )

Definition at line 533 of file tif_open.c.

{
    return (tif->tif_fd);
}

◆ TIFFFindCODEC()

const TIFFCodec * TIFFFindCODEC ( uint16 scheme )

Definition at line 186 of file tif_compress.c.

{
    const TIFFCodec* c;
    codec_t* cd;
 
    for (cd = registeredCODECS; cd; cd = cd->next)
        if (cd->info->scheme == scheme)
            return ((const TIFFCodec*) cd->info);
    for (c = _TIFFBuiltinCODECS; c->name; c++)
        if (c->scheme == scheme)
            return (c);
    return ((const TIFFCodec*) 0);
}

Referenced by _notConfigured(), TIFFIsCODECConfigured(), TIFFNoDecode(), TIFFNoEncode(), TIFFPrintDirectory(), and TIFFSetCompressionScheme().

◆ TIFFFindField()

const TIFFField * TIFFFindField	(	TIFF *	tif,
		uint32	tag,
		TIFFDataType	dt
	)

Definition at line 506 of file tif_dirinfo.c.

{
    TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0, 0, 0, NULL, NULL};
    TIFFField* pkey = &key;
    const TIFFField **ret;
    if (tif->tif_foundfield && tif->tif_foundfield->field_tag == tag &&
        (dt == TIFF_ANY || dt == tif->tif_foundfield->field_type))
        return tif->tif_foundfield;
 
    /* If we are invoked with no field information, then just return. */
    if (!tif->tif_fields)
        return NULL;
 
    /* NB: use sorted search (e.g. binary search) */
 
    key.field_tag = tag;
    key.field_type = dt;
 
    ret = (const TIFFField **) bsearch(&pkey, tif->tif_fields,
                       tif->tif_nfields,
                       sizeof(TIFFField *), tagCompare);
    return tif->tif_foundfield = (ret ? *ret : NULL);
}

Referenced by _TIFFFindOrRegisterField(), _TIFFMergeFields(), _TIFFRewriteField(), _TIFFVGetField(), _TIFFVSetField(), OkToChangeTag(), TIFFFieldWithTag(), and TIFFVGetField().

◆ TIFFFlush()

int TIFFFlush ( TIFF * tif )

Definition at line 32 of file tif_flush.c.

{
    if( tif->tif_mode == O_RDONLY )
        return 1;
 
    if (!TIFFFlushData(tif))
        return (0);
                
    /* In update (r+) mode we try to detect the case where 
       only the strip/tile map has been altered, and we try to 
       rewrite only that portion of the directory without 
       making any other changes */
                
    if( (tif->tif_flags & TIFF_DIRTYSTRIP)
        && !(tif->tif_flags & TIFF_DIRTYDIRECT) 
        && tif->tif_mode == O_RDWR )
    {
        if( TIFFForceStrileArrayWriting(tif) )
            return 1;
    }
 
    if ((tif->tif_flags & (TIFF_DIRTYDIRECT|TIFF_DIRTYSTRIP)) 
        && !TIFFRewriteDirectory(tif))
        return (0);
 
    return (1);
}

Referenced by TIFFCleanup().

◆ TIFFFlushData()

int TIFFFlushData ( TIFF * tif )

Definition at line 156 of file tif_flush.c.

{
    if ((tif->tif_flags & TIFF_BEENWRITING) == 0)
        return (1);
    if (tif->tif_flags & TIFF_POSTENCODE) {
        tif->tif_flags &= ~TIFF_POSTENCODE;
        if (!(*tif->tif_postencode)(tif))
            return (0);
    }
    return (TIFFFlushData1(tif));
}

Referenced by TIFFFlush(), and TIFFWriteScanline().

◆ TIFFForceStrileArrayWriting()

int TIFFForceStrileArrayWriting ( TIFF * tif )

Definition at line 79 of file tif_flush.c.

{
    static const char module[] = "TIFFForceStrileArrayWriting";
    const int isTiled = TIFFIsTiled(tif);
 
    if (tif->tif_mode == O_RDONLY)
    {
        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                     "File opened in read-only mode");
        return 0;
    }
    if( tif->tif_diroff == 0 )
    {
        TIFFErrorExt(tif->tif_clientdata, module,
                     "Directory has not yet been written");
        return 0;
    }
    if( (tif->tif_flags & TIFF_DIRTYDIRECT) != 0 )
    {
        TIFFErrorExt(tif->tif_clientdata, module,
                     "Directory has changes other than the strile arrays. "
                     "TIFFRewriteDirectory() should be called instead");
        return 0;
    }
 
    if( !(tif->tif_flags & TIFF_DIRTYSTRIP) )
    {
        if( !(tif->tif_dir.td_stripoffset_entry.tdir_tag != 0 &&
             tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
             tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
             tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 &&
             tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0 &&
             tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
             tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
             tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0) )
        {
            TIFFErrorExt(tif->tif_clientdata, module,
                        "Function not called together with "
                        "TIFFDeferStrileArrayWriting()");
            return 0;
        }
 
        if (tif->tif_dir.td_stripoffset_p == NULL && !TIFFSetupStrips(tif))
            return 0;
    }
 
    if( _TIFFRewriteField( tif,
                           isTiled ? TIFFTAG_TILEOFFSETS :
                                     TIFFTAG_STRIPOFFSETS,
                           TIFF_LONG8,
                           tif->tif_dir.td_nstrips,
                           tif->tif_dir.td_stripoffset_p )
        && _TIFFRewriteField( tif,
                              isTiled ? TIFFTAG_TILEBYTECOUNTS :
                                        TIFFTAG_STRIPBYTECOUNTS,
                              TIFF_LONG8,
                              tif->tif_dir.td_nstrips,
                              tif->tif_dir.td_stripbytecount_p ) )
    {
        tif->tif_flags &= ~TIFF_DIRTYSTRIP;
        tif->tif_flags &= ~TIFF_BEENWRITING;
        return 1;
    }
 
    return 0;
}

Referenced by TIFFFlush(), and TIFFWriteCheck().

◆ TIFFFreeDirectory()

void TIFFFreeDirectory ( TIFF * tif )

Definition at line 1268 of file tif_dir.c.

{
    TIFFDirectory *td = &tif->tif_dir;
    int            i;
 
    _TIFFmemset(td->td_fieldsset, 0, FIELD_SETLONGS);
    CleanupField(td_sminsamplevalue);
    CleanupField(td_smaxsamplevalue);
    CleanupField(td_colormap[0]);
    CleanupField(td_colormap[1]);
    CleanupField(td_colormap[2]);
    CleanupField(td_sampleinfo);
    CleanupField(td_subifd);
    CleanupField(td_inknames);
    CleanupField(td_refblackwhite);
    CleanupField(td_transferfunction[0]);
    CleanupField(td_transferfunction[1]);
    CleanupField(td_transferfunction[2]);
    CleanupField(td_stripoffset_p);
    CleanupField(td_stripbytecount_p);
        td->td_stripoffsetbyteallocsize = 0;
    TIFFClrFieldBit(tif, FIELD_YCBCRSUBSAMPLING);
    TIFFClrFieldBit(tif, FIELD_YCBCRPOSITIONING);
 
    /* Cleanup custom tag values */
    for( i = 0; i < td->td_customValueCount; i++ ) {
        if (td->td_customValues[i].value)
            _TIFFfree(td->td_customValues[i].value);
    }
 
    td->td_customValueCount = 0;
    CleanupField(td_customValues);
 
        _TIFFmemset( &(td->td_stripoffset_entry), 0, sizeof(TIFFDirEntry));
        _TIFFmemset( &(td->td_stripbytecount_entry), 0, sizeof(TIFFDirEntry));
}

Referenced by TIFFCleanup(), TIFFReadCustomDirectory(), TIFFReadDirectory(), TIFFUnlinkDirectory(), and TIFFWriteDirectorySec().

◆ TIFFGetBitRevTable()

const unsigned char * TIFFGetBitRevTable ( int reversed )

Definition at line 278 of file tif_swab.c.

{
    return (reversed ? TIFFBitRevTable : TIFFNoBitRevTable);
}

◆ TIFFGetClientInfo()

void * TIFFGetClientInfo	(	TIFF *	tif,
		const char *	name
	)

Definition at line 64 of file tif_extension.c.

{
    TIFFClientInfoLink *psLink = tif->tif_clientinfo;
 
    while( psLink != NULL && strcmp(psLink->name,name) != 0 )
        psLink = psLink->next;
 
    if( psLink != NULL )
        return psLink->data;
    else
        return NULL;
}

◆ TIFFGetCloseProc()

TIFFCloseProc TIFFGetCloseProc ( TIFF * tif )

Definition at line 702 of file tif_open.c.

{
    return (tif->tif_closeproc);
}

◆ TIFFGetConfiguredCODECs()

TIFFCodec * TIFFGetConfiguredCODECs ( void )

Get list of configured codecs, both built-in and registered by user. Caller is responsible to free this structure.

Returns: returns array of TIFFCodec records (the last record should be NULL) or NULL if function failed.

Definition at line 252 of file tif_compress.c.

{
    int i = 1;
    codec_t *cd;
    const TIFFCodec* c;
    TIFFCodec* codecs = NULL;
    TIFFCodec* new_codecs;
 
    for (cd = registeredCODECS; cd; cd = cd->next) {
        new_codecs = (TIFFCodec *)
            _TIFFrealloc(codecs, i * sizeof(TIFFCodec));
        if (!new_codecs) {
            _TIFFfree (codecs);
            return NULL;
        }
        codecs = new_codecs;
        _TIFFmemcpy(codecs + i - 1, cd, sizeof(TIFFCodec));
        i++;
    }
    for (c = _TIFFBuiltinCODECS; c->name; c++) {
        if (TIFFIsCODECConfigured(c->scheme)) {
            new_codecs = (TIFFCodec *)
                _TIFFrealloc(codecs, i * sizeof(TIFFCodec));
            if (!new_codecs) {
                _TIFFfree (codecs);
                return NULL;
            }
            codecs = new_codecs;
            _TIFFmemcpy(codecs + i - 1, (const void*)c, sizeof(TIFFCodec));
            i++;
        }
    }
 
    new_codecs = (TIFFCodec *) _TIFFrealloc(codecs, i * sizeof(TIFFCodec));
    if (!new_codecs) {
        _TIFFfree (codecs);
        return NULL;
    }
    codecs = new_codecs;
    _TIFFmemset(codecs + i - 1, 0, sizeof(TIFFCodec));
 
    return codecs;
}

◆ TIFFGetField()

int TIFFGetField	(	TIFF *	tif,
		uint32	tag,
			...
	)

Definition at line 1232 of file tif_dir.c.

{
    int status;
    va_list ap;
 
    va_start(ap, tag);
    status = TIFFVGetField(tif, tag, ap);
    va_end(ap);
    return (status);
}

Referenced by gtTileContig(), gtTileSeparate(), isCCITTCompression(), tiff_decoder_get_color_context(), tiff_get_decode_info(), TIFFPrintDirectory(), TIFFRGBAImageBegin(), TIFFRGBAImageOK(), and TIFFWriteDirectorySec().

◆ TIFFGetFieldDefaulted()

int TIFFGetFieldDefaulted	(	TIFF *	tif,
		uint32	tag,
			...
	)

Definition at line 345 of file tif_aux.c.

{
    int ok;
    va_list ap;
 
    va_start(ap, tag);
    ok =  TIFFVGetFieldDefaulted(tif, tag, ap);
    va_end(ap);
    return (ok);
}

Referenced by gtStripContig(), gtStripSeparate(), initCIELabConversion(), initYCbCrConversion(), PickContigCase(), PickSeparateCase(), TIFFReadRGBAStripExt(), TIFFReadRGBATileExt(), TIFFRGBAImageBegin(), TIFFRGBAImageOK(), TIFFScanlineSize64(), TIFFVStripSize64(), TIFFVTileSize64(), and TIFFWriteDirectorySec().

◆ TIFFGetMapFileProc()

TIFFMapFileProc TIFFGetMapFileProc ( TIFF * tif )

Definition at line 720 of file tif_open.c.

{
    return (tif->tif_mapproc);
}

◆ TIFFGetMode()

int TIFFGetMode ( TIFF * tif )

Definition at line 573 of file tif_open.c.

{
    return (tif->tif_mode);
}

◆ TIFFGetReadProc()

TIFFReadWriteProc TIFFGetReadProc ( TIFF * tif )

Definition at line 675 of file tif_open.c.

{
    return (tif->tif_readproc);
}

◆ TIFFGetSeekProc()

TIFFSeekProc TIFFGetSeekProc ( TIFF * tif )

Definition at line 693 of file tif_open.c.

{
    return (tif->tif_seekproc);
}

◆ TIFFGetSizeProc()

TIFFSizeProc TIFFGetSizeProc ( TIFF * tif )

Definition at line 711 of file tif_open.c.

{
    return (tif->tif_sizeproc);
}

◆ TIFFGetStrileByteCount()

uint64 TIFFGetStrileByteCount	(	TIFF *	tif,
		uint32	strile
	)

Definition at line 6305 of file tif_dirread.c.

{
    return TIFFGetStrileByteCountWithErr(tif, strile, NULL);
}

Referenced by allocChoppedUpStripArrays(), ByteCountLooksBad(), ChopUpSingleUncompressedStrip(), TIFFFillStrip(), TIFFFillStripPartial(), TIFFFillTile(), TIFFPrintDirectory(), TIFFRawStripSize64(), TIFFReadDirectory(), TIFFReadRawStrip(), TIFFReadRawTile(), TIFFSeek(), TIFFStartStrip(), TIFFStartTile(), and TryChopUpUncompressedBigTiff().

◆ TIFFGetStrileByteCountWithErr()

uint64 TIFFGetStrileByteCountWithErr	(	TIFF *	tif,
		uint32	strile,
		int *	pbErr
	)

Definition at line 6311 of file tif_dirread.c.

{
    TIFFDirectory *td = &tif->tif_dir;
    return _TIFFGetStrileOffsetOrByteCountValue(tif, strile,
                               &(td->td_stripbytecount_entry),
                               &(td->td_stripbytecount_p), pbErr);
}

Referenced by TIFFGetStrileByteCount().

◆ TIFFGetStrileOffset()

uint64 TIFFGetStrileOffset	(	TIFF *	tif,
		uint32	strile
	)

Definition at line 6290 of file tif_dirread.c.

{
    return TIFFGetStrileOffsetWithErr(tif, strile, NULL);
}

Referenced by allocChoppedUpStripArrays(), ByteCountLooksBad(), TIFFFillStrip(), TIFFFillStripPartial(), TIFFFillTile(), TIFFPrintDirectory(), TIFFReadDirectory(), TIFFReadRawStrip1(), TIFFReadRawStripOrTile2(), TIFFReadRawTile1(), and TryChopUpUncompressedBigTiff().

◆ TIFFGetStrileOffsetWithErr()

uint64 TIFFGetStrileOffsetWithErr	(	TIFF *	tif,
		uint32	strile,
		int *	pbErr
	)

Definition at line 6296 of file tif_dirread.c.

{
    TIFFDirectory *td = &tif->tif_dir;
    return _TIFFGetStrileOffsetOrByteCountValue(tif, strile,
                               &(td->td_stripoffset_entry),
                               &(td->td_stripoffset_p), pbErr);
}

Referenced by TIFFGetStrileOffset().

◆ TIFFGetTagListCount()

int TIFFGetTagListCount ( TIFF * tif )

Definition at line 34 of file tif_extension.c.

{
    TIFFDirectory* td = &tif->tif_dir;
    
    return td->td_customValueCount;
}

Referenced by TIFFPrintDirectory().

◆ TIFFGetTagListEntry()

uint32 TIFFGetTagListEntry	(	TIFF *	tif,
		int	tag_index
	)

Definition at line 42 of file tif_extension.c.

{
    TIFFDirectory* td = &tif->tif_dir;
 
    if( tag_index < 0 || tag_index >= td->td_customValueCount )
        return (uint32)(-1);
    else
        return td->td_customValues[tag_index].info->field_tag;
}

Referenced by TIFFPrintDirectory().

◆ TIFFGetUnmapFileProc()

TIFFUnmapFileProc TIFFGetUnmapFileProc ( TIFF * tif )

Definition at line 729 of file tif_open.c.

{
    return (tif->tif_unmapproc);
}

◆ TIFFGetVersion()

const char * TIFFGetVersion ( void )

Definition at line 29 of file tif_version.c.

{
    return (TIFFVersion);
}

◆ TIFFGetWriteProc()

TIFFReadWriteProc TIFFGetWriteProc ( TIFF * tif )

Definition at line 684 of file tif_open.c.

{
    return (tif->tif_writeproc);
}

◆ TIFFIsBigEndian()

int TIFFIsBigEndian ( TIFF * tif )

Definition at line 666 of file tif_open.c.

{
    return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN);
}

◆ TIFFIsByteSwapped()

int TIFFIsByteSwapped ( TIFF * tif )

Definition at line 639 of file tif_open.c.

{
    return ((tif->tif_flags & TIFF_SWAB) != 0);
}

Referenced by tiff_decoder_get_metadata_blocks(), and tiff_decoder_read_tile().

◆ TIFFIsCODECConfigured()

int TIFFIsCODECConfigured ( uint16 scheme )

Check whether we have working codec for the specific coding scheme.

Returns: returns 1 if the codec is configured and working. Otherwise 0 will be returned.

Definition at line 150 of file tif_codec.c.

{
    const TIFFCodec* codec = TIFFFindCODEC(scheme);
 
    if(codec == NULL) {
        return 0;
    }
    if(codec->init == NULL) {
        return 0;
    }
    if(codec->init != NotConfigured){
        return 1;
    }
    return 0;
}

Referenced by TIFFGetConfiguredCODECs().

◆ TIFFIsMSB2LSB()

int TIFFIsMSB2LSB ( TIFF * tif )

Definition at line 657 of file tif_open.c.

{
    return (isFillOrder(tif, FILLORDER_MSB2LSB));
}

◆ TIFFIsTiled()

int TIFFIsTiled ( TIFF * tif )

Definition at line 594 of file tif_open.c.

{
    return (isTiled(tif));
}

Referenced by PickContigCase(), PickSeparateCase(), TIFFForceStrileArrayWriting(), TIFFReadFromUserBuffer(), TIFFReadRGBAStripExt(), and TIFFReadRGBATileExt().

◆ TIFFIsUpSampled()

int TIFFIsUpSampled ( TIFF * tif )

Definition at line 648 of file tif_open.c.

{
    return (isUpSampled(tif));
}

◆ TIFFLastDirectory()

int TIFFLastDirectory ( TIFF * tif )

Definition at line 1676 of file tif_dir.c.

{
    return (tif->tif_nextdiroff == 0);
}

◆ TIFFMergeFieldInfo()

int TIFFMergeFieldInfo	(	TIFF *	tif,
		const	TIFFFieldInfo[],
		uint32	n
	)

Definition at line 888 of file tif_dirinfo.c.

{
    static const char module[] = "TIFFMergeFieldInfo";
    static const char reason[] = "for fields array";
    TIFFField *tp;
    size_t nfields;
    uint32 i;
 
    if (tif->tif_nfieldscompat > 0) {
        tif->tif_fieldscompat = (TIFFFieldArray *)
            _TIFFCheckRealloc(tif, tif->tif_fieldscompat,
                      tif->tif_nfieldscompat + 1,
                      sizeof(TIFFFieldArray), reason);
    } else {
        tif->tif_fieldscompat = (TIFFFieldArray *)
            _TIFFCheckMalloc(tif, 1, sizeof(TIFFFieldArray),
                     reason);
    }
    if (!tif->tif_fieldscompat) {
        TIFFErrorExt(tif->tif_clientdata, module,
                 "Failed to allocate fields array");
        return -1;
    }
    nfields = tif->tif_nfieldscompat++;
 
    tif->tif_fieldscompat[nfields].type = tfiatOther;
    tif->tif_fieldscompat[nfields].allocated_size = n;
    tif->tif_fieldscompat[nfields].count = n;
    tif->tif_fieldscompat[nfields].fields =
        (TIFFField *)_TIFFCheckMalloc(tif, n, sizeof(TIFFField),
                          reason);
    if (!tif->tif_fieldscompat[nfields].fields) {
        TIFFErrorExt(tif->tif_clientdata, module,
                 "Failed to allocate fields array");
        return -1;
    }
 
    tp = tif->tif_fieldscompat[nfields].fields;
    for (i = 0; i < n; i++) {
        tp->field_tag = info[i].field_tag;
        tp->field_readcount = info[i].field_readcount;
        tp->field_writecount = info[i].field_writecount;
        tp->field_type = info[i].field_type;
        tp->reserved = 0;
        tp->set_field_type =
             _TIFFSetGetType(info[i].field_type,
                info[i].field_readcount,
                info[i].field_passcount);
        tp->get_field_type =
             _TIFFSetGetType(info[i].field_type,
                info[i].field_readcount,
                info[i].field_passcount);
        tp->field_bit = info[i].field_bit;
        tp->field_oktochange = info[i].field_oktochange;
        tp->field_passcount = info[i].field_passcount;
        tp->field_name = info[i].field_name;
        tp->field_subfields = NULL;
        tp++;
    }
 
    if (!_TIFFMergeFields(tif, tif->tif_fieldscompat[nfields].fields, n)) {
        TIFFErrorExt(tif->tif_clientdata, module,
                 "Setting up field info failed");
        return -1;
    }
 
    return 0;
}

◆ TIFFNumberOfDirectories()

uint16 TIFFNumberOfDirectories ( TIFF * tif )

Definition at line 1586 of file tif_dir.c.

{
    static const char module[] = "TIFFNumberOfDirectories";
    uint64 nextdir;
    uint16 n;
    if (!(tif->tif_flags&TIFF_BIGTIFF))
        nextdir = tif->tif_header.classic.tiff_diroff;
    else
        nextdir = tif->tif_header.big.tiff_diroff;
    n = 0;
    while (nextdir != 0 && TIFFAdvanceDirectory(tif, &nextdir, NULL))
        {
                if (n != 65535) {
                        ++n;
                }
        else
                {
                        TIFFErrorExt(tif->tif_clientdata, module,
                                     "Directory count exceeded 65535 limit,"
                                     " giving up on counting.");
                        return (65535);
                }
        }
    return (n);
}

Referenced by tiff_decoder_initialize().

◆ TIFFNumberOfStrips()

uint32 TIFFNumberOfStrips ( TIFF * tif )

Definition at line 59 of file tif_strip.c.

{
    TIFFDirectory *td = &tif->tif_dir;
    uint32 nstrips;
 
    nstrips = (td->td_rowsperstrip == (uint32) -1 ? 1 :
         TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip));
    if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
        nstrips = _TIFFMultiply32(tif, nstrips, (uint32)td->td_samplesperpixel,
            "TIFFNumberOfStrips");
    return (nstrips);
}

Referenced by TIFFReadDirectory(), and TIFFSetupStrips().

◆ TIFFNumberOfTiles()

uint32 TIFFNumberOfTiles ( TIFF * tif )

Definition at line 113 of file tif_tile.c.

{
    TIFFDirectory *td = &tif->tif_dir;
    uint32 dx = td->td_tilewidth;
    uint32 dy = td->td_tilelength;
    uint32 dz = td->td_tiledepth;
    uint32 ntiles;
 
    if (dx == (uint32) -1)
        dx = td->td_imagewidth;
    if (dy == (uint32) -1)
        dy = td->td_imagelength;
    if (dz == (uint32) -1)
        dz = td->td_imagedepth;
    ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 :
        _TIFFMultiply32(tif, _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
        TIFFhowmany_32(td->td_imagelength, dy),
        "TIFFNumberOfTiles"),
        TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
    if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
        ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
            "TIFFNumberOfTiles");
    return (ntiles);
}

Referenced by TIFFReadDirectory(), and TIFFSetupStrips().

◆ TIFFOpen()

TIFF * TIFFOpen	(	const char *	name,
		const char *	mode
	)

Definition at line 223 of file tif_unix.c.

{
    static const char module[] = "TIFFOpen";
    int m, fd;
    TIFF* tif;
 
    m = _TIFFgetMode(mode, module);
    if (m == -1)
        return ((TIFF*)0);
 
/* for cygwin and mingw */
#ifdef O_BINARY
    m |= O_BINARY;
#endif
 
    fd = open(name, m, 0666);
    if (fd < 0) {
        if (errno > 0 && strerror(errno) != NULL ) {
            TIFFErrorExt(0, module, "%s: %s", name, strerror(errno) );
        } else {
            TIFFErrorExt(0, module, "%s: Cannot open", name);
        }
        return ((TIFF *)0);
    }
 
    tif = TIFFFdOpen((int)fd, name, mode);
    if(!tif)
        close(fd);
    return tif;
}

◆ TIFFPrintDirectory()

void TIFFPrintDirectory	(	TIFF *	tif,
		FILE *	fd,
		long	flags
	)

Definition at line 234 of file tif_print.c.

{
    TIFFDirectory *td = &tif->tif_dir;
    char *sep;
    long l, n;
 
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
    fprintf(fd, "TIFF Directory at offset 0x%I64x (%I64u)\n",
        (unsigned __int64) tif->tif_diroff,
        (unsigned __int64) tif->tif_diroff);
#else
    fprintf(fd, "TIFF Directory at offset 0x%llx (%llu)\n",
        (unsigned long long) tif->tif_diroff,
        (unsigned long long) tif->tif_diroff);
#endif
    if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) {
        fprintf(fd, "  Subfile Type:");
        sep = " ";
        if (td->td_subfiletype & FILETYPE_REDUCEDIMAGE) {
            fprintf(fd, "%sreduced-resolution image", sep);
            sep = "/";
        }
        if (td->td_subfiletype & FILETYPE_PAGE) {
            fprintf(fd, "%smulti-page document", sep);
            sep = "/";
        }
        if (td->td_subfiletype & FILETYPE_MASK)
            fprintf(fd, "%stransparency mask", sep);
        fprintf(fd, " (%lu = 0x%lx)\n",
            (unsigned long) td->td_subfiletype, (long) td->td_subfiletype);
    }
    if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) {
        fprintf(fd, "  Image Width: %lu Image Length: %lu",
            (unsigned long) td->td_imagewidth, (unsigned long) td->td_imagelength);
        if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH))
            fprintf(fd, " Image Depth: %lu",
                (unsigned long) td->td_imagedepth);
        fprintf(fd, "\n");
    }
    if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)) {
        fprintf(fd, "  Tile Width: %lu Tile Length: %lu",
            (unsigned long) td->td_tilewidth, (unsigned long) td->td_tilelength);
        if (TIFFFieldSet(tif,FIELD_TILEDEPTH))
            fprintf(fd, " Tile Depth: %lu",
                (unsigned long) td->td_tiledepth);
        fprintf(fd, "\n");
    }
    if (TIFFFieldSet(tif,FIELD_RESOLUTION)) {
        fprintf(fd, "  Resolution: %g, %g",
            td->td_xresolution, td->td_yresolution);
        if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)) {
            switch (td->td_resolutionunit) {
            case RESUNIT_NONE:
                fprintf(fd, " (unitless)");
                break;
            case RESUNIT_INCH:
                fprintf(fd, " pixels/inch");
                break;
            case RESUNIT_CENTIMETER:
                fprintf(fd, " pixels/cm");
                break;
            default:
                fprintf(fd, " (unit %u = 0x%x)",
                    td->td_resolutionunit,
                    td->td_resolutionunit);
                break;
            }
        }
        fprintf(fd, "\n");
    }
    if (TIFFFieldSet(tif,FIELD_POSITION))
        fprintf(fd, "  Position: %g, %g\n",
            td->td_xposition, td->td_yposition);
    if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))
        fprintf(fd, "  Bits/Sample: %u\n", td->td_bitspersample);
    if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)) {
        fprintf(fd, "  Sample Format: ");
        switch (td->td_sampleformat) {
        case SAMPLEFORMAT_VOID:
            fprintf(fd, "void\n");
            break;
        case SAMPLEFORMAT_INT:
            fprintf(fd, "signed integer\n");
            break;
        case SAMPLEFORMAT_UINT:
            fprintf(fd, "unsigned integer\n");
            break;
        case SAMPLEFORMAT_IEEEFP:
            fprintf(fd, "IEEE floating point\n");
            break;
        case SAMPLEFORMAT_COMPLEXINT:
            fprintf(fd, "complex signed integer\n");
            break;
        case SAMPLEFORMAT_COMPLEXIEEEFP:
            fprintf(fd, "complex IEEE floating point\n");
            break;
        default:
            fprintf(fd, "%u (0x%x)\n",
                td->td_sampleformat, td->td_sampleformat);
            break;
        }
    }
    if (TIFFFieldSet(tif,FIELD_COMPRESSION)) {
        const TIFFCodec* c = TIFFFindCODEC(td->td_compression);
        fprintf(fd, "  Compression Scheme: ");
        if (c)
            fprintf(fd, "%s\n", c->name);
        else
            fprintf(fd, "%u (0x%x)\n",
                td->td_compression, td->td_compression);
    }
    if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) {
        fprintf(fd, "  Photometric Interpretation: ");
        if (td->td_photometric < NPHOTONAMES)
            fprintf(fd, "%s\n", photoNames[td->td_photometric]);
        else {
            switch (td->td_photometric) {
            case PHOTOMETRIC_LOGL:
                fprintf(fd, "CIE Log2(L)\n");
                break;
            case PHOTOMETRIC_LOGLUV:
                fprintf(fd, "CIE Log2(L) (u',v')\n");
                break;
            default:
                fprintf(fd, "%u (0x%x)\n",
                    td->td_photometric, td->td_photometric);
                break;
            }
        }
    }
    if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES) && td->td_extrasamples) {
        uint16 i;
        fprintf(fd, "  Extra Samples: %u<", td->td_extrasamples);
        sep = "";
        for (i = 0; i < td->td_extrasamples; i++) {
            switch (td->td_sampleinfo[i]) {
            case EXTRASAMPLE_UNSPECIFIED:
                fprintf(fd, "%sunspecified", sep);
                break;
            case EXTRASAMPLE_ASSOCALPHA:
                fprintf(fd, "%sassoc-alpha", sep);
                break;
            case EXTRASAMPLE_UNASSALPHA:
                fprintf(fd, "%sunassoc-alpha", sep);
                break;
            default:
                fprintf(fd, "%s%u (0x%x)", sep,
                    td->td_sampleinfo[i], td->td_sampleinfo[i]);
                break;
            }
            sep = ", ";
        }
        fprintf(fd, ">\n");
    }
    if (TIFFFieldSet(tif,FIELD_INKNAMES)) {
        char* cp;
        uint16 i;
        fprintf(fd, "  Ink Names: ");
        i = td->td_samplesperpixel;
        sep = "";
        for (cp = td->td_inknames; 
             i > 0 && cp < td->td_inknames + td->td_inknameslen; 
             cp = strchr(cp,'\0')+1, i--) {
            size_t max_chars = 
                td->td_inknameslen - (cp - td->td_inknames);
            fputs(sep, fd);
            _TIFFprintAsciiBounded(fd, cp, max_chars);
            sep = ", ";
        }
                fputs("\n", fd);
    }
    if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)) {
        fprintf(fd, "  Thresholding: ");
        switch (td->td_threshholding) {
        case THRESHHOLD_BILEVEL:
            fprintf(fd, "bilevel art scan\n");
            break;
        case THRESHHOLD_HALFTONE:
            fprintf(fd, "halftone or dithered scan\n");
            break;
        case THRESHHOLD_ERRORDIFFUSE:
            fprintf(fd, "error diffused\n");
            break;
        default:
            fprintf(fd, "%u (0x%x)\n",
                td->td_threshholding, td->td_threshholding);
            break;
        }
    }
    if (TIFFFieldSet(tif,FIELD_FILLORDER)) {
        fprintf(fd, "  FillOrder: ");
        switch (td->td_fillorder) {
        case FILLORDER_MSB2LSB:
            fprintf(fd, "msb-to-lsb\n");
            break;
        case FILLORDER_LSB2MSB:
            fprintf(fd, "lsb-to-msb\n");
            break;
        default:
            fprintf(fd, "%u (0x%x)\n",
                td->td_fillorder, td->td_fillorder);
            break;
        }
    }
    if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING))
        {
        fprintf(fd, "  YCbCr Subsampling: %u, %u\n",
            td->td_ycbcrsubsampling[0], td->td_ycbcrsubsampling[1] );
    }
    if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) {
        fprintf(fd, "  YCbCr Positioning: ");
        switch (td->td_ycbcrpositioning) {
        case YCBCRPOSITION_CENTERED:
            fprintf(fd, "centered\n");
            break;
        case YCBCRPOSITION_COSITED:
            fprintf(fd, "cosited\n");
            break;
        default:
            fprintf(fd, "%u (0x%x)\n",
                td->td_ycbcrpositioning, td->td_ycbcrpositioning);
            break;
        }
    }
    if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS))
        fprintf(fd, "  Halftone Hints: light %u dark %u\n",
            td->td_halftonehints[0], td->td_halftonehints[1]);
    if (TIFFFieldSet(tif,FIELD_ORIENTATION)) {
        fprintf(fd, "  Orientation: ");
        if (td->td_orientation < NORIENTNAMES)
            fprintf(fd, "%s\n", orientNames[td->td_orientation]);
        else
            fprintf(fd, "%u (0x%x)\n",
                td->td_orientation, td->td_orientation);
    }
    if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
        fprintf(fd, "  Samples/Pixel: %u\n", td->td_samplesperpixel);
    if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)) {
        fprintf(fd, "  Rows/Strip: ");
        if (td->td_rowsperstrip == (uint32) -1)
            fprintf(fd, "(infinite)\n");
        else
            fprintf(fd, "%lu\n", (unsigned long) td->td_rowsperstrip);
    }
    if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE))
        fprintf(fd, "  Min Sample Value: %u\n", td->td_minsamplevalue);
    if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE))
        fprintf(fd, "  Max Sample Value: %u\n", td->td_maxsamplevalue);
    if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE)) {
        int i;
        int count = (tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplesperpixel : 1;
        fprintf(fd, "  SMin Sample Value:");
        for (i = 0; i < count; ++i)
            fprintf(fd, " %g", td->td_sminsamplevalue[i]);
        fprintf(fd, "\n");
    }
    if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE)) {
        int i;
        int count = (tif->tif_flags & TIFF_PERSAMPLE) ? td->td_samplesperpixel : 1;
        fprintf(fd, "  SMax Sample Value:");
        for (i = 0; i < count; ++i)
            fprintf(fd, " %g", td->td_smaxsamplevalue[i]);
        fprintf(fd, "\n");
    }
    if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) {
        fprintf(fd, "  Planar Configuration: ");
        switch (td->td_planarconfig) {
        case PLANARCONFIG_CONTIG:
            fprintf(fd, "single image plane\n");
            break;
        case PLANARCONFIG_SEPARATE:
            fprintf(fd, "separate image planes\n");
            break;
        default:
            fprintf(fd, "%u (0x%x)\n",
                td->td_planarconfig, td->td_planarconfig);
            break;
        }
    }
    if (TIFFFieldSet(tif,FIELD_PAGENUMBER))
        fprintf(fd, "  Page Number: %u-%u\n",
            td->td_pagenumber[0], td->td_pagenumber[1]);
    if (TIFFFieldSet(tif,FIELD_COLORMAP)) {
        fprintf(fd, "  Color Map: ");
        if (flags & TIFFPRINT_COLORMAP) {
            fprintf(fd, "\n");
            n = 1L<<td->td_bitspersample;
            for (l = 0; l < n; l++)
                fprintf(fd, "   %5ld: %5u %5u %5u\n",
                    l,
                    td->td_colormap[0][l],
                    td->td_colormap[1][l],
                    td->td_colormap[2][l]);
        } else
            fprintf(fd, "(present)\n");
    }
    if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE)) {
        int i;
        fprintf(fd, "  Reference Black/White:\n");
        for (i = 0; i < 3; i++)
        fprintf(fd, "    %2d: %5g %5g\n", i,
            td->td_refblackwhite[2*i+0],
            td->td_refblackwhite[2*i+1]);
    }
    if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) {
        fprintf(fd, "  Transfer Function: ");
        if (flags & TIFFPRINT_CURVES) {
            fprintf(fd, "\n");
            n = 1L<<td->td_bitspersample;
            for (l = 0; l < n; l++) {
                uint16 i;
                fprintf(fd, "    %2ld: %5u",
                    l, td->td_transferfunction[0][l]);
                for (i = 1; i < td->td_samplesperpixel - td->td_extrasamples && i < 3; i++)
                    fprintf(fd, " %5u",
                        td->td_transferfunction[i][l]);
                fputc('\n', fd);
            }
        } else
            fprintf(fd, "(present)\n");
    }
    if (TIFFFieldSet(tif, FIELD_SUBIFD) && (td->td_subifd)) {
        uint16 i;
        fprintf(fd, "  SubIFD Offsets:");
        for (i = 0; i < td->td_nsubifd; i++)
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
            fprintf(fd, " %5I64u",
                (unsigned __int64) td->td_subifd[i]);
#else
            fprintf(fd, " %5llu",
                (unsigned long long) td->td_subifd[i]);
#endif
        fputc('\n', fd);
    }
 
    /*
    ** Custom tag support.
    */
    {
        int  i;
        short count;
 
        count = (short) TIFFGetTagListCount(tif);
        for(i = 0; i < count; i++) {
            uint32 tag = TIFFGetTagListEntry(tif, i);
            const TIFFField *fip;
            uint32 value_count;
            int mem_alloc = 0;
            void *raw_data;
 
            fip = TIFFFieldWithTag(tif, tag);
            if(fip == NULL)
                continue;
 
            if(fip->field_passcount) {
                if (fip->field_readcount == TIFF_VARIABLE2 ) {
                    if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1)
                        continue;
                } else if (fip->field_readcount == TIFF_VARIABLE ) {
                    uint16 small_value_count;
                    if(TIFFGetField(tif, tag, &small_value_count, &raw_data) != 1)
                        continue;
                    value_count = small_value_count;
                } else {
                    assert (fip->field_readcount == TIFF_VARIABLE
                        || fip->field_readcount == TIFF_VARIABLE2);
                    continue;
                } 
            } else {
                if (fip->field_readcount == TIFF_VARIABLE
                    || fip->field_readcount == TIFF_VARIABLE2)
                    value_count = 1;
                else if (fip->field_readcount == TIFF_SPP)
                    value_count = td->td_samplesperpixel;
                else
                    value_count = fip->field_readcount;
                if (fip->field_tag == TIFFTAG_DOTRANGE
                    && strcmp(fip->field_name,"DotRange") == 0) {
                    /* TODO: This is an evil exception and should not have been
                       handled this way ... likely best if we move it into
                       the directory structure with an explicit field in 
                       libtiff 4.1 and assign it a FIELD_ value */
                    static uint16 dotrange[2];
                    raw_data = dotrange;
                    TIFFGetField(tif, tag, dotrange+0, dotrange+1);
                } else if (fip->field_type == TIFF_ASCII
                       || fip->field_readcount == TIFF_VARIABLE
                       || fip->field_readcount == TIFF_VARIABLE2
                       || fip->field_readcount == TIFF_SPP
                       || value_count > 1) {
                    if(TIFFGetField(tif, tag, &raw_data) != 1)
                        continue;
                } else {
                    raw_data = _TIFFmalloc(
                        _TIFFDataSize(fip->field_type)
                        * value_count);
                    mem_alloc = 1;
                    if(TIFFGetField(tif, tag, raw_data) != 1) {
                        _TIFFfree(raw_data);
                        continue;
                    }
                }
            }
 
            /*
             * Catch the tags which needs to be specially handled
             * and pretty print them. If tag not handled in
             * _TIFFPrettyPrintField() fall down and print it as
             * any other tag.
             */
            if (!_TIFFPrettyPrintField(tif, fip, fd, tag, value_count, raw_data))
                _TIFFPrintField(fd, fip, value_count, raw_data);
 
            if(mem_alloc)
                _TIFFfree(raw_data);
        }
    }
        
    if (tif->tif_tagmethods.printdir)
        (*tif->tif_tagmethods.printdir)(tif, fd, flags);
 
    if ((flags & TIFFPRINT_STRIPS) &&
        TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) {
        uint32 s;
 
        fprintf(fd, "  %lu %s:\n",
            (unsigned long) td->td_nstrips,
            isTiled(tif) ? "Tiles" : "Strips");
        for (s = 0; s < td->td_nstrips; s++)
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
            fprintf(fd, "    %3lu: [%8I64u, %8I64u]\n",
                (unsigned long) s,
                (unsigned __int64) TIFFGetStrileOffset(tif, s),
                (unsigned __int64) TIFFGetStrileByteCount(tif, s));
#else
            fprintf(fd, "    %3lu: [%8llu, %8llu]\n",
                (unsigned long) s,
                (unsigned long long) TIFFGetStrileOffset(tif, s),
                (unsigned long long) TIFFGetStrileByteCount(tif, s));
#endif
    }
}

◆ TIFFRasterScanlineSize()

tmsize_t TIFFRasterScanlineSize ( TIFF * tif )

Definition at line 344 of file tif_strip.c.

{
    static const char module[] = "TIFFRasterScanlineSize";
    uint64 m;
    m=TIFFRasterScanlineSize64(tif);
    return _TIFFCastUInt64ToSSize(tif, m, module);
}

◆ TIFFRasterScanlineSize64()

uint64 TIFFRasterScanlineSize64 ( TIFF * tif )

Definition at line 329 of file tif_strip.c.

{
    static const char module[] = "TIFFRasterScanlineSize64";
    TIFFDirectory *td = &tif->tif_dir;
    uint64 scanline;
 
    scanline = _TIFFMultiply64(tif, td->td_bitspersample, td->td_imagewidth, module);
    if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
        scanline = _TIFFMultiply64(tif, scanline, td->td_samplesperpixel, module);
        return (TIFFhowmany8_64(scanline));
    } else
        return (_TIFFMultiply64(tif, TIFFhowmany8_64(scanline),
            td->td_samplesperpixel, module));
}

Referenced by TIFFRasterScanlineSize().

◆ TIFFRawStripSize()

tmsize_t TIFFRawStripSize	(	TIFF *	tif,
		uint32	strip
	)

Definition at line 164 of file tif_strip.c.

{
    static const char module[] = "TIFFRawStripSize";
    uint64 m;
    tmsize_t n;
    m=TIFFRawStripSize64(tif,strip);
    if (m==(uint64)(-1))
        n=(tmsize_t)(-1);
    else
    {
        n=(tmsize_t)m;
        if ((uint64)n!=m)
        {
            TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
            n=0;
        }
    }
    return(n);
}

◆ TIFFRawStripSize64()

uint64 TIFFRawStripSize64	(	TIFF *	tif,
		uint32	strip
	)

Definition at line 140 of file tif_strip.c.

{
    static const char module[] = "TIFFRawStripSize64";
    uint64 bytecount = TIFFGetStrileByteCount(tif, strip);
 
    if (bytecount == 0)
    {
#if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
        TIFFErrorExt(tif->tif_clientdata, module,
                 "%I64u: Invalid strip byte count, strip %lu",
                 (unsigned __int64) bytecount,
                 (unsigned long) strip);
#else
        TIFFErrorExt(tif->tif_clientdata, module,
                 "%llu: Invalid strip byte count, strip %lu",
                 (unsigned long long) bytecount,
                 (unsigned long) strip);
#endif
        bytecount = (uint64) -1;
    }
 
    return bytecount;
}

Referenced by TIFFRawStripSize().

◆ TIFFReadBufferSetup()

int TIFFReadBufferSetup	(	TIFF *	tif,
		void *	bp,
		tmsize_t	size
	)

Definition at line 1378 of file tif_read.c.

{
    static const char module[] = "TIFFReadBufferSetup";
 
    assert((tif->tif_flags&TIFF_NOREADRAW)==0);
    tif->tif_flags &= ~TIFF_BUFFERMMAP;
 
    if (tif->tif_rawdata) {
        if (tif->tif_flags & TIFF_MYBUFFER)
            _TIFFfree(tif->tif_rawdata);
        tif->tif_rawdata = NULL;
        tif->tif_rawdatasize = 0;
    }
    if (bp) {
        tif->tif_rawdatasize = size;
        tif->tif_rawdata = (uint8*) bp;
        tif->tif_flags &= ~TIFF_MYBUFFER;
    } else {
        tif->tif_rawdatasize = (tmsize_t)TIFFroundup_64((uint64)size, 1024);
        if (tif->tif_rawdatasize==0) {
            TIFFErrorExt(tif->tif_clientdata, module,
                 "Invalid buffer size");
            return (0);
        }
        /* Initialize to zero to avoid uninitialized buffers in case of */
                /* short reads (http://bugzilla.maptools.org/show_bug.cgi?id=2651) */
        tif->tif_rawdata = (uint8*) _TIFFcalloc(1, tif->tif_rawdatasize);
        tif->tif_flags |= TIFF_MYBUFFER;
    }
    if (tif->tif_rawdata == NULL) {
        TIFFErrorExt(tif->tif_clientdata, module,
            "No space for data buffer at scanline %lu",
            (unsigned long) tif->tif_row);
        tif->tif_rawdatasize = 0;
        return (0);
    }
    return (1);
}

Referenced by TIFFFillStrip(), and TIFFFillTile().

◆ TIFFReadCustomDirectory()

int TIFFReadCustomDirectory	(	TIFF *	tif,
		toff_t	diroff,
		const TIFFFieldArray *	infoarray
	)

Definition at line 4394 of file tif_dirread.c.

{
    static const char module[] = "TIFFReadCustomDirectory";
    TIFFDirEntry* dir;
    uint16 dircount;
    TIFFDirEntry* dp;
    uint16 di;
    const TIFFField* fip;
    uint32 fii;
    _TIFFSetupFields(tif, infoarray);
    dircount=TIFFFetchDirectory(tif,diroff,&dir,NULL);
    if (!dircount)
    {
        TIFFErrorExt(tif->tif_clientdata,module,
            "Failed to read custom directory at offset " TIFF_UINT64_FORMAT,diroff);
        return 0;
    }
    TIFFFreeDirectory(tif);
    _TIFFmemset(&tif->tif_dir, 0, sizeof(TIFFDirectory));
    TIFFReadDirectoryCheckOrder(tif,dir,dircount);
    for (di=0, dp=dir; di<dircount; di++, dp++)
    {
        TIFFReadDirectoryFindFieldInfo(tif,dp->tdir_tag,&fii);
        if (fii == FAILED_FII)
        {
            TIFFWarningExt(tif->tif_clientdata, module,
                "Unknown field with tag %d (0x%x) encountered",
                dp->tdir_tag, dp->tdir_tag);
            if (!_TIFFMergeFields(tif, _TIFFCreateAnonField(tif,
                        dp->tdir_tag,
                        (TIFFDataType) dp->tdir_type),
                         1)) {
                TIFFWarningExt(tif->tif_clientdata, module,
                    "Registering anonymous field with tag %d (0x%x) failed",
                    dp->tdir_tag, dp->tdir_tag);
                dp->tdir_ignore = TRUE;
            } else {
                TIFFReadDirectoryFindFieldInfo(tif,dp->tdir_tag,&fii);
                assert( fii != FAILED_FII );
            }
        }
        if (!dp->tdir_ignore)
        {
            fip=tif->tif_fields[fii];
            if (fip->field_bit==FIELD_IGNORE)
                dp->tdir_ignore = TRUE;
            else
            {
                /* check data type */
                while ((fip->field_type!=TIFF_ANY)&&(fip->field_type!=dp->tdir_type))
                {
                    fii++;
                    if ((fii==tif->tif_nfields)||
                        (tif->tif_fields[fii]->field_tag!=(uint32)dp->tdir_tag))
                    {
                        fii=0xFFFF;
                        break;
                    }
                    fip=tif->tif_fields[fii];
                }
                if (fii==0xFFFF)
                {
                    TIFFWarningExt(tif->tif_clientdata, module,
                        "Wrong data type %d for \"%s\"; tag ignored",
                        dp->tdir_type,fip->field_name);
                    dp->tdir_ignore = TRUE;
                }
                else
                {
                    /* check count if known in advance */
                    if ((fip->field_readcount!=TIFF_VARIABLE)&&
                        (fip->field_readcount!=TIFF_VARIABLE2))
                    {
                        uint32 expected;
                        if (fip->field_readcount==TIFF_SPP)
                            expected=(uint32)tif->tif_dir.td_samplesperpixel;
                        else
                            expected=(uint32)fip->field_readcount;
                        if (!CheckDirCount(tif,dp,expected))
                            dp->tdir_ignore = TRUE;
                    }
                }
            }
            if (!dp->tdir_ignore) {
                switch (dp->tdir_tag) 
                {
                    case EXIFTAG_SUBJECTDISTANCE:
                        (void)TIFFFetchSubjectDistance(tif, dp);
                        break;
                    default:
                        (void)TIFFFetchNormalTag(tif, dp, TRUE);
                        break;
                }
            } /*-- if (!dp->tdir_ignore) */
        }
    }
    if (dir)
        _TIFFfree(dir);
    return 1;
}

Referenced by TIFFReadEXIFDirectory().

◆ TIFFReadDirectory()

int TIFFReadDirectory ( TIFF * tif )

Definition at line 3574 of file tif_dirread.c.

{
    static const char module[] = "TIFFReadDirectory";
    TIFFDirEntry* dir;
    uint16 dircount;
    TIFFDirEntry* dp;
    uint16 di;
    const TIFFField* fip;
    uint32 fii=FAILED_FII;
        toff_t nextdiroff;
    int bitspersample_read = FALSE;
        int color_channels;
 
    tif->tif_diroff=tif->tif_nextdiroff;
    if (!TIFFCheckDirOffset(tif,tif->tif_nextdiroff))
        return 0;           /* last offset or bad offset (IFD looping) */
    (*tif->tif_cleanup)(tif);   /* cleanup any previous compression state */
    tif->tif_curdir++;
        nextdiroff = tif->tif_nextdiroff;
    dircount=TIFFFetchDirectory(tif,nextdiroff,&dir,&tif->tif_nextdiroff);
    if (!dircount)
    {
        TIFFErrorExt(tif->tif_clientdata,module,
            "Failed to read directory at offset " TIFF_UINT64_FORMAT,nextdiroff);
        return 0;
    }
    TIFFReadDirectoryCheckOrder(tif,dir,dircount);
 
        /*
         * Mark duplicates of any tag to be ignored (bugzilla 1994)
         * to avoid certain pathological problems.
         */
    {
        TIFFDirEntry* ma;
        uint16 mb;
        for (ma=dir, mb=0; mb<dircount; ma++, mb++)
        {
            TIFFDirEntry* na;
            uint16 nb;
            for (na=ma+1, nb=mb+1; nb<dircount; na++, nb++)
            {
                if (ma->tdir_tag == na->tdir_tag) {
                    na->tdir_ignore = TRUE;
                }
            }
        }
    }
        
    tif->tif_flags &= ~TIFF_BEENWRITING;    /* reset before new dir */
    tif->tif_flags &= ~TIFF_BUF4WRITE;      /* reset before new dir */
    tif->tif_flags &= ~TIFF_CHOPPEDUPARRAYS;
 
    /* free any old stuff and reinit */
    TIFFFreeDirectory(tif);
    TIFFDefaultDirectory(tif);
    /*
     * Electronic Arts writes gray-scale TIFF files
     * without a PlanarConfiguration directory entry.
     * Thus we setup a default value here, even though
     * the TIFF spec says there is no default value.
     */
    TIFFSetField(tif,TIFFTAG_PLANARCONFIG,PLANARCONFIG_CONTIG);
    /*
     * Setup default value and then make a pass over
     * the fields to check type and tag information,
     * and to extract info required to size data
     * structures.  A second pass is made afterwards
     * to read in everything not taken in the first pass.
     * But we must process the Compression tag first
     * in order to merge in codec-private tag definitions (otherwise
     * we may get complaints about unknown tags).  However, the
     * Compression tag may be dependent on the SamplesPerPixel
     * tag value because older TIFF specs permitted Compression
     * to be written as a SamplesPerPixel-count tag entry.
     * Thus if we don't first figure out the correct SamplesPerPixel
     * tag value then we may end up ignoring the Compression tag
     * value because it has an incorrect count value (if the
     * true value of SamplesPerPixel is not 1).
     */
    dp=TIFFReadDirectoryFindEntry(tif,dir,dircount,TIFFTAG_SAMPLESPERPIXEL);
    if (dp)
    {
        if (!TIFFFetchNormalTag(tif,dp,0))
            goto bad;
        dp->tdir_ignore = TRUE;
    }
    dp=TIFFReadDirectoryFindEntry(tif,dir,dircount,TIFFTAG_COMPRESSION);
    if (dp)
    {
        /*
         * The 5.0 spec says the Compression tag has one value, while
         * earlier specs say it has one value per sample.  Because of
         * this, we accept the tag if one value is supplied with either
         * count.
         */
        uint16 value;
        enum TIFFReadDirEntryErr err;
        err=TIFFReadDirEntryShort(tif,dp,&value);
        if (err==TIFFReadDirEntryErrCount)
            err=TIFFReadDirEntryPersampleShort(tif,dp,&value);
        if (err!=TIFFReadDirEntryErrOk)
        {
            TIFFReadDirEntryOutputErr(tif,err,module,"Compression",0);
            goto bad;
        }
        if (!TIFFSetField(tif,TIFFTAG_COMPRESSION,value))
            goto bad;
        dp->tdir_ignore = TRUE;
    }
    else
    {
        if (!TIFFSetField(tif,TIFFTAG_COMPRESSION,COMPRESSION_NONE))
            goto bad;
    }
    /*
     * First real pass over the directory.
     */
    for (di=0, dp=dir; di<dircount; di++, dp++)
    {
        if (!dp->tdir_ignore)
        {
            TIFFReadDirectoryFindFieldInfo(tif,dp->tdir_tag,&fii);
            if (fii == FAILED_FII)
            {
                TIFFWarningExt(tif->tif_clientdata, module,
                    "Unknown field with tag %d (0x%x) encountered",
                    dp->tdir_tag,dp->tdir_tag);
                /* the following knowingly leaks the 
                   anonymous field structure */
                if (!_TIFFMergeFields(tif,
                    _TIFFCreateAnonField(tif,
                        dp->tdir_tag,
                        (TIFFDataType) dp->tdir_type),
                    1)) {
                    TIFFWarningExt(tif->tif_clientdata,
                        module,
                        "Registering anonymous field with tag %d (0x%x) failed",
                        dp->tdir_tag,
                        dp->tdir_tag);
                    dp->tdir_ignore = TRUE;
                } else {
                    TIFFReadDirectoryFindFieldInfo(tif,dp->tdir_tag,&fii);
                    assert(fii != FAILED_FII);
                }
            }
        }
        if (!dp->tdir_ignore)
        {
            fip=tif->tif_fields[fii];
            if (fip->field_bit==FIELD_IGNORE)
                dp->tdir_ignore = TRUE;
            else
            {
                switch (dp->tdir_tag)
                {
                    case TIFFTAG_STRIPOFFSETS:
                    case TIFFTAG_STRIPBYTECOUNTS:
                    case TIFFTAG_TILEOFFSETS:
                    case TIFFTAG_TILEBYTECOUNTS:
                        TIFFSetFieldBit(tif,fip->field_bit);
                        break;
                    case TIFFTAG_IMAGEWIDTH:
                    case TIFFTAG_IMAGELENGTH:
                    case TIFFTAG_IMAGEDEPTH:
                    case TIFFTAG_TILELENGTH:
                    case TIFFTAG_TILEWIDTH:
                    case TIFFTAG_TILEDEPTH:
                    case TIFFTAG_PLANARCONFIG:
                    case TIFFTAG_ROWSPERSTRIP:
                    case TIFFTAG_EXTRASAMPLES:
                        if (!TIFFFetchNormalTag(tif,dp,0))
                            goto bad;
                        dp->tdir_ignore = TRUE;
                        break;
                    default:
                        if( !_TIFFCheckFieldIsValidForCodec(tif, dp->tdir_tag) )
                            dp->tdir_ignore = TRUE;
                        break;
                }
            }
        }
    }
    /*
     * XXX: OJPEG hack.
     * If a) compression is OJPEG, b) planarconfig tag says it's separate,
     * c) strip offsets/bytecounts tag are both present and
     * d) both contain exactly one value, then we consistently find
     * that the buggy implementation of the buggy compression scheme
     * matches contig planarconfig best. So we 'fix-up' the tag here
     */
    if ((tif->tif_dir.td_compression==COMPRESSION_OJPEG)&&
        (tif->tif_dir.td_planarconfig==PLANARCONFIG_SEPARATE))
    {
        if (!_TIFFFillStriles(tif))
            goto bad;
        dp=TIFFReadDirectoryFindEntry(tif,dir,dircount,TIFFTAG_STRIPOFFSETS);
        if ((dp!=0)&&(dp->tdir_count==1))
        {
            dp=TIFFReadDirectoryFindEntry(tif,dir,dircount,
                TIFFTAG_STRIPBYTECOUNTS);
            if ((dp!=0)&&(dp->tdir_count==1))
            {
                tif->tif_dir.td_planarconfig=PLANARCONFIG_CONTIG;
                TIFFWarningExt(tif->tif_clientdata,module,
                    "Planarconfig tag value assumed incorrect, "
                    "assuming data is contig instead of chunky");
            }
        }
    }
    /*
     * Allocate directory structure and setup defaults.
     */
    if (!TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS))
    {
        MissingRequired(tif,"ImageLength");
        goto bad;
    }
    /*
     * Setup appropriate structures (by strip or by tile)
     */
    if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
        tif->tif_dir.td_nstrips = TIFFNumberOfStrips(tif);  
        tif->tif_dir.td_tilewidth = tif->tif_dir.td_imagewidth;
        tif->tif_dir.td_tilelength = tif->tif_dir.td_rowsperstrip;
        tif->tif_dir.td_tiledepth = tif->tif_dir.td_imagedepth;
        tif->tif_flags &= ~TIFF_ISTILED;
    } else {
        tif->tif_dir.td_nstrips = TIFFNumberOfTiles(tif);
        tif->tif_flags |= TIFF_ISTILED;
    }
    if (!tif->tif_dir.td_nstrips) {
        TIFFErrorExt(tif->tif_clientdata, module,
            "Cannot handle zero number of %s",
            isTiled(tif) ? "tiles" : "strips");
        goto bad;
    }
    tif->tif_dir.td_stripsperimage = tif->tif_dir.td_nstrips;
    if (tif->tif_dir.td_planarconfig == PLANARCONFIG_SEPARATE)
        tif->tif_dir.td_stripsperimage /= tif->tif_dir.td_samplesperpixel;
    if (!TIFFFieldSet(tif, FIELD_STRIPOFFSETS)) {
#ifdef OJPEG_SUPPORT
        if ((tif->tif_dir.td_compression==COMPRESSION_OJPEG) &&
            (isTiled(tif)==0) &&
            (tif->tif_dir.td_nstrips==1)) {
            /*
             * XXX: OJPEG hack.
             * If a) compression is OJPEG, b) it's not a tiled TIFF,
             * and c) the number of strips is 1,
             * then we tolerate the absence of stripoffsets tag,
             * because, presumably, all required data is in the
             * JpegInterchangeFormat stream.
             */
            TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS);
        } else
#endif
        {
            MissingRequired(tif,
                isTiled(tif) ? "TileOffsets" : "StripOffsets");
            goto bad;
        }
    }
    /*
     * Second pass: extract other information.
     */
    for (di=0, dp=dir; di<dircount; di++, dp++)
    {
        if (!dp->tdir_ignore) {
            switch (dp->tdir_tag) 
            {
                case TIFFTAG_MINSAMPLEVALUE:
                case TIFFTAG_MAXSAMPLEVALUE:
                case TIFFTAG_BITSPERSAMPLE:
                case TIFFTAG_DATATYPE:
                case TIFFTAG_SAMPLEFORMAT:
                    /*
                     * The MinSampleValue, MaxSampleValue, BitsPerSample
                     * DataType and SampleFormat tags are supposed to be
                     * written as one value/sample, but some vendors
                     * incorrectly write one value only -- so we accept
                     * that as well (yuck). Other vendors write correct
                     * value for NumberOfSamples, but incorrect one for
                     * BitsPerSample and friends, and we will read this
                     * too.
                     */
                    {
                        uint16 value;
                        enum TIFFReadDirEntryErr err;
                        err=TIFFReadDirEntryShort(tif,dp,&value);
                        if (err==TIFFReadDirEntryErrCount)
                            err=TIFFReadDirEntryPersampleShort(tif,dp,&value);
                        if (err!=TIFFReadDirEntryErrOk)
                        {
                            fip = TIFFFieldWithTag(tif,dp->tdir_tag);
                            TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",0);
                            goto bad;
                        }
                        if (!TIFFSetField(tif,dp->tdir_tag,value))
                            goto bad;
                        if( dp->tdir_tag == TIFFTAG_BITSPERSAMPLE )
                            bitspersample_read = TRUE;
                    }
                    break;
                case TIFFTAG_SMINSAMPLEVALUE:
                case TIFFTAG_SMAXSAMPLEVALUE:
                    {
 
                        double *data = NULL;
                        enum TIFFReadDirEntryErr err;
                        uint32 saved_flags;
                        int m;
                        if (dp->tdir_count != (uint64)tif->tif_dir.td_samplesperpixel)
                            err = TIFFReadDirEntryErrCount;
                        else
                            err = TIFFReadDirEntryDoubleArray(tif, dp, &data);
                        if (err!=TIFFReadDirEntryErrOk)
                        {
                            fip = TIFFFieldWithTag(tif,dp->tdir_tag);
                            TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",0);
                            goto bad;
                        }
                        saved_flags = tif->tif_flags;
                        tif->tif_flags |= TIFF_PERSAMPLE;
                        m = TIFFSetField(tif,dp->tdir_tag,data);
                        tif->tif_flags = saved_flags;
                        _TIFFfree(data);
                        if (!m)
                            goto bad;
                    }
                    break;
                case TIFFTAG_STRIPOFFSETS:
                case TIFFTAG_TILEOFFSETS:
                    _TIFFmemcpy( &(tif->tif_dir.td_stripoffset_entry),
                       dp, sizeof(TIFFDirEntry) );
                    break;
                case TIFFTAG_STRIPBYTECOUNTS:
                case TIFFTAG_TILEBYTECOUNTS:
                    _TIFFmemcpy( &(tif->tif_dir.td_stripbytecount_entry),
                       dp, sizeof(TIFFDirEntry) );
                    break;
                case TIFFTAG_COLORMAP:
                case TIFFTAG_TRANSFERFUNCTION:
                    {
                        enum TIFFReadDirEntryErr err;
                        uint32 countpersample;
                        uint32 countrequired;
                        uint32 incrementpersample;
                        uint16* value=NULL;
                        /* It would be dangerous to instantiate those tag values */
                        /* since if td_bitspersample has not yet been read (due to */
                        /* unordered tags), it could be read afterwards with a */
                        /* values greater than the default one (1), which may cause */
                        /* crashes in user code */
                        if( !bitspersample_read )
                        {
                            fip = TIFFFieldWithTag(tif,dp->tdir_tag);
                            TIFFWarningExt(tif->tif_clientdata,module,
                                "Ignoring %s since BitsPerSample tag not found",
                                fip ? fip->field_name : "unknown tagname");
                            continue;
                        }
                        /* ColorMap or TransferFunction for high bit */
                        /* depths do not make much sense and could be */
                        /* used as a denial of service vector */
                        if (tif->tif_dir.td_bitspersample > 24)
                        {
                            fip = TIFFFieldWithTag(tif,dp->tdir_tag);
                            TIFFWarningExt(tif->tif_clientdata,module,
                                "Ignoring %s because BitsPerSample=%d>24",
                                fip ? fip->field_name : "unknown tagname",
                                tif->tif_dir.td_bitspersample);
                            continue;
                        }
                        countpersample=(1U<<tif->tif_dir.td_bitspersample);
                        if ((dp->tdir_tag==TIFFTAG_TRANSFERFUNCTION)&&(dp->tdir_count==(uint64)countpersample))
                        {
                            countrequired=countpersample;
                            incrementpersample=0;
                        }
                        else
                        {
                            countrequired=3*countpersample;
                            incrementpersample=countpersample;
                        }
                        if (dp->tdir_count!=(uint64)countrequired)
                            err=TIFFReadDirEntryErrCount;
                        else
                            err=TIFFReadDirEntryShortArray(tif,dp,&value);
                        if (err!=TIFFReadDirEntryErrOk)
                        {
                            fip = TIFFFieldWithTag(tif,dp->tdir_tag);
                            TIFFReadDirEntryOutputErr(tif,err,module,fip ? fip->field_name : "unknown tagname",1);
                        }
                        else
                        {
                            TIFFSetField(tif,dp->tdir_tag,value,value+incrementpersample,value+2*incrementpersample);
                            _TIFFfree(value);
                        }
                    }
                    break;
/* BEGIN REV 4.0 COMPATIBILITY */
                case TIFFTAG_OSUBFILETYPE:
                    {
                        uint16 valueo;
                        uint32 value;
                        if (TIFFReadDirEntryShort(tif,dp,&valueo)==TIFFReadDirEntryErrOk)
                        {
                            switch (valueo)
                            {
                                case OFILETYPE_REDUCEDIMAGE: value=FILETYPE_REDUCEDIMAGE; break;
                                case OFILETYPE_PAGE: value=FILETYPE_PAGE; break;
                                default: value=0; break;
                            }
                            if (value!=0)
                                TIFFSetField(tif,TIFFTAG_SUBFILETYPE,value);
                        }
                    }
                    break;
/* END REV 4.0 COMPATIBILITY */
                default:
                    (void) TIFFFetchNormalTag(tif, dp, TRUE);
                    break;
                }
            } /* -- if (!dp->tdir_ignore) */
        } /* -- for-loop -- */
 
        if( tif->tif_mode == O_RDWR &&
            tif->tif_dir.td_stripoffset_entry.tdir_tag != 0 &&
            tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
            tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
            tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 &&
            tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0 &&
            tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
            tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
            tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0 )
        {
            /* Directory typically created with TIFFDeferStrileArrayWriting() */
            TIFFSetupStrips(tif);
        }
        else if( !(tif->tif_flags&TIFF_DEFERSTRILELOAD) )
        {
            if( tif->tif_dir.td_stripoffset_entry.tdir_tag != 0 )
            {
                if (!TIFFFetchStripThing(tif,&(tif->tif_dir.td_stripoffset_entry),
                                         tif->tif_dir.td_nstrips,
                                         &tif->tif_dir.td_stripoffset_p))
                {
                    goto bad;
                }
            }
            if( tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0 )
            {
                if (!TIFFFetchStripThing(tif,&(tif->tif_dir.td_stripbytecount_entry),
                                         tif->tif_dir.td_nstrips,
                                         &tif->tif_dir.td_stripbytecount_p))
                {
                    goto bad;
                }
            }
        }
 
    /*
     * OJPEG hack:
     * - If a) compression is OJPEG, and b) photometric tag is missing,
     * then we consistently find that photometric should be YCbCr
     * - If a) compression is OJPEG, and b) photometric tag says it's RGB,
     * then we consistently find that the buggy implementation of the
     * buggy compression scheme matches photometric YCbCr instead.
     * - If a) compression is OJPEG, and b) bitspersample tag is missing,
     * then we consistently find bitspersample should be 8.
     * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
     * and c) photometric is RGB or YCbCr, then we consistently find
     * samplesperpixel should be 3
     * - If a) compression is OJPEG, b) samplesperpixel tag is missing,
     * and c) photometric is MINISWHITE or MINISBLACK, then we consistently
     * find samplesperpixel should be 3
     */
    if (tif->tif_dir.td_compression==COMPRESSION_OJPEG)
    {
        if (!TIFFFieldSet(tif,FIELD_PHOTOMETRIC))
        {
            TIFFWarningExt(tif->tif_clientdata, module,
                "Photometric tag is missing, assuming data is YCbCr");
            if (!TIFFSetField(tif,TIFFTAG_PHOTOMETRIC,PHOTOMETRIC_YCBCR))
                goto bad;
        }
        else if (tif->tif_dir.td_photometric==PHOTOMETRIC_RGB)
        {
            tif->tif_dir.td_photometric=PHOTOMETRIC_YCBCR;
            TIFFWarningExt(tif->tif_clientdata, module,
                "Photometric tag value assumed incorrect, "
                "assuming data is YCbCr instead of RGB");
        }
        if (!TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))
        {
            TIFFWarningExt(tif->tif_clientdata,module,
                "BitsPerSample tag is missing, assuming 8 bits per sample");
            if (!TIFFSetField(tif,TIFFTAG_BITSPERSAMPLE,8))
                goto bad;
        }
        if (!TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
        {
            if (tif->tif_dir.td_photometric==PHOTOMETRIC_RGB)
            {
                TIFFWarningExt(tif->tif_clientdata,module,
                    "SamplesPerPixel tag is missing, "
                    "assuming correct SamplesPerPixel value is 3");
                if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,3))
                    goto bad;
            }
            if (tif->tif_dir.td_photometric==PHOTOMETRIC_YCBCR)
            {
                TIFFWarningExt(tif->tif_clientdata,module,
                    "SamplesPerPixel tag is missing, "
                    "applying correct SamplesPerPixel value of 3");
                if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,3))
                    goto bad;
            }
            else if ((tif->tif_dir.td_photometric==PHOTOMETRIC_MINISWHITE)
                 || (tif->tif_dir.td_photometric==PHOTOMETRIC_MINISBLACK))
            {
                /*
                 * SamplesPerPixel tag is missing, but is not required
                 * by spec.  Assume correct SamplesPerPixel value of 1.
                 */
                if (!TIFFSetField(tif,TIFFTAG_SAMPLESPERPIXEL,1))
                    goto bad;
            }
        }
    }
 
    /*
     * Make sure all non-color channels are extrasamples.
     * If it's not the case, define them as such.
     */
        color_channels = _TIFFGetMaxColorChannels(tif->tif_dir.td_photometric);
        if (color_channels && tif->tif_dir.td_samplesperpixel - tif->tif_dir.td_extrasamples > color_channels) {
                uint16 old_extrasamples;
                uint16 *new_sampleinfo;
 
                TIFFWarningExt(tif->tif_clientdata,module, "Sum of Photometric type-related "
                    "color channels and ExtraSamples doesn't match SamplesPerPixel. "
                    "Defining non-color channels as ExtraSamples.");
 
                old_extrasamples = tif->tif_dir.td_extrasamples;
                tif->tif_dir.td_extrasamples = (uint16) (tif->tif_dir.td_samplesperpixel - color_channels);
 
                // sampleinfo should contain information relative to these new extra samples
                new_sampleinfo = (uint16*) _TIFFcalloc(tif->tif_dir.td_extrasamples, sizeof(uint16));
                if (!new_sampleinfo) {
                    TIFFErrorExt(tif->tif_clientdata, module, "Failed to allocate memory for "
                                "temporary new sampleinfo array (%d 16 bit elements)",
                                tif->tif_dir.td_extrasamples);
                    goto bad;
                }
 
                memcpy(new_sampleinfo, tif->tif_dir.td_sampleinfo, old_extrasamples * sizeof(uint16));
                _TIFFsetShortArray(&tif->tif_dir.td_sampleinfo, new_sampleinfo, tif->tif_dir.td_extrasamples);
                _TIFFfree(new_sampleinfo);
        }
 
    /*
     * Verify Palette image has a Colormap.
     */
    if (tif->tif_dir.td_photometric == PHOTOMETRIC_PALETTE &&
        !TIFFFieldSet(tif, FIELD_COLORMAP)) {
        if ( tif->tif_dir.td_bitspersample>=8 && tif->tif_dir.td_samplesperpixel==3)
            tif->tif_dir.td_photometric = PHOTOMETRIC_RGB;
        else if (tif->tif_dir.td_bitspersample>=8)
            tif->tif_dir.td_photometric = PHOTOMETRIC_MINISBLACK;
        else {
            MissingRequired(tif, "Colormap");
            goto bad;
        }
    }
    /*
     * OJPEG hack:
     * We do no further messing with strip/tile offsets/bytecounts in OJPEG
     * TIFFs
     */
    if (tif->tif_dir.td_compression!=COMPRESSION_OJPEG)
    {
        /*
         * Attempt to deal with a missing StripByteCounts tag.
         */
        if (!TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS)) {
            /*
             * Some manufacturers violate the spec by not giving
             * the size of the strips.  In this case, assume there
             * is one uncompressed strip of data.
             */
            if ((tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG &&
                tif->tif_dir.td_nstrips > 1) ||
                (tif->tif_dir.td_planarconfig == PLANARCONFIG_SEPARATE &&
                 tif->tif_dir.td_nstrips != (uint32)tif->tif_dir.td_samplesperpixel)) {
                MissingRequired(tif, "StripByteCounts");
                goto bad;
            }
            TIFFWarningExt(tif->tif_clientdata, module,
                "TIFF directory is missing required "
                "\"StripByteCounts\" field, calculating from imagelength");
            if (EstimateStripByteCounts(tif, dir, dircount) < 0)
                goto bad;
 
        } else if (tif->tif_dir.td_nstrips == 1
                           && !(tif->tif_flags&TIFF_ISTILED)
               && ByteCountLooksBad(tif)) {
            /*
             * XXX: Plexus (and others) sometimes give a value of
             * zero for a tag when they don't know what the
             * correct value is!  Try and handle the simple case
             * of estimating the size of a one strip image.
             */
            TIFFWarningExt(tif->tif_clientdata, module,
                "Bogus \"StripByteCounts\" field, ignoring and calculating from imagelength");
            if(EstimateStripByteCounts(tif, dir, dircount) < 0)
                goto bad;
 
        } else if (!(tif->tif_flags&TIFF_DEFERSTRILELOAD)
               && tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG
               && tif->tif_dir.td_nstrips > 2
               && tif->tif_dir.td_compression == COMPRESSION_NONE
               && TIFFGetStrileByteCount(tif, 0) != TIFFGetStrileByteCount(tif, 1)
               && TIFFGetStrileByteCount(tif, 0) != 0
               && TIFFGetStrileByteCount(tif, 1) != 0 ) {
            /*
             * XXX: Some vendors fill StripByteCount array with
             * absolutely wrong values (it can be equal to
             * StripOffset array, for example). Catch this case
             * here.
                         *
                         * We avoid this check if deferring strile loading
                         * as it would always force us to load the strip/tile
                         * information.
             */
            TIFFWarningExt(tif->tif_clientdata, module,
                "Wrong \"StripByteCounts\" field, ignoring and calculating from imagelength");
            if (EstimateStripByteCounts(tif, dir, dircount) < 0)
                goto bad;
        }
    }
    if (dir)
    {
        _TIFFfree(dir);
        dir=NULL;
    }
    if (!TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE))
    {
        if (tif->tif_dir.td_bitspersample>=16)
            tif->tif_dir.td_maxsamplevalue=0xFFFF;
        else
            tif->tif_dir.td_maxsamplevalue = (uint16)((1L<<tif->tif_dir.td_bitspersample)-1);
    }
 
#ifdef STRIPBYTECOUNTSORTED_UNUSED
    /*
     * XXX: We can optimize checking for the strip bounds using the sorted
     * bytecounts array. See also comments for TIFFAppendToStrip()
     * function in tif_write.c.
     */
    if (!(tif->tif_flags&TIFF_DEFERSTRILELOAD) && tif->tif_dir.td_nstrips > 1) {
        uint32 strip;
 
        tif->tif_dir.td_stripbytecountsorted = 1;
        for (strip = 1; strip < tif->tif_dir.td_nstrips; strip++) {
            if (TIFFGetStrileOffset(tif, strip - 1) >
                TIFFGetStrileOffset(tif, strip)) {
                tif->tif_dir.td_stripbytecountsorted = 0;
                break;
            }
        }
    }
#endif
 
    /*
     * An opportunity for compression mode dependent tag fixup
     */
    (*tif->tif_fixuptags)(tif);
 
    /*
     * Some manufacturers make life difficult by writing
     * large amounts of uncompressed data as a single strip.
     * This is contrary to the recommendations of the spec.
     * The following makes an attempt at breaking such images
     * into strips closer to the recommended 8k bytes.  A
     * side effect, however, is that the RowsPerStrip tag
     * value may be changed.
     */
    if ((tif->tif_dir.td_planarconfig==PLANARCONFIG_CONTIG)&&
        (tif->tif_dir.td_nstrips==1)&&
        (tif->tif_dir.td_compression==COMPRESSION_NONE)&&  
        ((tif->tif_flags&(TIFF_STRIPCHOP|TIFF_ISTILED))==TIFF_STRIPCHOP))
        {
            ChopUpSingleUncompressedStrip(tif);
        }
 
        /* There are also uncompressed striped files with strips larger than */
        /* 2 GB, which make them unfriendly with a lot of code. If possible, */
        /* try to expose smaller "virtual" strips. */
        if( tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG &&
            tif->tif_dir.td_compression == COMPRESSION_NONE &&
            (tif->tif_flags&(TIFF_STRIPCHOP|TIFF_ISTILED)) == TIFF_STRIPCHOP &&
            TIFFStripSize64(tif) > 0x7FFFFFFFUL )
        {
            TryChopUpUncompressedBigTiff(tif);
        }
 
        /*
         * Clear the dirty directory flag. 
         */
    tif->tif_flags &= ~TIFF_DIRTYDIRECT;
    tif->tif_flags &= ~TIFF_DIRTYSTRIP;
 
    /*
     * Reinitialize i/o since we are starting on a new directory.
     */
    tif->tif_row = (uint32) -1;
    tif->tif_curstrip = (uint32) -1;
    tif->tif_col = (uint32) -1;
    tif->tif_curtile = (uint32) -1;
    tif->tif_tilesize = (tmsize_t) -1;
 
    tif->tif_scanlinesize = TIFFScanlineSize(tif);
    if (!tif->tif_scanlinesize) {
        TIFFErrorExt(tif->tif_clientdata, module,
            "Cannot handle zero scanline size");
        return (0);
    }
 
    if (isTiled(tif)) {
        tif->tif_tilesize = TIFFTileSize(tif);
        if (!tif->tif_tilesize) {
            TIFFErrorExt(tif->tif_clientdata, module,
                 "Cannot handle zero tile size");
            return (0);
        }
    } else {
        if (!TIFFStripSize(tif)) {
            TIFFErrorExt(tif->tif_clientdata, module,
                "Cannot handle zero strip size");
            return (0);
        }
    }
    return (1);
bad:
    if (dir)
        _TIFFfree(dir);
    return (0);
}

Referenced by TIFFClientOpen(), TIFFSetDirectory(), and TIFFSetSubDirectory().

◆ TIFFReadEncodedStrip()

tmsize_t TIFFReadEncodedStrip	(	TIFF *	tif,
		uint32	strip,
		void *	buf,
		tmsize_t	size
	)

Definition at line 527 of file tif_read.c.

{
    static const char module[] = "TIFFReadEncodedStrip";
    TIFFDirectory *td = &tif->tif_dir;
    tmsize_t stripsize;
    uint16 plane;
 
    stripsize=TIFFReadEncodedStripGetStripSize(tif, strip, &plane);
    if (stripsize==((tmsize_t)(-1)))
        return((tmsize_t)(-1));
 
    /* shortcut to avoid an extra memcpy() */
    if( td->td_compression == COMPRESSION_NONE &&
        size!=(tmsize_t)(-1) && size >= stripsize &&
        !isMapped(tif) &&
        ((tif->tif_flags&TIFF_NOREADRAW)==0) )
    {
        if (TIFFReadRawStrip1(tif, strip, buf, stripsize, module) != stripsize)
            return ((tmsize_t)(-1));
 
        if (!isFillOrder(tif, td->td_fillorder) &&
            (tif->tif_flags & TIFF_NOBITREV) == 0)
            TIFFReverseBits(buf,stripsize);
 
        (*tif->tif_postdecode)(tif,buf,stripsize);
        return (stripsize);
    }
 
    if ((size!=(tmsize_t)(-1))&&(size<stripsize))
        stripsize=size;
    if (!TIFFFillStrip(tif,strip))
        return((tmsize_t)(-1));
    if ((*tif->tif_decodestrip)(tif,buf,stripsize,plane)<=0)
        return((tmsize_t)(-1));
    (*tif->tif_postdecode)(tif,buf,stripsize);
    return(stripsize);
}

Referenced by _TIFFReadEncodedStripAndAllocBuffer(), gtStripSeparate(), and tiff_decoder_read_tile().

◆ TIFFReadEncodedTile()

tmsize_t TIFFReadEncodedTile	(	TIFF *	tif,
		uint32	tile,
		void *	buf,
		tmsize_t	size
	)

Definition at line 978 of file tif_read.c.

{
    static const char module[] = "TIFFReadEncodedTile";
    TIFFDirectory *td = &tif->tif_dir;
    tmsize_t tilesize = tif->tif_tilesize;
 
    if (!TIFFCheckRead(tif, 1))
        return ((tmsize_t)(-1));
    if (tile >= td->td_nstrips) {
        TIFFErrorExt(tif->tif_clientdata, module,
            "%lu: Tile out of range, max %lu",
            (unsigned long) tile, (unsigned long) td->td_nstrips);
        return ((tmsize_t)(-1));
    }
 
    /* shortcut to avoid an extra memcpy() */
    if( td->td_compression == COMPRESSION_NONE &&
        size!=(tmsize_t)(-1) && size >= tilesize &&
        !isMapped(tif) &&
        ((tif->tif_flags&TIFF_NOREADRAW)==0) )
    {
        if (TIFFReadRawTile1(tif, tile, buf, tilesize, module) != tilesize)
            return ((tmsize_t)(-1));
 
        if (!isFillOrder(tif, td->td_fillorder) &&
            (tif->tif_flags & TIFF_NOBITREV) == 0)
            TIFFReverseBits(buf,tilesize);
 
        (*tif->tif_postdecode)(tif,buf,tilesize);
        return (tilesize);
    }
 
    if (size == (tmsize_t)(-1))
        size = tilesize;
    else if (size > tilesize)
        size = tilesize;
    if (TIFFFillTile(tif, tile) && (*tif->tif_decodetile)(tif,
        (uint8*) buf, size, (uint16)(tile/td->td_stripsperimage))) {
        (*tif->tif_postdecode)(tif, (uint8*) buf, size);
        return (size);
    } else
        return ((tmsize_t)(-1));
}

Referenced by _TIFFReadEncodedTileAndAllocBuffer(), tiff_decoder_read_tile(), and TIFFReadTile().

◆ TIFFReadEXIFDirectory()

int TIFFReadEXIFDirectory	(	TIFF *	tif,
		toff_t	diroff
	)

Definition at line 4501 of file tif_dirread.c.

{
    const TIFFFieldArray* exifFieldArray;
    exifFieldArray = _TIFFGetExifFields();
    return TIFFReadCustomDirectory(tif, diroff, exifFieldArray);  
}

◆ TIFFReadFromUserBuffer()

int TIFFReadFromUserBuffer	(	TIFF *	tif,
		uint32	strile,
		void *	inbuf,
		tmsize_t	insize,
		void *	outbuf,
		tmsize_t	outsize
	)

Definition at line 1524 of file tif_read.c.

{
    static const char module[] = "TIFFReadFromUserBuffer";
    TIFFDirectory *td = &tif->tif_dir;
    int ret = 1;
    uint32 old_tif_flags = tif->tif_flags;
    tmsize_t old_rawdatasize = tif->tif_rawdatasize;
    void* old_rawdata = tif->tif_rawdata;
 
    if (tif->tif_mode == O_WRONLY) {
        TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "File not open for reading");
        return 0;
    }
    if (tif->tif_flags&TIFF_NOREADRAW)
    {
        TIFFErrorExt(tif->tif_clientdata, module,
                "Compression scheme does not support access to raw uncompressed data");
        return 0;
    }
 
    tif->tif_flags &= ~TIFF_MYBUFFER;
    tif->tif_flags |= TIFF_BUFFERMMAP;
    tif->tif_rawdatasize = insize;
    tif->tif_rawdata = inbuf;
    tif->tif_rawdataoff = 0;
    tif->tif_rawdataloaded = insize;
 
    if (!isFillOrder(tif, td->td_fillorder) &&
        (tif->tif_flags & TIFF_NOBITREV) == 0)
    {
        TIFFReverseBits(inbuf, insize);
    }
 
    if( TIFFIsTiled(tif) )
    {
        if( !TIFFStartTile(tif, strile) ||
            !(*tif->tif_decodetile)(tif, (uint8*) outbuf, outsize, 
                                    (uint16)(strile/td->td_stripsperimage)) )
        {
            ret = 0;
        }
    }
    else
    {
        uint32 rowsperstrip=td->td_rowsperstrip;
        uint32 stripsperplane;
        if (rowsperstrip>td->td_imagelength)
            rowsperstrip=td->td_imagelength;
        stripsperplane= TIFFhowmany_32_maxuint_compat(td->td_imagelength, rowsperstrip);
        if( !TIFFStartStrip(tif, strile) ||
            !(*tif->tif_decodestrip)(tif, (uint8*) outbuf, outsize, 
                                     (uint16)(strile/stripsperplane)) )
        {
            ret = 0;
        }
    }
    if( ret )
    {
        (*tif->tif_postdecode)(tif, (uint8*) outbuf, outsize);
    }
 
    if (!isFillOrder(tif, td->td_fillorder) &&
        (tif->tif_flags & TIFF_NOBITREV) == 0)
    {
        TIFFReverseBits(inbuf, insize);
    }
 
    tif->tif_flags = old_tif_flags;
    tif->tif_rawdatasize = old_rawdatasize;
    tif->tif_rawdata = old_rawdata;
    tif->tif_rawdataoff = 0;
    tif->tif_rawdataloaded = 0;
 
    return ret;
}

◆ TIFFReadRawStrip()

tmsize_t TIFFReadRawStrip	(	TIFF *	tif,
		uint32	strip,
		void *	buf,
		tmsize_t	size
	)

Definition at line 722 of file tif_read.c.

{
    static const char module[] = "TIFFReadRawStrip";
    TIFFDirectory *td = &tif->tif_dir;
    uint64 bytecount64;
    tmsize_t bytecountm;
 
    if (!TIFFCheckRead(tif, 0))
        return ((tmsize_t)(-1));
    if (strip >= td->td_nstrips) {
        TIFFErrorExt(tif->tif_clientdata, module,
             "%lu: Strip out of range, max %lu",
             (unsigned long) strip,
             (unsigned long) td->td_nstrips);
        return ((tmsize_t)(-1));
    }
    if (tif->tif_flags&TIFF_NOREADRAW)
    {
        TIFFErrorExt(tif->tif_clientdata, module,
            "Compression scheme does not support access to raw uncompressed data");
        return ((tmsize_t)(-1));
    }
    bytecount64 = TIFFGetStrileByteCount(tif, strip);
    if (size != (tmsize_t)(-1) && (uint64)size <= bytecount64)
        bytecountm = size;
    else
        bytecountm = _TIFFCastUInt64ToSSize(tif, bytecount64, module);
    if( bytecountm == 0 ) {
        return ((tmsize_t)(-1));
    }
    return (TIFFReadRawStrip1(tif, strip, buf, bytecountm, module));
}

◆ TIFFReadRawTile()

tmsize_t TIFFReadRawTile	(	TIFF *	tif,
		uint32	tile,
		void *	buf,
		tmsize_t	size
	)

Definition at line 1167 of file tif_read.c.

{
    static const char module[] = "TIFFReadRawTile";
    TIFFDirectory *td = &tif->tif_dir;
    uint64 bytecount64;
    tmsize_t bytecountm;
 
    if (!TIFFCheckRead(tif, 1))
        return ((tmsize_t)(-1));
    if (tile >= td->td_nstrips) {
        TIFFErrorExt(tif->tif_clientdata, module,
            "%lu: Tile out of range, max %lu",
            (unsigned long) tile, (unsigned long) td->td_nstrips);
        return ((tmsize_t)(-1));
    }
    if (tif->tif_flags&TIFF_NOREADRAW)
    {
        TIFFErrorExt(tif->tif_clientdata, module,
        "Compression scheme does not support access to raw uncompressed data");
        return ((tmsize_t)(-1));
    }
    bytecount64 = TIFFGetStrileByteCount(tif, tile);
    if (size != (tmsize_t)(-1) && (uint64)size <= bytecount64)
        bytecountm = size;
    else
        bytecountm = _TIFFCastUInt64ToSSize(tif, bytecount64, module);
    if( bytecountm == 0 ) {
        return ((tmsize_t)(-1));
    }
    return (TIFFReadRawTile1(tif, tile, buf, bytecountm, module));
}

◆ TIFFReadRGBAImage()

int TIFFReadRGBAImage	(	TIFF *	tif,
		uint32	rwidth,
		uint32	rheight,
		uint32 *	raster,
		int	stop
	)

Definition at line 545 of file tif_getimage.c.

{
    return TIFFReadRGBAImageOriented(tif, rwidth, rheight, raster,
                     ORIENTATION_BOTLEFT, stop);
}

◆ TIFFReadRGBAImageOriented()

int TIFFReadRGBAImageOriented	(	TIFF *	tif,
		uint32	rwidth,
		uint32	rheight,
		uint32 *	raster,
		int	orientation,
		int	stop
	)

Definition at line 519 of file tif_getimage.c.

{
    char emsg[1024] = "";
    TIFFRGBAImage img;
    int ok;
 
    if (TIFFRGBAImageOK(tif, emsg) && TIFFRGBAImageBegin(&img, tif, stop, emsg)) {
        img.req_orientation = (uint16)orientation;
        /* XXX verify rwidth and rheight against width and height */
        ok = TIFFRGBAImageGet(&img, raster+(rheight-img.height)*rwidth,
            rwidth, img.height);
        TIFFRGBAImageEnd(&img);
    } else {
        TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg);
        ok = 0;
    }
    return (ok);
}

Referenced by TIFFReadRGBAImage().

◆ TIFFReadRGBAStrip()

int TIFFReadRGBAStrip	(	TIFF *	tif,
		uint32	row,
		uint32 *	raster
	)

Definition at line 2889 of file tif_getimage.c.

{
    return TIFFReadRGBAStripExt(tif, row, raster, 0 );
}

◆ TIFFReadRGBAStripExt()

int TIFFReadRGBAStripExt	(	TIFF *	tif,
		uint32	row,
		uint32 *	raster,
		int	stop_on_error
	)

Definition at line 2896 of file tif_getimage.c.

{
    char    emsg[1024] = "";
    TIFFRGBAImage img;
    int     ok;
    uint32  rowsperstrip, rows_to_read;
 
    if( TIFFIsTiled( tif ) )
    {
        TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif),
                  "Can't use TIFFReadRGBAStrip() with tiled file.");
    return (0);
    }
    
    TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);
    if( (row % rowsperstrip) != 0 )
    {
        TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif),
                "Row passed to TIFFReadRGBAStrip() must be first in a strip.");
        return (0);
    }
 
    if (TIFFRGBAImageOK(tif, emsg) && TIFFRGBAImageBegin(&img, tif, stop_on_error, emsg)) {
 
        img.row_offset = row;
        img.col_offset = 0;
 
        if( row + rowsperstrip > img.height )
            rows_to_read = img.height - row;
        else
            rows_to_read = rowsperstrip;
        
    ok = TIFFRGBAImageGet(&img, raster, img.width, rows_to_read );
        
    TIFFRGBAImageEnd(&img);
    } else {
        TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg);
        ok = 0;
    }
    
    return (ok);
}

Referenced by TIFFReadRGBAStrip().

◆ TIFFReadRGBATile()

int TIFFReadRGBATile	(	TIFF *	tif,
		uint32	col,
		uint32	row,
		uint32 *	raster
	)

Definition at line 2947 of file tif_getimage.c.

{
    return TIFFReadRGBATileExt(tif, col, row, raster, 0 );
}

◆ TIFFReadRGBATileExt()

int TIFFReadRGBATileExt	(	TIFF *	tif,
		uint32	col,
		uint32	row,
		uint32 *	raster,
		int	stop_on_error
	)

Definition at line 2955 of file tif_getimage.c.

{
    char    emsg[1024] = "";
    TIFFRGBAImage img;
    int     ok;
    uint32  tile_xsize, tile_ysize;
    uint32  read_xsize, read_ysize;
    uint32  i_row;
 
    /*
     * Verify that our request is legal - on a tile file, and on a
     * tile boundary.
     */
    
    if( !TIFFIsTiled( tif ) )
    {
        TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif),
                  "Can't use TIFFReadRGBATile() with striped file.");
        return (0);
    }
    
    TIFFGetFieldDefaulted(tif, TIFFTAG_TILEWIDTH, &tile_xsize);
    TIFFGetFieldDefaulted(tif, TIFFTAG_TILELENGTH, &tile_ysize);
    if( (col % tile_xsize) != 0 || (row % tile_ysize) != 0 )
    {
        TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif),
                  "Row/col passed to TIFFReadRGBATile() must be top"
                  "left corner of a tile.");
    return (0);
    }
 
    /*
     * Setup the RGBA reader.
     */
    
    if (!TIFFRGBAImageOK(tif, emsg) 
    || !TIFFRGBAImageBegin(&img, tif, stop_on_error, emsg)) {
        TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "%s", emsg);
        return( 0 );
    }
 
    /*
     * The TIFFRGBAImageGet() function doesn't allow us to get off the
     * edge of the image, even to fill an otherwise valid tile.  So we
     * figure out how much we can read, and fix up the tile buffer to
     * a full tile configuration afterwards.
     */
 
    if( row + tile_ysize > img.height )
        read_ysize = img.height - row;
    else
        read_ysize = tile_ysize;
    
    if( col + tile_xsize > img.width )
        read_xsize = img.width - col;
    else
        read_xsize = tile_xsize;
 
    /*
     * Read the chunk of imagery.
     */
    
    img.row_offset = row;
    img.col_offset = col;
 
    ok = TIFFRGBAImageGet(&img, raster, read_xsize, read_ysize );
        
    TIFFRGBAImageEnd(&img);
 
    /*
     * If our read was incomplete we will need to fix up the tile by
     * shifting the data around as if a full tile of data is being returned.
     *
     * This is all the more complicated because the image is organized in
     * bottom to top format. 
     */
 
    if( read_xsize == tile_xsize && read_ysize == tile_ysize )
        return( ok );
 
    for( i_row = 0; i_row < read_ysize; i_row++ ) {
        memmove( raster + (tile_ysize - i_row - 1) * tile_xsize,
                 raster + (read_ysize - i_row - 1) * read_xsize,
                 read_xsize * sizeof(uint32) );
        _TIFFmemset( raster + (tile_ysize - i_row - 1) * tile_xsize+read_xsize,
                     0, sizeof(uint32) * (tile_xsize - read_xsize) );
    }
 
    for( i_row = read_ysize; i_row < tile_ysize; i_row++ ) {
        _TIFFmemset( raster + (tile_ysize - i_row - 1) * tile_xsize,
                     0, sizeof(uint32) * tile_xsize );
    }
 
    return (ok);
}

Referenced by TIFFReadRGBATile().

◆ TIFFReadScanline()

int TIFFReadScanline	(	TIFF *	tif,
		void *	buf,
		uint32	row,
		uint16	sample
	)

Definition at line 460 of file tif_read.c.

{
    int e;
 
    if (!TIFFCheckRead(tif, 0))
        return (-1);
    if( (e = TIFFSeek(tif, row, sample)) != 0) {
        /*
         * Decompress desired row into user buffer.
         */
        e = (*tif->tif_decoderow)
            (tif, (uint8*) buf, tif->tif_scanlinesize, sample);  
 
        /* we are now poised at the beginning of the next row */
        tif->tif_row = row + 1;
 
        if (e)
            (*tif->tif_postdecode)(tif, (uint8*) buf,
                tif->tif_scanlinesize);  
    }
    return (e > 0 ? 1 : -1);
}

◆ TIFFReadTile()

tmsize_t TIFFReadTile	(	TIFF *	tif,
		void *	buf,
		uint32	x,
		uint32	y,
		uint32	z,
		uint16	s
	)

Definition at line 965 of file tif_read.c.

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

Referenced by gtTileSeparate().

◆ TIFFRegisterCODEC()

TIFFCodec * TIFFRegisterCODEC	(	uint16	scheme,
		const char *	name,
		TIFFInitMethod	init
	)

Definition at line 201 of file tif_compress.c.

{
    codec_t* cd = (codec_t*)
        _TIFFmalloc((tmsize_t)(sizeof (codec_t) + sizeof (TIFFCodec) + strlen(name)+1));
 
    if (cd != NULL) {
        cd->info = (TIFFCodec*) ((uint8*) cd + sizeof (codec_t));
        cd->info->name = (char*)
            ((uint8*) cd->info + sizeof (TIFFCodec));
        strcpy(cd->info->name, name);
        cd->info->scheme = scheme;
        cd->info->init = init;
        cd->next = registeredCODECS;
        registeredCODECS = cd;
    } else {
        TIFFErrorExt(0, "TIFFRegisterCODEC",
            "No space to register compression scheme %s", name);
        return NULL;
    }
    return (cd->info);
}

◆ TIFFReverseBits()

void TIFFReverseBits	(	uint8 *	cp,
		tmsize_t	n
	)

Definition at line 284 of file tif_swab.c.

{
    for (; n > 8; n -= 8) {
        cp[0] = TIFFBitRevTable[cp[0]];
        cp[1] = TIFFBitRevTable[cp[1]];
        cp[2] = TIFFBitRevTable[cp[2]];
        cp[3] = TIFFBitRevTable[cp[3]];
        cp[4] = TIFFBitRevTable[cp[4]];
        cp[5] = TIFFBitRevTable[cp[5]];
        cp[6] = TIFFBitRevTable[cp[6]];
        cp[7] = TIFFBitRevTable[cp[7]];
        cp += 8;
    }
    while (n-- > 0) {
        *cp = TIFFBitRevTable[*cp];
        cp++;
    }
}

Referenced by TIFFFillStrip(), TIFFFillStripPartial(), TIFFFillTile(), TIFFFlushData1(), TIFFReadEncodedStrip(), TIFFReadEncodedTile(), TIFFReadFromUserBuffer(), TIFFWriteEncodedStrip(), and TIFFWriteEncodedTile().

◆ TIFFRewriteDirectory()

int TIFFRewriteDirectory ( TIFF * tif )

Definition at line 261 of file tif_dirwrite.c.

{
    static const char module[] = "TIFFRewriteDirectory";
 
    /* We don't need to do anything special if it hasn't been written. */
    if( tif->tif_diroff == 0 )
        return TIFFWriteDirectory( tif );
 
    /*
     * Find and zero the pointer to this directory, so that TIFFLinkDirectory
     * will cause it to be added after this directories current pre-link.
     */
 
    if (!(tif->tif_flags&TIFF_BIGTIFF))
    {
        if (tif->tif_header.classic.tiff_diroff == tif->tif_diroff)
        {
            tif->tif_header.classic.tiff_diroff = 0;
            tif->tif_diroff = 0;
 
            TIFFSeekFile(tif,4,SEEK_SET);
            if (!WriteOK(tif, &(tif->tif_header.classic.tiff_diroff),4))
            {
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                    "Error updating TIFF header");
                return (0);
            }
        }
        else
        {
            uint32 nextdir;
            nextdir = tif->tif_header.classic.tiff_diroff;
            while(1) {
                uint16 dircount;
                uint32 nextnextdir;
 
                if (!SeekOK(tif, nextdir) ||
                    !ReadOK(tif, &dircount, 2)) {
                    TIFFErrorExt(tif->tif_clientdata, module,
                         "Error fetching directory count");
                    return (0);
                }
                if (tif->tif_flags & TIFF_SWAB)
                    TIFFSwabShort(&dircount);
                (void) TIFFSeekFile(tif,
                    nextdir+2+dircount*12, SEEK_SET);
                if (!ReadOK(tif, &nextnextdir, 4)) {
                    TIFFErrorExt(tif->tif_clientdata, module,
                         "Error fetching directory link");
                    return (0);
                }
                if (tif->tif_flags & TIFF_SWAB)
                    TIFFSwabLong(&nextnextdir);
                if (nextnextdir==tif->tif_diroff)
                {
                    uint32 m;
                    m=0;
                    (void) TIFFSeekFile(tif,
                        nextdir+2+dircount*12, SEEK_SET);
                    if (!WriteOK(tif, &m, 4)) {
                        TIFFErrorExt(tif->tif_clientdata, module,
                             "Error writing directory link");
                        return (0);
                    }
                    tif->tif_diroff=0;
                    break;
                }
                nextdir=nextnextdir;
            }
        }
    }
    else
    {
        if (tif->tif_header.big.tiff_diroff == tif->tif_diroff)
        {
            tif->tif_header.big.tiff_diroff = 0;
            tif->tif_diroff = 0;
 
            TIFFSeekFile(tif,8,SEEK_SET);
            if (!WriteOK(tif, &(tif->tif_header.big.tiff_diroff),8))
            {
                TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                    "Error updating TIFF header");
                return (0);
            }
        }
        else
        {
            uint64 nextdir;
            nextdir = tif->tif_header.big.tiff_diroff;
            while(1) {
                uint64 dircount64;
                uint16 dircount;
                uint64 nextnextdir;
 
                if (!SeekOK(tif, nextdir) ||
                    !ReadOK(tif, &dircount64, 8)) {
                    TIFFErrorExt(tif->tif_clientdata, module,
                         "Error fetching directory count");
                    return (0);
                }
                if (tif->tif_flags & TIFF_SWAB)
                    TIFFSwabLong8(&dircount64);
                if (dircount64>0xFFFF)
                {
                    TIFFErrorExt(tif->tif_clientdata, module,
                         "Sanity check on tag count failed, likely corrupt TIFF");
                    return (0);
                }
                dircount=(uint16)dircount64;
                (void) TIFFSeekFile(tif,
                    nextdir+8+dircount*20, SEEK_SET);
                if (!ReadOK(tif, &nextnextdir, 8)) {
                    TIFFErrorExt(tif->tif_clientdata, module,
                         "Error fetching directory link");
                    return (0);
                }
                if (tif->tif_flags & TIFF_SWAB)
                    TIFFSwabLong8(&nextnextdir);
                if (nextnextdir==tif->tif_diroff)
                {
                    uint64 m;
                    m=0;
                    (void) TIFFSeekFile(tif,
                        nextdir+8+dircount*20, SEEK_SET);
                    if (!WriteOK(tif, &m, 8)) {
                        TIFFErrorExt(tif->tif_clientdata, module,
                             "Error writing directory link");
                        return (0);
                    }
                    tif->tif_diroff=0;
                    break;
                }
                nextdir=nextnextdir;
            }
        }
    }
 
    /*
     * Now use TIFFWriteDirectory() normally.
     */
 
    return TIFFWriteDirectory( tif );
}

Referenced by TIFFFlush().

◆ TIFFRGBAImageBegin()

int TIFFRGBAImageBegin	(	TIFFRGBAImage *	img,
		TIFF *	tif,
		int	stop,
		char	emsg[1024]
	)

Definition at line 265 of file tif_getimage.c.

{
    uint16* sampleinfo;
    uint16 extrasamples;
    uint16 planarconfig;
    uint16 compress;
    int colorchannels;
    uint16 *red_orig, *green_orig, *blue_orig;
    int n_color;
    
    if( !TIFFRGBAImageOK(tif, emsg) )
        return 0;
 
    /* Initialize to normal values */
    img->row_offset = 0;
    img->col_offset = 0;
    img->redcmap = NULL;
    img->greencmap = NULL;
    img->bluecmap = NULL;
    img->Map = NULL;
    img->BWmap = NULL;
    img->PALmap = NULL;
    img->ycbcr = NULL;
    img->cielab = NULL;
    img->UaToAa = NULL;
    img->Bitdepth16To8 = NULL;
    img->req_orientation = ORIENTATION_BOTLEFT;     /* It is the default */
 
    img->tif = tif;
    img->stoponerr = stop;
    TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &img->bitspersample);
    switch (img->bitspersample) {
        case 1:
        case 2:
        case 4:
        case 8:
        case 16:
            break;
        default:
            sprintf(emsg, "Sorry, can not handle images with %d-bit samples",
                img->bitspersample);
            goto fail_return;
    }
    img->alpha = 0;
    TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLESPERPIXEL, &img->samplesperpixel);
    TIFFGetFieldDefaulted(tif, TIFFTAG_EXTRASAMPLES,
        &extrasamples, &sampleinfo);
    if (extrasamples >= 1)
    {
        switch (sampleinfo[0]) {
            case EXTRASAMPLE_UNSPECIFIED:          /* Workaround for some images without */
                if (img->samplesperpixel > 3)  /* correct info about alpha channel */
                    img->alpha = EXTRASAMPLE_ASSOCALPHA;
                break;
            case EXTRASAMPLE_ASSOCALPHA:           /* data is pre-multiplied */
            case EXTRASAMPLE_UNASSALPHA:           /* data is not pre-multiplied */
                img->alpha = sampleinfo[0];
                break;
        }
    }
 
#ifdef DEFAULT_EXTRASAMPLE_AS_ALPHA
    if( !TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric))
        img->photometric = PHOTOMETRIC_MINISWHITE;
 
    if( extrasamples == 0
        && img->samplesperpixel == 4
        && img->photometric == PHOTOMETRIC_RGB )
    {
        img->alpha = EXTRASAMPLE_ASSOCALPHA;
        extrasamples = 1;
    }
#endif
 
    colorchannels = img->samplesperpixel - extrasamples;
    TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &compress);
    TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &planarconfig);
    if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &img->photometric)) {
        switch (colorchannels) {
            case 1:
                if (isCCITTCompression(tif))
                    img->photometric = PHOTOMETRIC_MINISWHITE;
                else
                    img->photometric = PHOTOMETRIC_MINISBLACK;
                break;
            case 3:
                img->photometric = PHOTOMETRIC_RGB;
                break;
            default:
                sprintf(emsg, "Missing needed %s tag", photoTag);
                                goto fail_return;
        }
    }
    switch (img->photometric) {
        case PHOTOMETRIC_PALETTE:
            if (!TIFFGetField(tif, TIFFTAG_COLORMAP,
                &red_orig, &green_orig, &blue_orig)) {
                sprintf(emsg, "Missing required \"Colormap\" tag");
                                goto fail_return;
            }
 
            /* copy the colormaps so we can modify them */
            n_color = (1U << img->bitspersample);
            img->redcmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
            img->greencmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
            img->bluecmap = (uint16 *) _TIFFmalloc(sizeof(uint16)*n_color);
            if( !img->redcmap || !img->greencmap || !img->bluecmap ) {
                sprintf(emsg, "Out of memory for colormap copy");
                                goto fail_return;
            }
 
            _TIFFmemcpy( img->redcmap, red_orig, n_color * 2 );
            _TIFFmemcpy( img->greencmap, green_orig, n_color * 2 );
            _TIFFmemcpy( img->bluecmap, blue_orig, n_color * 2 );
 
            /* fall through... */
        case PHOTOMETRIC_MINISWHITE:
        case PHOTOMETRIC_MINISBLACK:
            if (planarconfig == PLANARCONFIG_CONTIG
                && img->samplesperpixel != 1
                && img->bitspersample < 8 ) {
                sprintf(emsg,
                    "Sorry, can not handle contiguous data with %s=%d, "
                    "and %s=%d and Bits/Sample=%d",
                    photoTag, img->photometric,
                    "Samples/pixel", img->samplesperpixel,
                    img->bitspersample);
                                goto fail_return;
            }
            break;
        case PHOTOMETRIC_YCBCR:
            /* It would probably be nice to have a reality check here. */
            if (planarconfig == PLANARCONFIG_CONTIG)
                /* can rely on libjpeg to convert to RGB */
                /* XXX should restore current state on exit */
                switch (compress) {
                    case COMPRESSION_JPEG:
                        /*
                         * TODO: when complete tests verify complete desubsampling
                         * and YCbCr handling, remove use of TIFFTAG_JPEGCOLORMODE in
                         * favor of tif_getimage.c native handling
                         */
                        TIFFSetField(tif, TIFFTAG_JPEGCOLORMODE, JPEGCOLORMODE_RGB);
                        img->photometric = PHOTOMETRIC_RGB;
                        break;
                    default:
                        /* do nothing */;
                        break;
                }
            /*
             * TODO: if at all meaningful and useful, make more complete
             * support check here, or better still, refactor to let supporting
             * code decide whether there is support and what meaningful
             * error to return
             */
            break;
        case PHOTOMETRIC_RGB:
            if (colorchannels < 3) {
                sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
                    "Color channels", colorchannels);
                                goto fail_return;
            }
            break;
        case PHOTOMETRIC_SEPARATED:
            {
                uint16 inkset;
                TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
                if (inkset != INKSET_CMYK) {
                    sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
                        "InkSet", inkset);
                                        goto fail_return;
                }
                if (img->samplesperpixel < 4) {
                    sprintf(emsg, "Sorry, can not handle separated image with %s=%d",
                        "Samples/pixel", img->samplesperpixel);
                                        goto fail_return;
                }
            }
            break;
        case PHOTOMETRIC_LOGL:
            if (compress != COMPRESSION_SGILOG) {
                sprintf(emsg, "Sorry, LogL data must have %s=%d",
                    "Compression", COMPRESSION_SGILOG);
                                goto fail_return;
            }
            TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
            img->photometric = PHOTOMETRIC_MINISBLACK;  /* little white lie */
            img->bitspersample = 8;
            break;
        case PHOTOMETRIC_LOGLUV:
            if (compress != COMPRESSION_SGILOG && compress != COMPRESSION_SGILOG24) {
                sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d",
                    "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24);
                                goto fail_return;
            }
            if (planarconfig != PLANARCONFIG_CONTIG) {
                sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
                    "Planarconfiguration", planarconfig);
                return (0);
            }
            TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_8BIT);
            img->photometric = PHOTOMETRIC_RGB;     /* little white lie */
            img->bitspersample = 8;
            break;
        case PHOTOMETRIC_CIELAB:
            break;
        default:
            sprintf(emsg, "Sorry, can not handle image with %s=%d",
                photoTag, img->photometric);
                        goto fail_return;
    }
    TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &img->width);
    TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &img->height);
    TIFFGetFieldDefaulted(tif, TIFFTAG_ORIENTATION, &img->orientation);
    img->isContig =
        !(planarconfig == PLANARCONFIG_SEPARATE && img->samplesperpixel > 1);
    if (img->isContig) {
        if (!PickContigCase(img)) {
            sprintf(emsg, "Sorry, can not handle image");
            goto fail_return;
        }
    } else {
        if (!PickSeparateCase(img)) {
            sprintf(emsg, "Sorry, can not handle image");
            goto fail_return;
        }
    }
    return 1;
 
  fail_return:
        TIFFRGBAImageEnd( img );
        return 0;
}

Referenced by TIFFReadRGBAImageOriented(), TIFFReadRGBAStripExt(), and TIFFReadRGBATileExt().

◆ TIFFRGBAImageEnd()

void TIFFRGBAImageEnd ( TIFFRGBAImage * img )

Definition at line 214 of file tif_getimage.c.

{
    if (img->Map) {
        _TIFFfree(img->Map);
        img->Map = NULL;
    }
    if (img->BWmap) {
        _TIFFfree(img->BWmap);
        img->BWmap = NULL;
    }
    if (img->PALmap) {
        _TIFFfree(img->PALmap);
        img->PALmap = NULL;
    }
    if (img->ycbcr) {
        _TIFFfree(img->ycbcr);
        img->ycbcr = NULL;
    }
    if (img->cielab) {
        _TIFFfree(img->cielab);
        img->cielab = NULL;
    }
    if (img->UaToAa) {
        _TIFFfree(img->UaToAa);
        img->UaToAa = NULL;
    }
    if (img->Bitdepth16To8) {
        _TIFFfree(img->Bitdepth16To8);
        img->Bitdepth16To8 = NULL;
    }
 
    if( img->redcmap ) {
        _TIFFfree( img->redcmap );
        _TIFFfree( img->greencmap );
        _TIFFfree( img->bluecmap );
                img->redcmap = img->greencmap = img->bluecmap = NULL;
    }
}

Referenced by TIFFReadRGBAImageOriented(), TIFFReadRGBAStripExt(), TIFFReadRGBATileExt(), and TIFFRGBAImageBegin().

◆ TIFFRGBAImageGet()

int TIFFRGBAImageGet	(	TIFFRGBAImage *	img,
		uint32 *	raster,
		uint32	w,
		uint32	h
	)

Definition at line 500 of file tif_getimage.c.

{
    if (img->get == NULL) {
        TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif), "No \"get\" routine setup");
        return (0);
    }
    if (img->put.any == NULL) {
        TIFFErrorExt(img->tif->tif_clientdata, TIFFFileName(img->tif),
        "No \"put\" routine setupl; probably can not handle image format");
        return (0);
    }
    return (*img->get)(img, raster, w, h);
}

Referenced by TIFFReadRGBAImageOriented(), TIFFReadRGBAStripExt(), and TIFFReadRGBATileExt().

◆ TIFFRGBAImageOK()

int TIFFRGBAImageOK	(	TIFF *	tif,
		char	emsg[1024]
	)

Definition at line 74 of file tif_getimage.c.

{
    TIFFDirectory* td = &tif->tif_dir;
    uint16 photometric;
    int colorchannels;
 
    if (!tif->tif_decodestatus) {
        sprintf(emsg, "Sorry, requested compression method is not configured");
        return (0);
    }
    switch (td->td_bitspersample) {
        case 1:
        case 2:
        case 4:
        case 8:
        case 16:
            break;
        default:
            sprintf(emsg, "Sorry, can not handle images with %d-bit samples",
                td->td_bitspersample);
            return (0);
    }
        if (td->td_sampleformat == SAMPLEFORMAT_IEEEFP) {
                sprintf(emsg, "Sorry, can not handle images with IEEE floating-point samples");
                return (0);
        }
    colorchannels = td->td_samplesperpixel - td->td_extrasamples;
    if (!TIFFGetField(tif, TIFFTAG_PHOTOMETRIC, &photometric)) {
        switch (colorchannels) {
            case 1:
                photometric = PHOTOMETRIC_MINISBLACK;
                break;
            case 3:
                photometric = PHOTOMETRIC_RGB;
                break;
            default:
                sprintf(emsg, "Missing needed %s tag", photoTag);
                return (0);
        }
    }
    switch (photometric) {
        case PHOTOMETRIC_MINISWHITE:
        case PHOTOMETRIC_MINISBLACK:
        case PHOTOMETRIC_PALETTE:
            if (td->td_planarconfig == PLANARCONFIG_CONTIG
                && td->td_samplesperpixel != 1
                && td->td_bitspersample < 8 ) {
                sprintf(emsg,
                    "Sorry, can not handle contiguous data with %s=%d, "
                    "and %s=%d and Bits/Sample=%d",
                    photoTag, photometric,
                    "Samples/pixel", td->td_samplesperpixel,
                    td->td_bitspersample);
                return (0);
            }
            /*
             * We should likely validate that any extra samples are either
             * to be ignored, or are alpha, and if alpha we should try to use
             * them.  But for now we won't bother with this.
            */
            break;
        case PHOTOMETRIC_YCBCR:
            /*
             * TODO: if at all meaningful and useful, make more complete
             * support check here, or better still, refactor to let supporting
             * code decide whether there is support and what meaningful
             * error to return
             */
            break;
        case PHOTOMETRIC_RGB:
            if (colorchannels < 3) {
                sprintf(emsg, "Sorry, can not handle RGB image with %s=%d",
                    "Color channels", colorchannels);
                return (0);
            }
            break;
        case PHOTOMETRIC_SEPARATED:
            {
                uint16 inkset;
                TIFFGetFieldDefaulted(tif, TIFFTAG_INKSET, &inkset);
                if (inkset != INKSET_CMYK) {
                    sprintf(emsg,
                        "Sorry, can not handle separated image with %s=%d",
                        "InkSet", inkset);
                    return 0;
                }
                if (td->td_samplesperpixel < 4) {
                    sprintf(emsg,
                        "Sorry, can not handle separated image with %s=%d",
                        "Samples/pixel", td->td_samplesperpixel);
                    return 0;
                }
                break;
            }
        case PHOTOMETRIC_LOGL:
            if (td->td_compression != COMPRESSION_SGILOG) {
                sprintf(emsg, "Sorry, LogL data must have %s=%d",
                    "Compression", COMPRESSION_SGILOG);
                return (0);
            }
            break;
        case PHOTOMETRIC_LOGLUV:
            if (td->td_compression != COMPRESSION_SGILOG &&
                td->td_compression != COMPRESSION_SGILOG24) {
                sprintf(emsg, "Sorry, LogLuv data must have %s=%d or %d",
                    "Compression", COMPRESSION_SGILOG, COMPRESSION_SGILOG24);
                return (0);
            }
            if (td->td_planarconfig != PLANARCONFIG_CONTIG) {
                sprintf(emsg, "Sorry, can not handle LogLuv images with %s=%d",
                    "Planarconfiguration", td->td_planarconfig);
                return (0);
            }
            if ( td->td_samplesperpixel != 3 || colorchannels != 3 ) {
                                sprintf(emsg,
                                        "Sorry, can not handle image with %s=%d, %s=%d",
                                        "Samples/pixel", td->td_samplesperpixel,
                                        "colorchannels", colorchannels);
                                return 0;
                        }
            break;
        case PHOTOMETRIC_CIELAB:
                        if ( td->td_samplesperpixel != 3 || colorchannels != 3 || td->td_bitspersample != 8 ) {
                                sprintf(emsg,
                                        "Sorry, can not handle image with %s=%d, %s=%d and %s=%d",
                                        "Samples/pixel", td->td_samplesperpixel,
                                        "colorchannels", colorchannels,
                                        "Bits/sample", td->td_bitspersample);
                                return 0;
                        }
            break;
                default:
            sprintf(emsg, "Sorry, can not handle image with %s=%d",
                photoTag, photometric);
            return (0);
    }
    return (1);
}

Referenced by TIFFReadRGBAImageOriented(), TIFFReadRGBAStripExt(), TIFFReadRGBATileExt(), and TIFFRGBAImageBegin().

◆ TIFFScanlineSize()

tmsize_t TIFFScanlineSize ( TIFF * tif )

Definition at line 314 of file tif_strip.c.

{
    static const char module[] = "TIFFScanlineSize";
    uint64 m;
    m=TIFFScanlineSize64(tif);
    return _TIFFCastUInt64ToSSize(tif, m, module);
}

Referenced by gtStripContig(), gtStripSeparate(), PredictorSetup(), TIFFReadDirectory(), and TIFFWriteCheck().

◆ TIFFScanlineSize64()

uint64 TIFFScanlineSize64 ( TIFF * tif )

Definition at line 257 of file tif_strip.c.

{
    static const char module[] = "TIFFScanlineSize64";
    TIFFDirectory *td = &tif->tif_dir;
    uint64 scanline_size;
    if (td->td_planarconfig==PLANARCONFIG_CONTIG)
    {
        if ((td->td_photometric==PHOTOMETRIC_YCBCR)&&
            (td->td_samplesperpixel==3)&&
            (!isUpSampled(tif)))
        {
            uint16 ycbcrsubsampling[2];
            uint16 samplingblock_samples;
            uint32 samplingblocks_hor;
            uint64 samplingrow_samples;
            uint64 samplingrow_size;
            if(td->td_samplesperpixel!=3)
            {
                            TIFFErrorExt(tif->tif_clientdata,module,
                                         "Invalid td_samplesperpixel value");
                            return 0;
            }
            TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,
                                              ycbcrsubsampling+0,
                                              ycbcrsubsampling+1);
            if (((ycbcrsubsampling[0]!=1)&&(ycbcrsubsampling[0]!=2)&&(ycbcrsubsampling[0]!=4)) ||
                ((ycbcrsubsampling[1]!=1)&&(ycbcrsubsampling[1]!=2)&&(ycbcrsubsampling[1]!=4)))
            {
                            TIFFErrorExt(tif->tif_clientdata,module,
                                         "Invalid YCbCr subsampling");
                            return 0;
            }
            samplingblock_samples = ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
            samplingblocks_hor = TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]);
            samplingrow_samples = _TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
            samplingrow_size = TIFFhowmany_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module),8);
            scanline_size = (samplingrow_size/ycbcrsubsampling[1]);
        }
        else
        {
            uint64 scanline_samples;
            scanline_samples=_TIFFMultiply64(tif,td->td_imagewidth,td->td_samplesperpixel,module);
            scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,scanline_samples,td->td_bitspersample,module),8);
        }
    }
    else
        {
        scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,td->td_imagewidth,td->td_bitspersample,module),8);
        }
        if (scanline_size == 0)
        {
                TIFFErrorExt(tif->tif_clientdata,module,"Computed scanline size is zero");
                return 0;
        }
    return(scanline_size);
}

Referenced by _TIFFDefaultStripSize(), ByteCountLooksBad(), EstimateStripByteCounts(), TIFFScanlineSize(), and TIFFVStripSize64().

◆ TIFFSetClientdata()

thandle_t TIFFSetClientdata	(	TIFF *	tif,
		thandle_t	newvalue
	)

Definition at line 562 of file tif_open.c.

{
    thandle_t m = tif->tif_clientdata;
    tif->tif_clientdata = newvalue;
    return m;
}

◆ TIFFSetClientInfo()

void TIFFSetClientInfo	(	TIFF *	tif,
		void *	data,
		const char *	name
	)

Definition at line 78 of file tif_extension.c.

{
    TIFFClientInfoLink *psLink = tif->tif_clientinfo;
 
    /*
    ** Do we have an existing link with this name?  If so, just
    ** set it.
    */
    while( psLink != NULL && strcmp(psLink->name,name) != 0 )
        psLink = psLink->next;
 
    if( psLink != NULL )
    {
        psLink->data = data;
        return;
    }
 
    /*
    ** Create a new link.
    */
 
    psLink = (TIFFClientInfoLink *) _TIFFmalloc(sizeof(TIFFClientInfoLink));
    assert (psLink != NULL);
    psLink->next = tif->tif_clientinfo;
    psLink->name = (char *) _TIFFmalloc((tmsize_t)(strlen(name)+1));
    assert (psLink->name != NULL);
    strcpy(psLink->name, name);
    psLink->data = data;
 
    tif->tif_clientinfo = psLink;
}

◆ TIFFSetDirectory()

int TIFFSetDirectory	(	TIFF *	tif,
		uint16	dirn
	)

Definition at line 1617 of file tif_dir.c.

{
    uint64 nextdir;
    uint16 n;
 
    if (!(tif->tif_flags&TIFF_BIGTIFF))
        nextdir = tif->tif_header.classic.tiff_diroff;
    else
        nextdir = tif->tif_header.big.tiff_diroff;
    for (n = dirn; n > 0 && nextdir != 0; n--)
        if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
            return (0);
    tif->tif_nextdiroff = nextdir;
    /*
     * Set curdir to the actual directory index.  The
     * -1 is because TIFFReadDirectory will increment
     * tif_curdir after successfully reading the directory.
     */
    tif->tif_curdir = (dirn - n) - 1;
    /*
     * Reset tif_dirnumber counter and start new list of seen directories.
     * We need this to prevent IFD loops.
     */
    tif->tif_dirnumber = 0;
    return (TIFFReadDirectory(tif));
}

Referenced by tiff_decoder_select_frame().

◆ TIFFSetErrorHandler()

void void void void TIFFErrorHandler TIFFSetErrorHandler ( TIFFErrorHandler handler )

Definition at line 33 of file tif_error.c.

{
    TIFFErrorHandler prev = _TIFFerrorHandler;
    _TIFFerrorHandler = handler;
    return (prev);
}

Referenced by tiff_decoder_create(), and tiff_encoder_create().

◆ TIFFSetErrorHandlerExt()

TIFFErrorHandlerExt TIFFSetErrorHandlerExt ( TIFFErrorHandlerExt handler )

Definition at line 41 of file tif_error.c.

{
    TIFFErrorHandlerExt prev = _TIFFerrorHandlerExt;
    _TIFFerrorHandlerExt = handler;
    return (prev);
}

◆ TIFFSetField()

int TIFFSetField	(	TIFF *	tif,
		uint32	tag,
			...
	)

Definition at line 807 of file tif_dir.c.

{
    va_list ap;
    int status;
 
    va_start(ap, tag);
    status = TIFFVSetField(tif, tag, ap);
    va_end(ap);
    return (status);
}

Referenced by allocChoppedUpStripArrays(), tiff_encoder_create_frame(), TIFFDefaultDirectory(), TIFFFetchNormalTag(), TIFFFetchSubjectDistance(), TIFFReadDirectory(), and TIFFRGBAImageBegin().

◆ TIFFSetFileName()

const char * TIFFSetFileName	(	TIFF *	tif,
		const char *	name
	)

Definition at line 522 of file tif_open.c.

{
    const char* old_name = tif->tif_name;
    tif->tif_name = (char *)name;
    return (old_name);
}

◆ TIFFSetFileno()

int TIFFSetFileno	(	TIFF *	tif,
		int	fd
	)

Definition at line 542 of file tif_open.c.

{
        int old_fd = tif->tif_fd;
    tif->tif_fd = fd;
    return old_fd;
}

◆ TIFFSetMode()

int TIFFSetMode	(	TIFF *	tif,
		int	mode
	)

Definition at line 582 of file tif_open.c.

{
    int old_mode = tif->tif_mode;
    tif->tif_mode = mode;
    return (old_mode);
}

◆ TIFFSetSubDirectory()

int TIFFSetSubDirectory	(	TIFF *	tif,
		uint64	diroff
	)

Definition at line 1651 of file tif_dir.c.

{
    tif->tif_nextdiroff = diroff;
    /*
     * Reset tif_dirnumber counter and start new list of seen directories.
     * We need this to prevent IFD loops.
     */
    tif->tif_dirnumber = 0;
    return (TIFFReadDirectory(tif));
}

◆ TIFFSetTagExtender()

TIFFExtendProc TIFFSetTagExtender ( TIFFExtendProc extender )

Definition at line 1312 of file tif_dir.c.

{
    TIFFExtendProc prev = _TIFFextender;
    _TIFFextender = extender;
    return (prev);
}

◆ TIFFSetupStrips()

int TIFFSetupStrips ( TIFF * tif )

Definition at line 523 of file tif_write.c.

{
    TIFFDirectory* td = &tif->tif_dir;
 
    if (isTiled(tif))
        td->td_stripsperimage =
            isUnspecified(tif, FIELD_TILEDIMENSIONS) ?
            td->td_samplesperpixel : TIFFNumberOfTiles(tif);
    else
        td->td_stripsperimage =
            isUnspecified(tif, FIELD_ROWSPERSTRIP) ?
            td->td_samplesperpixel : TIFFNumberOfStrips(tif);
    td->td_nstrips = td->td_stripsperimage;
    if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
        td->td_stripsperimage /= td->td_samplesperpixel;
    td->td_stripoffset_p = (uint64 *)
            _TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint64),
                             "for \"StripOffsets\" array");
    td->td_stripbytecount_p = (uint64 *)
            _TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint64),
                             "for \"StripByteCounts\" array");
    if (td->td_stripoffset_p == NULL || td->td_stripbytecount_p == NULL)
        return (0);
    /*
     * Place data at the end-of-file
     * (by setting offsets to zero).
     */
    _TIFFmemset(td->td_stripoffset_p, 0, td->td_nstrips*sizeof (uint64));
    _TIFFmemset(td->td_stripbytecount_p, 0, td->td_nstrips*sizeof (uint64));
    TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS);
    TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
    return (1);
}

Referenced by TIFFCheckpointDirectory(), TIFFForceStrileArrayWriting(), TIFFReadDirectory(), and TIFFWriteCheck().

◆ TIFFSetWarningHandler()

TIFFErrorHandler TIFFSetWarningHandler ( TIFFErrorHandler handler )

Definition at line 33 of file tif_warning.c.

{
    TIFFErrorHandler prev = _TIFFwarningHandler;
    _TIFFwarningHandler = handler;
    return (prev);
}

Referenced by tiff_decoder_create(), and tiff_encoder_create().

◆ TIFFSetWarningHandlerExt()

TIFFErrorHandlerExt TIFFSetWarningHandlerExt ( TIFFErrorHandlerExt handler )

Definition at line 41 of file tif_warning.c.

{
    TIFFErrorHandlerExt prev = _TIFFwarningHandlerExt;
    _TIFFwarningHandlerExt = handler;
    return (prev);
}

◆ TIFFSetWriteOffset()

void TIFFSetWriteOffset	(	TIFF *	tif,
		toff_t	off
	)

Definition at line 834 of file tif_write.c.

{
    tif->tif_curoff = off;
}

Referenced by TIFFCheckpointDirectory().

◆ TIFFStripSize()

tmsize_t TIFFStripSize ( TIFF * tif )

Definition at line 202 of file tif_strip.c.

{
    static const char module[] = "TIFFStripSize";
    uint64 m;
    m=TIFFStripSize64(tif);
    return _TIFFCastUInt64ToSSize(tif, m, module);
}

Referenced by gtStripContig(), gtStripSeparate(), TIFFFillStrip(), TIFFReadDirectory(), and TIFFWriteBufferSetup().

◆ TIFFStripSize64()

uint64 TIFFStripSize64 ( TIFF * tif )

Definition at line 193 of file tif_strip.c.

{
    TIFFDirectory* td = &tif->tif_dir;
    uint32 rps = td->td_rowsperstrip;
    if (rps > td->td_imagelength)
        rps = td->td_imagelength;
    return (TIFFVStripSize64(tif, rps));
}

Referenced by _TIFFRewriteField(), TIFFReadDirectory(), TIFFStripSize(), TIFFWriteDirectoryTagLongLong8Array(), and TryChopUpUncompressedBigTiff().

◆ TIFFSwabArrayOfDouble()

void TIFFSwabArrayOfDouble	(	double *	dp,
		tmsize_t	n
	)

Definition at line 182 of file tif_swab.c.

{
    register unsigned char *cp;
    register unsigned char t;
    assert(sizeof(double)==8);
    /* XXX unroll loop some */
    while (n-- > 0) {
        cp = (unsigned char *)dp;
        t = cp[7]; cp[7] = cp[0]; cp[0] = t;
        t = cp[6]; cp[6] = cp[1]; cp[1] = t;
        t = cp[5]; cp[5] = cp[2]; cp[2] = t;
        t = cp[4]; cp[4] = cp[3]; cp[3] = t;
        dp++;
    }
}

Referenced by _TIFFSwab64BitData(), and TIFFWriteDirectoryTagCheckedDoubleArray().

◆ TIFFSwabArrayOfFloat()

void TIFFSwabArrayOfFloat	(	float *	fp,
		tmsize_t	n
	)

◆ TIFFSwabArrayOfLong()

void TIFFSwabArrayOfLong	(	uint32 *	lp,
		tmsize_t	n
	)

◆ TIFFSwabArrayOfLong8()

void TIFFSwabArrayOfLong8	(	uint64 *	lp,
		tmsize_t	n
	)

◆ TIFFSwabArrayOfShort()

void TIFFSwabArrayOfShort	(	uint16 *	wp,
		tmsize_t	n
	)

◆ TIFFSwabArrayOfTriples()

void TIFFSwabArrayOfTriples	(	uint8 *	tp,
		tmsize_t	n
	)

◆ TIFFSwabDouble()

void TIFFSwabDouble ( double * dp )

Definition at line 168 of file tif_swab.c.

{
    register unsigned char* cp = (unsigned char*) dp;
    unsigned char t;
    assert(sizeof(double)==8);
    t = cp[7]; cp[7] = cp[0]; cp[0] = t;
    t = cp[6]; cp[6] = cp[1]; cp[1] = t;
    t = cp[5]; cp[5] = cp[2]; cp[2] = t;
    t = cp[4]; cp[4] = cp[3]; cp[3] = t;
}

◆ TIFFSwabFloat()

void TIFFSwabFloat ( float * fp )

Definition at line 139 of file tif_swab.c.

{
    register unsigned char* cp = (unsigned char*) fp;
    unsigned char t;
    assert(sizeof(float)==4);
    t = cp[3]; cp[3] = cp[0]; cp[0] = t;
    t = cp[2]; cp[2] = cp[1]; cp[1] = t;
}

◆ TIFFSwabLong()

void TIFFSwabLong ( uint32 * lp )

Definition at line 45 of file tif_swab.c.

{
    register unsigned char* cp = (unsigned char*) lp;
    unsigned char t;
    assert(sizeof(uint32)==4);
    t = cp[3]; cp[3] = cp[0]; cp[0] = t;
    t = cp[2]; cp[2] = cp[1]; cp[1] = t;
}

◆ TIFFSwabLong8()

void TIFFSwabLong8 ( uint64 * lp )

Definition at line 57 of file tif_swab.c.

{
    register unsigned char* cp = (unsigned char*) lp;
    unsigned char t;
    assert(sizeof(uint64)==8);
    t = cp[7]; cp[7] = cp[0]; cp[0] = t;
    t = cp[6]; cp[6] = cp[1]; cp[1] = t;
    t = cp[5]; cp[5] = cp[2]; cp[2] = t;
    t = cp[4]; cp[4] = cp[3]; cp[3] = t;
}

◆ TIFFSwabShort()

void TIFFSwabShort ( uint16 * wp )

Definition at line 34 of file tif_swab.c.

{
    register unsigned char* cp = (unsigned char*) wp;
    unsigned char t;
    assert(sizeof(uint16)==2);
    t = cp[1]; cp[1] = cp[0]; cp[0] = t;
}

◆ TIFFTileRowSize()

tmsize_t TIFFTileRowSize ( TIFF * tif )

Definition at line 180 of file tif_tile.c.

{
    static const char module[] = "TIFFTileRowSize";
    uint64 m;
    m=TIFFTileRowSize64(tif);
    return _TIFFCastUInt64ToSSize(tif, m, module);
}

Referenced by gtTileContig(), gtTileSeparate(), and PredictorSetup().

◆ TIFFTileRowSize64()

uint64 TIFFTileRowSize64 ( TIFF * tif )

Definition at line 142 of file tif_tile.c.

{
        static const char module[] = "TIFFTileRowSize64";
    TIFFDirectory *td = &tif->tif_dir;
    uint64 rowsize;
    uint64 tilerowsize;
 
    if (td->td_tilelength == 0)
        {
                TIFFErrorExt(tif->tif_clientdata,module,"Tile length is zero");
                return 0;
        }
        if (td->td_tilewidth == 0)
        {
                TIFFErrorExt(tif->tif_clientdata,module,"Tile width is zero");
        return (0);
        }
    rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
        "TIFFTileRowSize");
    if (td->td_planarconfig == PLANARCONFIG_CONTIG)
        {
                if (td->td_samplesperpixel == 0)
                {
                        TIFFErrorExt(tif->tif_clientdata,module,"Samples per pixel is zero");
                        return 0;
                }
        rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
            "TIFFTileRowSize");
        }
        tilerowsize=TIFFhowmany8_64(rowsize);
        if (tilerowsize == 0)
        {
                TIFFErrorExt(tif->tif_clientdata,module,"Computed tile row size is zero");
                return 0;
        }
    return (tilerowsize);
}

Referenced by TIFFTileRowSize(), and TIFFVTileSize64().

◆ TIFFTileSize()

tmsize_t TIFFTileSize ( TIFF * tif )

Definition at line 257 of file tif_tile.c.

{
    static const char module[] = "TIFFTileSize";
    uint64 m;
    m=TIFFTileSize64(tif);
    return _TIFFCastUInt64ToSSize(tif, m, module);
}

Referenced by gtTileContig(), gtTileSeparate(), TIFFFillTile(), TIFFReadDirectory(), and TIFFWriteCheck().

◆ TIFFTileSize64()

uint64 TIFFTileSize64 ( TIFF * tif )

Definition at line 252 of file tif_tile.c.

{
    return (TIFFVTileSize64(tif, tif->tif_dir.td_tilelength));
}

Referenced by _TIFFRewriteField(), EstimateStripByteCounts(), TIFFTileSize(), and TIFFWriteDirectoryTagLongLong8Array().

◆ TIFFUnlinkDirectory()

int TIFFUnlinkDirectory	(	TIFF *	tif,
		uint16	dirn
	)

Definition at line 1685 of file tif_dir.c.

{
    static const char module[] = "TIFFUnlinkDirectory";
    uint64 nextdir;
    uint64 off;
    uint16 n;
 
    if (tif->tif_mode == O_RDONLY) {
        TIFFErrorExt(tif->tif_clientdata, module,
                             "Can not unlink directory in read-only file");
        return (0);
    }
    /*
     * Go to the directory before the one we want
     * to unlink and nab the offset of the link
     * field we'll need to patch.
     */
    if (!(tif->tif_flags&TIFF_BIGTIFF))
    {
        nextdir = tif->tif_header.classic.tiff_diroff;
        off = 4;
    }
    else
    {
        nextdir = tif->tif_header.big.tiff_diroff;
        off = 8;
    }
    for (n = dirn-1; n > 0; n--) {
        if (nextdir == 0) {
            TIFFErrorExt(tif->tif_clientdata, module, "Directory %d does not exist", dirn);
            return (0);
        }
        if (!TIFFAdvanceDirectory(tif, &nextdir, &off))
            return (0);
    }
    /*
     * Advance to the directory to be unlinked and fetch
     * the offset of the directory that follows.
     */
    if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
        return (0);
    /*
     * Go back and patch the link field of the preceding
     * directory to point to the offset of the directory
     * that follows.
     */
    (void) TIFFSeekFile(tif, off, SEEK_SET);
    if (!(tif->tif_flags&TIFF_BIGTIFF))
    {
        uint32 nextdir32;
        nextdir32=(uint32)nextdir;
        assert((uint64)nextdir32==nextdir);
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong(&nextdir32);
        if (!WriteOK(tif, &nextdir32, sizeof (uint32))) {
            TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link");
            return (0);
        }
    }
    else
    {
        if (tif->tif_flags & TIFF_SWAB)
            TIFFSwabLong8(&nextdir);
        if (!WriteOK(tif, &nextdir, sizeof (uint64))) {
            TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link");
            return (0);
        }
    }
    /*
     * Leave directory state setup safely.  We don't have
     * facilities for doing inserting and removing directories,
     * so it's safest to just invalidate everything.  This
     * means that the caller can only append to the directory
     * chain.
     */
    (*tif->tif_cleanup)(tif);
    if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
        _TIFFfree(tif->tif_rawdata);
        tif->tif_rawdata = NULL;
        tif->tif_rawcc = 0;
                tif->tif_rawdataoff = 0;
                tif->tif_rawdataloaded = 0;
    }
    tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP|TIFF_POSTENCODE|TIFF_BUF4WRITE);
    TIFFFreeDirectory(tif);
    TIFFDefaultDirectory(tif);
    tif->tif_diroff = 0;            /* force link on next write */
    tif->tif_nextdiroff = 0;        /* next write must be at end */
    tif->tif_curoff = 0;
    tif->tif_row = (uint32) -1;
    tif->tif_curstrip = (uint32) -1;
    return (1);
}

◆ TIFFUnRegisterCODEC()

void TIFFUnRegisterCODEC ( TIFFCodec * c )

Definition at line 224 of file tif_compress.c.

{
    codec_t* cd;
    codec_t** pcd;
 
    for (pcd = &registeredCODECS; (cd = *pcd) != NULL; pcd = &cd->next)
        if (cd->info == c) {
            *pcd = cd->next;
            _TIFFfree(cd);
            return;
        }
    TIFFErrorExt(0, "TIFFUnRegisterCODEC",
        "Cannot remove compression scheme %s; not registered", c->name);
}

◆ TIFFUnsetField()

int TIFFUnsetField	(	TIFF *	tif,
		uint32	tag
	)

Definition at line 822 of file tif_dir.c.

{
    const TIFFField *fip =  TIFFFieldWithTag(tif, tag);
    TIFFDirectory* td = &tif->tif_dir;
 
    if( !fip )
        return 0;
 
    if( fip->field_bit != FIELD_CUSTOM )
        TIFFClrFieldBit(tif, fip->field_bit);
    else
    {
        TIFFTagValue *tv = NULL;
        int i;
 
        for (i = 0; i < td->td_customValueCount; i++) {
                
            tv = td->td_customValues + i;
            if( tv->info->field_tag == tag )
                break;
        }
 
        if( i < td->td_customValueCount )
        {
            _TIFFfree(tv->value);
            for( ; i < td->td_customValueCount-1; i++) {
                td->td_customValues[i] = td->td_customValues[i+1];
            }
            td->td_customValueCount--;
        }
    }
        
    tif->tif_flags |= TIFF_DIRTYDIRECT;
 
    return (1);
}

◆ TIFFVGetField()

int TIFFVGetField	(	TIFF *	tif,
		uint32	tag,
		va_list	ap
	)

Definition at line 1250 of file tif_dir.c.

{
    const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY);
    return (fip && (isPseudoTag(tag) || TIFFFieldSet(tif, fip->field_bit)) ?
        (*tif->tif_tagmethods.vgetfield)(tif, tag, ap) : 0);
}

Referenced by TIFFGetField(), and TIFFVGetFieldDefaulted().

◆ TIFFVGetFieldDefaulted()

int TIFFVGetFieldDefaulted	(	TIFF *	tif,
		uint32	tag,
		va_list	ap
	)

Definition at line 209 of file tif_aux.c.

{
    TIFFDirectory *td = &tif->tif_dir;
 
    if (TIFFVGetField(tif, tag, ap))
        return (1);
    switch (tag) {
    case TIFFTAG_SUBFILETYPE:
        *va_arg(ap, uint32 *) = td->td_subfiletype;
        return (1);
    case TIFFTAG_BITSPERSAMPLE:
        *va_arg(ap, uint16 *) = td->td_bitspersample;
        return (1);
    case TIFFTAG_THRESHHOLDING:
        *va_arg(ap, uint16 *) = td->td_threshholding;
        return (1);
    case TIFFTAG_FILLORDER:
        *va_arg(ap, uint16 *) = td->td_fillorder;
        return (1);
    case TIFFTAG_ORIENTATION:
        *va_arg(ap, uint16 *) = td->td_orientation;
        return (1);
    case TIFFTAG_SAMPLESPERPIXEL:
        *va_arg(ap, uint16 *) = td->td_samplesperpixel;
        return (1);
    case TIFFTAG_ROWSPERSTRIP:
        *va_arg(ap, uint32 *) = td->td_rowsperstrip;
        return (1);
    case TIFFTAG_MINSAMPLEVALUE:
        *va_arg(ap, uint16 *) = td->td_minsamplevalue;
        return (1);
    case TIFFTAG_MAXSAMPLEVALUE:
        *va_arg(ap, uint16 *) = td->td_maxsamplevalue;
        return (1);
    case TIFFTAG_PLANARCONFIG:
        *va_arg(ap, uint16 *) = td->td_planarconfig;
        return (1);
    case TIFFTAG_RESOLUTIONUNIT:
        *va_arg(ap, uint16 *) = td->td_resolutionunit;
        return (1);
    case TIFFTAG_PREDICTOR:
    {
        TIFFPredictorState* sp = (TIFFPredictorState*) tif->tif_data;
        if( sp == NULL )
        {
            TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
                         "Cannot get \"Predictor\" tag as plugin is not configured");
            *va_arg(ap, uint16*) = 0;
            return 0;
        }
        *va_arg(ap, uint16*) = (uint16) sp->predictor;
        return 1;
    }
    case TIFFTAG_DOTRANGE:
        *va_arg(ap, uint16 *) = 0;
        *va_arg(ap, uint16 *) = (1<<td->td_bitspersample)-1;
        return (1);
    case TIFFTAG_INKSET:
        *va_arg(ap, uint16 *) = INKSET_CMYK;
        return 1;
    case TIFFTAG_NUMBEROFINKS:
        *va_arg(ap, uint16 *) = 4;
        return (1);
    case TIFFTAG_EXTRASAMPLES:
        *va_arg(ap, uint16 *) = td->td_extrasamples;
        *va_arg(ap, uint16 **) = td->td_sampleinfo;
        return (1);
    case TIFFTAG_MATTEING:
        *va_arg(ap, uint16 *) =
            (td->td_extrasamples == 1 &&
             td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
        return (1);
    case TIFFTAG_TILEDEPTH:
        *va_arg(ap, uint32 *) = td->td_tiledepth;
        return (1);
    case TIFFTAG_DATATYPE:
        *va_arg(ap, uint16 *) = td->td_sampleformat-1;
        return (1);
    case TIFFTAG_SAMPLEFORMAT:
        *va_arg(ap, uint16 *) = td->td_sampleformat;
                return(1);
    case TIFFTAG_IMAGEDEPTH:
        *va_arg(ap, uint32 *) = td->td_imagedepth;
        return (1);
    case TIFFTAG_YCBCRCOEFFICIENTS:
        {
            /* defaults are from CCIR Recommendation 601-1 */
            static float ycbcrcoeffs[] = { 0.299f, 0.587f, 0.114f };
            *va_arg(ap, float **) = ycbcrcoeffs;
            return 1;
        }
    case TIFFTAG_YCBCRSUBSAMPLING:
        *va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[0];
        *va_arg(ap, uint16 *) = td->td_ycbcrsubsampling[1];
        return (1);
    case TIFFTAG_YCBCRPOSITIONING:
        *va_arg(ap, uint16 *) = td->td_ycbcrpositioning;
        return (1);
    case TIFFTAG_WHITEPOINT:
        {
            static float whitepoint[2];
 
            /* TIFF 6.0 specification tells that it is no default
               value for the WhitePoint, but AdobePhotoshop TIFF
               Technical Note tells that it should be CIE D50. */
            whitepoint[0] = D50_X0 / (D50_X0 + D50_Y0 + D50_Z0);
            whitepoint[1] = D50_Y0 / (D50_X0 + D50_Y0 + D50_Z0);
            *va_arg(ap, float **) = whitepoint;
            return 1;
        }
    case TIFFTAG_TRANSFERFUNCTION:
        if (!td->td_transferfunction[0] &&
            !TIFFDefaultTransferFunction(td)) {
            TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "No space for \"TransferFunction\" tag");
            return (0);
        }
        *va_arg(ap, uint16 **) = td->td_transferfunction[0];
        if (td->td_samplesperpixel - td->td_extrasamples > 1) {
            *va_arg(ap, uint16 **) = td->td_transferfunction[1];
            *va_arg(ap, uint16 **) = td->td_transferfunction[2];
        }
        return (1);
    case TIFFTAG_REFERENCEBLACKWHITE:
        if (!td->td_refblackwhite && !TIFFDefaultRefBlackWhite(td))
            return (0);
        *va_arg(ap, float **) = td->td_refblackwhite;
        return (1);
    }
    return 0;
}

Referenced by TIFFGetFieldDefaulted().

◆ TIFFVSetField()

int TIFFVSetField	(	TIFF *	tif,
		uint32	tag,
		va_list	ap
	)

Definition at line 866 of file tif_dir.c.

{
    return OkToChangeTag(tif, tag) ?
        (*tif->tif_tagmethods.vsetfield)(tif, tag, ap) : 0;
}

Referenced by TIFFSetField().

◆ TIFFVStripSize()

tmsize_t TIFFVStripSize	(	TIFF *	tif,
		uint32	nrows
	)

Definition at line 128 of file tif_strip.c.

{
    static const char module[] = "TIFFVStripSize";
    uint64 m;
    m=TIFFVStripSize64(tif,nrows);
        return _TIFFCastUInt64ToSSize(tif, m, module);
}

Referenced by TIFFReadEncodedStripGetStripSize().

◆ TIFFVStripSize64()

uint64 TIFFVStripSize64	(	TIFF *	tif,
		uint32	nrows
	)

Definition at line 76 of file tif_strip.c.

{
    static const char module[] = "TIFFVStripSize64";
    TIFFDirectory *td = &tif->tif_dir;
    if (nrows==(uint32)(-1))
        nrows=td->td_imagelength;
    if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&&
        (td->td_photometric == PHOTOMETRIC_YCBCR)&&
        (!isUpSampled(tif)))
    {
        /*
         * Packed YCbCr data contain one Cb+Cr for every
         * HorizontalSampling*VerticalSampling Y values.
         * Must also roundup width and height when calculating
         * since images that are not a multiple of the
         * horizontal/vertical subsampling area include
         * YCbCr data for the extended image.
         */
        uint16 ycbcrsubsampling[2];
        uint16 samplingblock_samples;
        uint32 samplingblocks_hor;
        uint32 samplingblocks_ver;
        uint64 samplingrow_samples;
        uint64 samplingrow_size;
        if(td->td_samplesperpixel!=3)
        {
            TIFFErrorExt(tif->tif_clientdata,module,
                "Invalid td_samplesperpixel value");
            return 0;
        }
        TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0,
            ycbcrsubsampling+1);
        if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4)
            ||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4))
        {
            TIFFErrorExt(tif->tif_clientdata,module,
                     "Invalid YCbCr subsampling (%dx%d)", 
                     ycbcrsubsampling[0], 
                     ycbcrsubsampling[1] );
            return 0;
        }
        samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
        samplingblocks_hor=TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]);
        samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
        samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
        samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
        return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
    }
    else
        return(_TIFFMultiply64(tif,nrows,TIFFScanlineSize64(tif),module));
}

Referenced by TIFFStripSize64(), TIFFVStripSize(), and TryChopUpUncompressedBigTiff().

◆ TIFFVTileSize()

tmsize_t TIFFVTileSize	(	TIFF *	tif,
		uint32	nrows
	)

Definition at line 240 of file tif_tile.c.

{
    static const char module[] = "TIFFVTileSize";
    uint64 m;
    m=TIFFVTileSize64(tif,nrows);
    return _TIFFCastUInt64ToSSize(tif, m, module);
}

◆ TIFFVTileSize64()

uint64 TIFFVTileSize64	(	TIFF *	tif,
		uint32	nrows
	)

Definition at line 192 of file tif_tile.c.

{
    static const char module[] = "TIFFVTileSize64";
    TIFFDirectory *td = &tif->tif_dir;
    if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
        td->td_tiledepth == 0)
        return (0);
    if ((td->td_planarconfig==PLANARCONFIG_CONTIG)&&
        (td->td_photometric==PHOTOMETRIC_YCBCR)&&
        (td->td_samplesperpixel==3)&&
        (!isUpSampled(tif)))
    {
        /*
         * Packed YCbCr data contain one Cb+Cr for every
         * HorizontalSampling*VerticalSampling Y values.
         * Must also roundup width and height when calculating
         * since images that are not a multiple of the
         * horizontal/vertical subsampling area include
         * YCbCr data for the extended image.
         */
        uint16 ycbcrsubsampling[2];
        uint16 samplingblock_samples;
        uint32 samplingblocks_hor;
        uint32 samplingblocks_ver;
        uint64 samplingrow_samples;
        uint64 samplingrow_size;
        TIFFGetFieldDefaulted(tif,TIFFTAG_YCBCRSUBSAMPLING,ycbcrsubsampling+0,
            ycbcrsubsampling+1);
        if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 && ycbcrsubsampling[0] != 4)
            ||(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 && ycbcrsubsampling[1] != 4))
        {
            TIFFErrorExt(tif->tif_clientdata,module,
                     "Invalid YCbCr subsampling (%dx%d)", 
                     ycbcrsubsampling[0], 
                     ycbcrsubsampling[1] );
            return 0;
        }
        samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
        samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampling[0]);
        samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
        samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
        samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
        return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
    }
    else
        return(_TIFFMultiply64(tif,nrows,TIFFTileRowSize64(tif),module));
}

Referenced by ChopUpSingleUncompressedStrip(), TIFFTileSize64(), and TIFFVTileSize().

◆ TIFFWarning()

void void void TIFFWarning	(	const char *	,
		const char *	,
			...
	)

◆ TIFFWarningExt()

void void void void TIFFWarningExt	(	thandle_t	,
		const char *	,
		const char *	,
			...
	)

◆ TIFFWriteBufferSetup()

int TIFFWriteBufferSetup	(	TIFF *	tif,
		void *	bp,
		tmsize_t	size
	)

Definition at line 650 of file tif_write.c.

{
    static const char module[] = "TIFFWriteBufferSetup";
 
    if (tif->tif_rawdata) {
        if (tif->tif_flags & TIFF_MYBUFFER) {
            _TIFFfree(tif->tif_rawdata);
            tif->tif_flags &= ~TIFF_MYBUFFER;
        }
        tif->tif_rawdata = NULL;
    }
    if (size == (tmsize_t)(-1)) {
        size = (isTiled(tif) ?
            tif->tif_tilesize : TIFFStripSize(tif));
        /*
         * Make raw data buffer at least 8K
         */
        if (size < 8*1024)
            size = 8*1024;
        bp = NULL;          /* NB: force malloc */
    }
    if (bp == NULL) {
        bp = _TIFFmalloc(size);
        if (bp == NULL) {
            TIFFErrorExt(tif->tif_clientdata, module, "No space for output buffer");
            return (0);
        }
        tif->tif_flags |= TIFF_MYBUFFER;
    } else
        tif->tif_flags &= ~TIFF_MYBUFFER;
    tif->tif_rawdata = (uint8*) bp;
    tif->tif_rawdatasize = size;
    tif->tif_rawcc = 0;
    tif->tif_rawcp = tif->tif_rawdata;
    tif->tif_flags |= TIFF_BUFFERSETUP;
    return (1);
}

Referenced by _TIFFReserveLargeEnoughWriteBuffer().

◆ TIFFWriteCheck()

int TIFFWriteCheck	(	TIFF *	tif,
		int	tiles,
		const char *	module
	)

Definition at line 565 of file tif_write.c.

{
    if (tif->tif_mode == O_RDONLY) {
        TIFFErrorExt(tif->tif_clientdata, module, "File not open for writing");
        return (0);
    }
    if (tiles ^ isTiled(tif)) {
        TIFFErrorExt(tif->tif_clientdata, module, tiles ?
            "Can not write tiles to a striped image" :
            "Can not write scanlines to a tiled image");
        return (0);
    }
 
        _TIFFFillStriles( tif );
        
    /*
     * On the first write verify all the required information
     * has been setup and initialize any data structures that
     * had to wait until directory information was set.
     * Note that a lot of our work is assumed to remain valid
     * because we disallow any of the important parameters
     * from changing after we start writing (i.e. once
     * TIFF_BEENWRITING is set, TIFFSetField will only allow
     * the image's length to be changed).
     */
    if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) {
        TIFFErrorExt(tif->tif_clientdata, module,
            "Must set \"ImageWidth\" before writing data");
        return (0);
    }
    if (tif->tif_dir.td_samplesperpixel == 1) {
        /* 
         * Planarconfiguration is irrelevant in case of single band
         * images and need not be included. We will set it anyway,
         * because this field is used in other parts of library even
         * in the single band case.
         */
        if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG))
                    tif->tif_dir.td_planarconfig = PLANARCONFIG_CONTIG;
    } else {
        if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) {
            TIFFErrorExt(tif->tif_clientdata, module,
                "Must set \"PlanarConfiguration\" before writing data");
            return (0);
        }
    }
    if (tif->tif_dir.td_stripoffset_p == NULL && !TIFFSetupStrips(tif)) {
        tif->tif_dir.td_nstrips = 0;
        TIFFErrorExt(tif->tif_clientdata, module, "No space for %s arrays",
            isTiled(tif) ? "tile" : "strip");
        return (0);
    }
    if (isTiled(tif))
    {
        tif->tif_tilesize = TIFFTileSize(tif);
        if (tif->tif_tilesize == 0)
            return (0);
    }
    else
        tif->tif_tilesize = (tmsize_t)(-1);
    tif->tif_scanlinesize = TIFFScanlineSize(tif);
    if (tif->tif_scanlinesize == 0)
        return (0);
    tif->tif_flags |= TIFF_BEENWRITING;
 
        if( tif->tif_dir.td_stripoffset_entry.tdir_tag != 0 &&
            tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
            tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
            tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 &&
            tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0 &&
            tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
            tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
            tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0 &&
            !(tif->tif_flags & TIFF_DIRTYDIRECT)  )
        {
            TIFFForceStrileArrayWriting(tif);
        }
 
    return (1);
}

◆ TIFFWriteCustomDirectory()

int TIFFWriteCustomDirectory	(	TIFF *	tif,
		uint64 *	pdiroff
	)

Definition at line 249 of file tif_dirwrite.c.

{
    return TIFFWriteDirectorySec(tif,FALSE,FALSE,pdiroff);
}

◆ TIFFWriteDirectory()

int TIFFWriteDirectory ( TIFF * tif )

Definition at line 180 of file tif_dirwrite.c.

{
    return TIFFWriteDirectorySec(tif,TRUE,TRUE,NULL);
}

Referenced by tiff_encoder_create_frame(), and TIFFRewriteDirectory().

◆ TIFFWriteEncodedStrip()

tmsize_t TIFFWriteEncodedStrip	(	TIFF *	tif,
		uint32	strip,
		void *	data,
		tmsize_t	cc
	)

Definition at line 212 of file tif_write.c.

{
    static const char module[] = "TIFFWriteEncodedStrip";
    TIFFDirectory *td = &tif->tif_dir;
    uint16 sample;
 
    if (!WRITECHECKSTRIPS(tif, module))
        return ((tmsize_t) -1);
    /*
     * Check strip array to make sure there's space.
     * We don't support dynamically growing files that
     * have data organized in separate bitplanes because
     * it's too painful.  In that case we require that
     * the imagelength be set properly before the first
     * write (so that the strips array will be fully
     * allocated above).
     */
    if (strip >= td->td_nstrips) {
        if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
            TIFFErrorExt(tif->tif_clientdata, module,
                "Can not grow image by strips when using separate planes");
            return ((tmsize_t) -1);
        }
        if (!TIFFGrowStrips(tif, 1, module))
            return ((tmsize_t) -1);
        td->td_stripsperimage =
            TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip);  
    }
    /*
     * Handle delayed allocation of data buffer.  This
     * permits it to be sized according to the directory
     * info.
     */
    if (!BUFFERCHECK(tif))
        return ((tmsize_t) -1);
 
        tif->tif_flags |= TIFF_BUF4WRITE;
    tif->tif_curstrip = strip;
 
    if( !_TIFFReserveLargeEnoughWriteBuffer(tif, strip) ) {
            return ((tmsize_t)(-1));
        }
 
        tif->tif_rawcc = 0;
        tif->tif_rawcp = tif->tif_rawdata;
 
        if (td->td_stripsperimage == 0) {
                TIFFErrorExt(tif->tif_clientdata, module, "Zero strips per image");
                return ((tmsize_t) -1);
        }
 
    tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
    if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
        if (!(*tif->tif_setupencode)(tif))
            return ((tmsize_t) -1);
        tif->tif_flags |= TIFF_CODERSETUP;
    }
 
    tif->tif_flags &= ~TIFF_POSTENCODE;
 
    /* shortcut to avoid an extra memcpy() */
    if( td->td_compression == COMPRESSION_NONE )
    {
        /* swab if needed - note that source buffer will be altered */
        tif->tif_postdecode( tif, (uint8*) data, cc );
 
        if (!isFillOrder(tif, td->td_fillorder) &&
            (tif->tif_flags & TIFF_NOBITREV) == 0)
            TIFFReverseBits((uint8*) data, cc);
 
        if (cc > 0 &&
            !TIFFAppendToStrip(tif, strip, (uint8*) data, cc))
            return ((tmsize_t) -1);
        return (cc);
    }
 
    sample = (uint16)(strip / td->td_stripsperimage);
    if (!(*tif->tif_preencode)(tif, sample))
        return ((tmsize_t) -1);
 
        /* swab if needed - note that source buffer will be altered */
    tif->tif_postdecode( tif, (uint8*) data, cc );
 
    if (!(*tif->tif_encodestrip)(tif, (uint8*) data, cc, sample))
        return ((tmsize_t) -1);
    if (!(*tif->tif_postencode)(tif))
        return ((tmsize_t) -1);
    if (!isFillOrder(tif, td->td_fillorder) &&
        (tif->tif_flags & TIFF_NOBITREV) == 0)
        TIFFReverseBits(tif->tif_rawdata, tif->tif_rawcc);
    if (tif->tif_rawcc > 0 &&
        !TIFFAppendToStrip(tif, strip, tif->tif_rawdata, tif->tif_rawcc))
        return ((tmsize_t) -1);
    tif->tif_rawcc = 0;
    tif->tif_rawcp = tif->tif_rawdata;
    return (cc);
}

◆ TIFFWriteEncodedTile()

tmsize_t TIFFWriteEncodedTile	(	TIFF *	tif,
		uint32	tile,
		void *	data,
		tmsize_t	cc
	)

Definition at line 391 of file tif_write.c.

{
    static const char module[] = "TIFFWriteEncodedTile";
    TIFFDirectory *td;
    uint16 sample;
        uint32 howmany32;
 
    if (!WRITECHECKTILES(tif, module))
        return ((tmsize_t)(-1));
    td = &tif->tif_dir;
    if (tile >= td->td_nstrips) {
        TIFFErrorExt(tif->tif_clientdata, module, "Tile %lu out of range, max %lu",
            (unsigned long) tile, (unsigned long) td->td_nstrips);
        return ((tmsize_t)(-1));
    }
    /*
     * Handle delayed allocation of data buffer.  This
     * permits it to be sized more intelligently (using
     * directory information).
     */
    if (!BUFFERCHECK(tif))
        return ((tmsize_t)(-1));
 
        tif->tif_flags |= TIFF_BUF4WRITE;
    tif->tif_curtile = tile;
 
        if( !_TIFFReserveLargeEnoughWriteBuffer(tif, tile) ) {
            return ((tmsize_t)(-1));
        }
 
    tif->tif_rawcc = 0;
    tif->tif_rawcp = tif->tif_rawdata;
 
    /* 
     * Compute tiles per row & per column to compute
     * current row and column
     */
        howmany32=TIFFhowmany_32(td->td_imagelength, td->td_tilelength);
        if (howmany32 == 0) {
                 TIFFErrorExt(tif->tif_clientdata,module,"Zero tiles");
                return ((tmsize_t)(-1));
        }
    tif->tif_row = (tile % howmany32) * td->td_tilelength;
        howmany32=TIFFhowmany_32(td->td_imagewidth, td->td_tilewidth);
        if (howmany32 == 0) {
                 TIFFErrorExt(tif->tif_clientdata,module,"Zero tiles");
                return ((tmsize_t)(-1));
        }
    tif->tif_col = (tile % howmany32) * td->td_tilewidth;
 
    if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
        if (!(*tif->tif_setupencode)(tif))
            return ((tmsize_t)(-1));
        tif->tif_flags |= TIFF_CODERSETUP;
    }
    tif->tif_flags &= ~TIFF_POSTENCODE;
 
    /*
     * Clamp write amount to the tile size.  This is mostly
     * done so that callers can pass in some large number
     * (e.g. -1) and have the tile size used instead.
     */
    if ( cc < 1 || cc > tif->tif_tilesize)
        cc = tif->tif_tilesize;
 
    /* shortcut to avoid an extra memcpy() */
    if( td->td_compression == COMPRESSION_NONE )
    {
        /* swab if needed - note that source buffer will be altered */
        tif->tif_postdecode( tif, (uint8*) data, cc );
 
        if (!isFillOrder(tif, td->td_fillorder) &&
            (tif->tif_flags & TIFF_NOBITREV) == 0)
            TIFFReverseBits((uint8*) data, cc);
 
        if (cc > 0 &&
            !TIFFAppendToStrip(tif, tile, (uint8*) data, cc))
            return ((tmsize_t) -1);
        return (cc);
    }
 
    sample = (uint16)(tile/td->td_stripsperimage);
    if (!(*tif->tif_preencode)(tif, sample))
        return ((tmsize_t)(-1));
    /* swab if needed - note that source buffer will be altered */
    tif->tif_postdecode( tif, (uint8*) data, cc );
 
    if (!(*tif->tif_encodetile)(tif, (uint8*) data, cc, sample))
            return ((tmsize_t) -1);
    if (!(*tif->tif_postencode)(tif))
            return ((tmsize_t)(-1));
    if (!isFillOrder(tif, td->td_fillorder) &&
        (tif->tif_flags & TIFF_NOBITREV) == 0)
            TIFFReverseBits((uint8*)tif->tif_rawdata, tif->tif_rawcc);
    if (tif->tif_rawcc > 0 && !TIFFAppendToStrip(tif, tile,
        tif->tif_rawdata, tif->tif_rawcc))
            return ((tmsize_t)(-1));
    tif->tif_rawcc = 0;
    tif->tif_rawcp = tif->tif_rawdata;
    return (cc);
}

Referenced by TIFFWriteTile().

◆ TIFFWriteRawStrip()

tmsize_t TIFFWriteRawStrip	(	TIFF *	tif,
		uint32	strip,
		void *	data,
		tmsize_t	cc
	)

Definition at line 316 of file tif_write.c.

{
    static const char module[] = "TIFFWriteRawStrip";
    TIFFDirectory *td = &tif->tif_dir;
 
    if (!WRITECHECKSTRIPS(tif, module))
        return ((tmsize_t) -1);
    /*
     * Check strip array to make sure there's space.
     * We don't support dynamically growing files that
     * have data organized in separate bitplanes because
     * it's too painful.  In that case we require that
     * the imagelength be set properly before the first
     * write (so that the strips array will be fully
     * allocated above).
     */
    if (strip >= td->td_nstrips) {
        if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
            TIFFErrorExt(tif->tif_clientdata, module,
                "Can not grow image by strips when using separate planes");
            return ((tmsize_t) -1);
        }
        /*
         * Watch out for a growing image.  The value of
         * strips/image will initially be 1 (since it
         * can't be deduced until the imagelength is known).
         */
        if (strip >= td->td_stripsperimage)
            td->td_stripsperimage =
                TIFFhowmany_32(td->td_imagelength,td->td_rowsperstrip);
        if (!TIFFGrowStrips(tif, 1, module))
            return ((tmsize_t) -1);
    }
    tif->tif_curstrip = strip;
        if (td->td_stripsperimage == 0) {
                TIFFErrorExt(tif->tif_clientdata, module,"Zero strips per image");
                return ((tmsize_t) -1);
        }
    tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
    return (TIFFAppendToStrip(tif, strip, (uint8*) data, cc) ?
        cc : (tmsize_t) -1);
}

◆ TIFFWriteRawTile()

tmsize_t TIFFWriteRawTile	(	TIFF *	tif,
		uint32	tile,
		void *	data,
		tmsize_t	cc
	)

Definition at line 503 of file tif_write.c.

{
    static const char module[] = "TIFFWriteRawTile";
 
    if (!WRITECHECKTILES(tif, module))
        return ((tmsize_t)(-1));
    if (tile >= tif->tif_dir.td_nstrips) {
        TIFFErrorExt(tif->tif_clientdata, module, "Tile %lu out of range, max %lu",
            (unsigned long) tile,
            (unsigned long) tif->tif_dir.td_nstrips);
        return ((tmsize_t)(-1));
    }
    return (TIFFAppendToStrip(tif, tile, (uint8*) data, cc) ?
        cc : (tmsize_t)(-1));
}

◆ TIFFWriteScanline()

int TIFFWriteScanline	(	TIFF *	tif,
		void *	buf,
		uint32	row,
		uint16	sample
	)

Definition at line 47 of file tif_write.c.

{
    static const char module[] = "TIFFWriteScanline";
    register TIFFDirectory *td;
    int status, imagegrew = 0;
    uint32 strip;
 
    if (!WRITECHECKSTRIPS(tif, module))
        return (-1);
    /*
     * Handle delayed allocation of data buffer.  This
     * permits it to be sized more intelligently (using
     * directory information).
     */
    if (!BUFFERCHECK(tif))
        return (-1);
        tif->tif_flags |= TIFF_BUF4WRITE; /* not strictly sure this is right*/
 
    td = &tif->tif_dir;
    /*
     * Extend image length if needed
     * (but only for PlanarConfig=1).
     */
    if (row >= td->td_imagelength) {    /* extend image */
        if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
            TIFFErrorExt(tif->tif_clientdata, module,
                "Can not change \"ImageLength\" when using separate planes");
            return (-1);
        }
        td->td_imagelength = row+1;
        imagegrew = 1;
    }
    /*
     * Calculate strip and check for crossings.
     */
    if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
        if (sample >= td->td_samplesperpixel) {
            TIFFErrorExt(tif->tif_clientdata, module,
                "%lu: Sample out of range, max %lu",
                (unsigned long) sample, (unsigned long) td->td_samplesperpixel);
            return (-1);
        }
        strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip;
    } else
        strip = row / td->td_rowsperstrip;
    /*
     * Check strip array to make sure there's space. We don't support
     * dynamically growing files that have data organized in separate
     * bitplanes because it's too painful.  In that case we require that
     * the imagelength be set properly before the first write (so that the
     * strips array will be fully allocated above).
     */
    if (strip >= td->td_nstrips && !TIFFGrowStrips(tif, 1, module))
        return (-1);
    if (strip != tif->tif_curstrip) {
        /*
         * Changing strips -- flush any data present.
         */
        if (!TIFFFlushData(tif))
            return (-1);
        tif->tif_curstrip = strip;
        /*
         * Watch out for a growing image.  The value of strips/image
         * will initially be 1 (since it can't be deduced until the
         * imagelength is known).
         */
        if (strip >= td->td_stripsperimage && imagegrew)
            td->td_stripsperimage =
                TIFFhowmany_32(td->td_imagelength,td->td_rowsperstrip);
                if (td->td_stripsperimage == 0) {
                        TIFFErrorExt(tif->tif_clientdata, module, "Zero strips per image");
                        return (-1);
                }
        tif->tif_row =
            (strip % td->td_stripsperimage) * td->td_rowsperstrip;
        if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
            if (!(*tif->tif_setupencode)(tif))
                return (-1);
            tif->tif_flags |= TIFF_CODERSETUP;
        }
        
        tif->tif_rawcc = 0;
        tif->tif_rawcp = tif->tif_rawdata;
 
        if( td->td_stripbytecount_p[strip] > 0 )
        {
            /* if we are writing over existing tiles, zero length */
            td->td_stripbytecount_p[strip] = 0;
 
            /* this forces TIFFAppendToStrip() to do a seek */
            tif->tif_curoff = 0;
        }
 
        if (!(*tif->tif_preencode)(tif, sample))
            return (-1);
        tif->tif_flags |= TIFF_POSTENCODE;
    }
    /*
     * Ensure the write is either sequential or at the
     * beginning of a strip (or that we can randomly
     * access the data -- i.e. no encoding).
     */
    if (row != tif->tif_row) {
        if (row < tif->tif_row) {
            /*
             * Moving backwards within the same strip:
             * backup to the start and then decode
             * forward (below).
             */
            tif->tif_row = (strip % td->td_stripsperimage) *
                td->td_rowsperstrip;
            tif->tif_rawcp = tif->tif_rawdata;
        }
        /*
         * Seek forward to the desired row.
         */
        if (!(*tif->tif_seek)(tif, row - tif->tif_row))
            return (-1);
        tif->tif_row = row;
    }
 
    /* swab if needed - note that source buffer will be altered */
    tif->tif_postdecode( tif, (uint8*) buf, tif->tif_scanlinesize );
 
    status = (*tif->tif_encoderow)(tif, (uint8*) buf,
        tif->tif_scanlinesize, sample);
 
        /* we are now poised at the beginning of the next row */
    tif->tif_row = row + 1;
    return (status);
}

Referenced by tiff_encoder_write_lines().

◆ TIFFWriteTile()

tmsize_t TIFFWriteTile	(	TIFF *	tif,
		void *	buf,
		uint32	x,
		uint32	y,
		uint32	z,
		uint16	s
	)

Definition at line 364 of file tif_write.c.

{
    if (!TIFFCheckTile(tif, x, y, z, s))
        return ((tmsize_t)(-1));
    /*
     * NB: A tile size of -1 is used instead of tif_tilesize knowing
     *     that TIFFWriteEncodedTile will clamp this to the tile size.
     *     This is done because the tile size may not be defined until
     *     after the output buffer is setup in TIFFWriteBufferSetup.
     */
    return (TIFFWriteEncodedTile(tif,
        TIFFComputeTile(tif, x, y, z, s), buf, (tmsize_t)(-1)));
}

◆ TIFFXYZToRGB()

void TIFFXYZToRGB	(	TIFFCIELabToRGB *	cielab,
		float	X,
		float	Y,
		float	Z,
		uint32 *	r,
		uint32 *	g,
		uint32 *	b
	)

Definition at line 76 of file tif_color.c.

{
    int i;
    float Yr, Yg, Yb;
    float *matrix = &cielab->display.d_mat[0][0];
 
    /* Multiply through the matrix to get luminosity values. */
    Yr =  matrix[0] * X + matrix[1] * Y + matrix[2] * Z;
    Yg =  matrix[3] * X + matrix[4] * Y + matrix[5] * Z;
    Yb =  matrix[6] * X + matrix[7] * Y + matrix[8] * Z;
 
    /* Clip input */
    Yr = TIFFmax(Yr, cielab->display.d_Y0R);
    Yg = TIFFmax(Yg, cielab->display.d_Y0G);
    Yb = TIFFmax(Yb, cielab->display.d_Y0B);
 
    /* Avoid overflow in case of wrong input values */
    Yr = TIFFmin(Yr, cielab->display.d_YCR);
    Yg = TIFFmin(Yg, cielab->display.d_YCG);
    Yb = TIFFmin(Yb, cielab->display.d_YCB);
 
    /* Turn luminosity to colour value. */
    i = (int)((Yr - cielab->display.d_Y0R) / cielab->rstep);
    i = TIFFmin(cielab->range, i);
    *r = RINT(cielab->Yr2r[i]);
 
    i = (int)((Yg - cielab->display.d_Y0G) / cielab->gstep);
    i = TIFFmin(cielab->range, i);
    *g = RINT(cielab->Yg2g[i]);
 
    i = (int)((Yb - cielab->display.d_Y0B) / cielab->bstep);
    i = TIFFmin(cielab->range, i);
    *b = RINT(cielab->Yb2b[i]);
 
    /* Clip output. */
    *r = TIFFmin(*r, cielab->display.d_Vrwr);
    *g = TIFFmin(*g, cielab->display.d_Vrwg);
    *b = TIFFmin(*b, cielab->display.d_Vrwb);
}