#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(), 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);
}

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

◆ 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(), 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);
}

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

◆ 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;

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ __attribute__

◆ CIELABTORGB_TABLE_RANGE

◆ D50_X0

◆ D50_Y0

◆ D50_Z0

◆ D65_X0

◆ D65_Y0

◆ D65_Z0

◆ FIELD_CUSTOM

◆ LOGLUV_PUBLIC

◆ TIFF_ANY

◆ TIFF_SPP

◆ TIFF_VARIABLE

◆ TIFF_VARIABLE2

◆ TIFFGetA

◆ TIFFGetB

◆ TIFFGetG

◆ TIFFGetR

◆ TIFFPRINT_COLORMAP

◆ TIFFPRINT_CURVES

◆ TIFFPRINT_JPEGACTABLES

◆ TIFFPRINT_JPEGDCTABLES

◆ TIFFPRINT_JPEGQTABLES

◆ TIFFPRINT_NONE

◆ TIFFPRINT_STRIPS

◆ U_NEU

◆ UVSCALE

◆ V_NEU

Typedef Documentation

◆ tdata_t

◆ tdir_t

◆ thandle_t

◆ TIFF

◆ TIFFCloseProc

◆ TIFFErrorHandler

◆ TIFFErrorHandlerExt

◆ TIFFExtendProc

◆ TIFFField

◆ TIFFFieldArray

◆ TIFFInitMethod

◆ TIFFMapFileProc

◆ TIFFPrintMethod

◆ TIFFReadWriteProc

◆ TIFFRGBAImage

◆ TIFFRGBValue

◆ TIFFSeekProc

◆ TIFFSizeProc

◆ TIFFUnmapFileProc

◆ TIFFVGetMethod

◆ TIFFVSetMethod

◆ tileContigRoutine

◆ tileSeparateRoutine

◆ tmsize_t

◆ toff_t

◆ tsample_t

◆ tsize_t

◆ tstrile_t

◆ tstrip_t

◆ ttag_t

◆ ttile_t

Function Documentation

◆ _TIFFcalloc()

◆ _TIFFfree()

◆ _TIFFmalloc()

◆ _TIFFmemcmp()

◆ _TIFFmemcpy()

◆ _TIFFmemset()

◆ _TIFFrealloc()

◆ LogL10fromY()

◆ LogL10toY()

◆ LogL16fromY()

◆ LogL16toY()

◆ LogLuv24fromXYZ()

◆ LogLuv24toXYZ()

◆ LogLuv32fromXYZ()

◆ attribute