ReactOS 0.4.15-dev-7961-gdcf9eb0
Classes | Macros | Typedefs | Functions | Variables
tiffiop.h File Reference
#include "tif_config.h"
#include <fcntl.h>
#include <sys/types.h>
#include <string.h>
#include <assert.h>
#include <search.h>
#include "tiffio.h"
#include "tif_dir.h"
Include dependency graph for tiffiop.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  client_info
 
struct  tiff
 

Macros

#define STRIP_SIZE_DEFAULT   8192
 
#define streq(a, b)   (strcmp(a,b) == 0)
 
#define strneq(a, b, n)   (strncmp(a,b,n) == 0)
 
#define TRUE   1
 
#define FALSE   0
 
#define TIFF_SIZE_T_MAX   ((size_t) ~ ((size_t)0))
 
#define TIFF_TMSIZE_T_MAX   (tmsize_t)(TIFF_SIZE_T_MAX >> 1)
 
#define TIFF_UINT32_MAX   0xFFFFFFFFU
 
#define TIFF_UINT64_MAX   (((uint64)(TIFF_UINT32_MAX)) << 32 | TIFF_UINT32_MAX)
 
#define TIFF_FILLORDER   0x00003U /* natural bit fill order for machine */
 
#define TIFF_DIRTYHEADER   0x00004U /* header must be written on close */
 
#define TIFF_DIRTYDIRECT   0x00008U /* current directory must be written */
 
#define TIFF_BUFFERSETUP   0x00010U /* data buffers setup */
 
#define TIFF_CODERSETUP   0x00020U /* encoder/decoder setup done */
 
#define TIFF_BEENWRITING   0x00040U /* written 1+ scanlines to file */
 
#define TIFF_SWAB   0x00080U /* byte swap file information */
 
#define TIFF_NOBITREV   0x00100U /* inhibit bit reversal logic */
 
#define TIFF_MYBUFFER   0x00200U /* my raw data buffer; free on close */
 
#define TIFF_ISTILED   0x00400U /* file is tile, not strip- based */
 
#define TIFF_MAPPED   0x00800U /* file is mapped into memory */
 
#define TIFF_POSTENCODE   0x01000U /* need call to postencode routine */
 
#define TIFF_INSUBIFD   0x02000U /* currently writing a subifd */
 
#define TIFF_UPSAMPLED   0x04000U /* library is doing data up-sampling */
 
#define TIFF_STRIPCHOP   0x08000U /* enable strip chopping support */
 
#define TIFF_HEADERONLY   0x10000U /* read header only, do not process the first directory */
 
#define TIFF_NOREADRAW   0x20000U /* skip reading of raw uncompressed image data */
 
#define TIFF_INCUSTOMIFD   0x40000U /* currently writing a custom IFD */
 
#define TIFF_BIGTIFF   0x80000U /* read/write bigtiff */
 
#define TIFF_BUF4WRITE   0x100000U /* rawcc bytes are for writing */
 
#define TIFF_DIRTYSTRIP   0x200000U /* stripoffsets/stripbytecount dirty*/
 
#define TIFF_PERSAMPLE   0x400000U /* get/set per sample tags as arrays */
 
#define TIFF_BUFFERMMAP   0x800000U /* read buffer (tif_rawdata) points into mmap() memory */
 
#define TIFF_DEFERSTRILELOAD   0x1000000U /* defer strip/tile offset/bytecount array loading. */
 
#define TIFF_LAZYSTRILELOAD   0x2000000U /* lazy/ondemand loading of strip/tile offset/bytecount values. Only used if TIFF_DEFERSTRILELOAD is set and in read-only mode */
 
#define TIFF_CHOPPEDUPARRAYS   0x4000000U /* set when allocChoppedUpStripArrays() has modified strip array */
 
#define isPseudoTag(t)   (t > 0xffff) /* is tag value normal or pseudo */
 
#define isTiled(tif)   (((tif)->tif_flags & TIFF_ISTILED) != 0)
 
#define isMapped(tif)   (((tif)->tif_flags & TIFF_MAPPED) != 0)
 
#define isFillOrder(tif, o)   (((tif)->tif_flags & (o)) != 0)
 
#define isUpSampled(tif)   (((tif)->tif_flags & TIFF_UPSAMPLED) != 0)
 
#define TIFFReadFile(tif, buf, size)    ((*(tif)->tif_readproc)((tif)->tif_clientdata,(buf),(size)))
 
#define TIFFWriteFile(tif, buf, size)    ((*(tif)->tif_writeproc)((tif)->tif_clientdata,(buf),(size)))
 
#define TIFFSeekFile(tif, off, whence)    ((*(tif)->tif_seekproc)((tif)->tif_clientdata,(off),(whence)))
 
#define TIFFCloseFile(tif)    ((*(tif)->tif_closeproc)((tif)->tif_clientdata))
 
#define TIFFGetFileSize(tif)    ((*(tif)->tif_sizeproc)((tif)->tif_clientdata))
 
#define TIFFMapFileContents(tif, paddr, psize)    ((*(tif)->tif_mapproc)((tif)->tif_clientdata,(paddr),(psize)))
 
#define TIFFUnmapFileContents(tif, addr, size)    ((*(tif)->tif_unmapproc)((tif)->tif_clientdata,(addr),(size)))
 
#define ReadOK(tif, buf, size)    (TIFFReadFile((tif),(buf),(size))==(size))
 
#define SeekOK(tif, off)   _TIFFSeekOK(tif, off)
 
#define WriteOK(tif, buf, size)    (TIFFWriteFile((tif),(buf),(size))==(size))
 
#define TIFFhowmany_32(x, y)
 
#define TIFFhowmany_32_maxuint_compat(x, y)    (((uint32)(x) / (uint32)(y)) + ((((uint32)(x) % (uint32)(y)) != 0) ? 1 : 0))
 
#define TIFFhowmany8_32(x)   (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3)
 
#define TIFFroundup_32(x, y)   (TIFFhowmany_32(x,y)*(y))
 
#define TIFFhowmany_64(x, y)   ((((uint64)(x))+(((uint64)(y))-1))/((uint64)(y)))
 
#define TIFFhowmany8_64(x)   (((x)&0x07)?((uint64)(x)>>3)+1:(uint64)(x)>>3)
 
#define TIFFroundup_64(x, y)   (TIFFhowmany_64(x,y)*(y))
 
#define TIFFSafeMultiply(t, v, m)   ((((t)(m) != (t)0) && (((t)(((v)*(m))/(m))) == (t)(v))) ? (t)((v)*(m)) : (t)0)
 
#define TIFFmax(A, B)   ((A)>(B)?(A):(B))
 
#define TIFFmin(A, B)   ((A)<(B)?(A):(B))
 
#define TIFFArrayCount(a)   (sizeof (a) / sizeof ((a)[0]))
 
#define _TIFF_lseek_f(fildes, offset, whence)   lseek(fildes,offset,whence)
 
#define _TIFF_fseek_f(stream, offset, whence)   fseek(stream,offset,whence)
 
#define _TIFF_fstat_f(fildes, stat_buff)   fstat(fildes,stat_buff)
 
#define _TIFF_stat_s   struct stat
 
#define _TIFF_off_t   off_t
 
#define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW
 

Typedefs

typedef struct client_info TIFFClientInfoLink
 
typedef unsigned char tidataval_t
 
typedef tidataval_t * tidata_t
 
typedef void(* TIFFVoidMethod) (TIFF *)
 
typedef int(* TIFFBoolMethod) (TIFF *)
 
typedef int(* TIFFPreMethod) (TIFF *, uint16)
 
typedef int(* TIFFCodeMethod) (TIFF *tif, uint8 *buf, tmsize_t size, uint16 sample)
 
typedef int(* TIFFSeekMethod) (TIFF *, uint32)
 
typedef void(* TIFFPostMethod) (TIFF *tif, uint8 *buf, tmsize_t size)
 
typedef uint32(* TIFFStripMethod) (TIFF *, uint32)
 
typedef void(* TIFFTileMethod) (TIFF *, uint32 *, uint32 *)
 
typedef size_t TIFFIOSize_t
 

Functions

int _TIFFgetMode (const char *mode, const char *module)
 
int _TIFFNoRowEncode (TIFF *tif, uint8 *pp, tmsize_t cc, uint16 s)
 
int _TIFFNoStripEncode (TIFF *tif, uint8 *pp, tmsize_t cc, uint16 s)
 
int _TIFFNoTileEncode (TIFF *, uint8 *pp, tmsize_t cc, uint16 s)
 
int _TIFFNoRowDecode (TIFF *tif, uint8 *pp, tmsize_t cc, uint16 s)
 
int _TIFFNoStripDecode (TIFF *tif, uint8 *pp, tmsize_t cc, uint16 s)
 
int _TIFFNoTileDecode (TIFF *, uint8 *pp, tmsize_t cc, uint16 s)
 
void _TIFFNoPostDecode (TIFF *tif, uint8 *buf, tmsize_t cc)
 
int _TIFFNoPreCode (TIFF *tif, uint16 s)
 
int _TIFFNoSeek (TIFF *tif, uint32 off)
 
void _TIFFSwab16BitData (TIFF *tif, uint8 *buf, tmsize_t cc)
 
void _TIFFSwab24BitData (TIFF *tif, uint8 *buf, tmsize_t cc)
 
void _TIFFSwab32BitData (TIFF *tif, uint8 *buf, tmsize_t cc)
 
void _TIFFSwab64BitData (TIFF *tif, uint8 *buf, tmsize_t cc)
 
int TIFFFlushData1 (TIFF *tif)
 
int TIFFDefaultDirectory (TIFF *tif)
 
void _TIFFSetDefaultCompressionState (TIFF *tif)
 
int _TIFFRewriteField (TIFF *, uint16, TIFFDataType, tmsize_t, void *)
 
int TIFFSetCompressionScheme (TIFF *tif, int scheme)
 
int TIFFSetDefaultCompressionState (TIFF *tif)
 
uint32 _TIFFDefaultStripSize (TIFF *tif, uint32 s)
 
void _TIFFDefaultTileSize (TIFF *tif, uint32 *tw, uint32 *th)
 
int _TIFFDataSize (TIFFDataType type)
 
void _TIFFsetByteArray (void **, void *, uint32)
 
void _TIFFsetString (char **, char *)
 
void _TIFFsetShortArray (uint16 **, uint16 *, uint32)
 
void _TIFFsetLongArray (uint32 **, uint32 *, uint32)
 
void _TIFFsetFloatArray (float **, float *, uint32)
 
void _TIFFsetDoubleArray (double **, double *, uint32)
 
void _TIFFprintAscii (FILE *, const char *)
 
void _TIFFprintAsciiTag (FILE *, const char *, const char *)
 
uint32 _TIFFMultiply32 (TIFF *, uint32, uint32, const char *)
 
uint64 _TIFFMultiply64 (TIFF *, uint64, uint64, const char *)
 
tmsize_t _TIFFMultiplySSize (TIFF *, tmsize_t, tmsize_t, const char *)
 
tmsize_t _TIFFCastUInt64ToSSize (TIFF *, uint64, const char *)
 
void * _TIFFCheckMalloc (TIFF *, tmsize_t, tmsize_t, const char *)
 
void * _TIFFCheckRealloc (TIFF *, void *, tmsize_t, tmsize_t, const char *)
 
double _TIFFUInt64ToDouble (uint64)
 
float _TIFFUInt64ToFloat (uint64)
 
float _TIFFClampDoubleToFloat (double)
 
tmsize_t _TIFFReadEncodedStripAndAllocBuffer (TIFF *tif, uint32 strip, void **buf, tmsize_t bufsizetoalloc, tmsize_t size_to_read)
 
tmsize_t _TIFFReadEncodedTileAndAllocBuffer (TIFF *tif, uint32 tile, void **buf, tmsize_t bufsizetoalloc, tmsize_t size_to_read)
 
tmsize_t _TIFFReadTileAndAllocBuffer (TIFF *tif, void **buf, tmsize_t bufsizetoalloc, uint32 x, uint32 y, uint32 z, uint16 s)
 
int _TIFFSeekOK (TIFF *tif, toff_t off)
 
int TIFFInitDumpMode (TIFF *, int)
 
int TIFFInitPackBits (TIFF *, int)
 
int TIFFInitCCITTRLE (TIFF *, int)
 
int TIFFInitCCITTRLEW (TIFF *, int)
 
int TIFFInitCCITTFax3 (TIFF *, int)
 
int TIFFInitCCITTFax4 (TIFF *, int)
 
int TIFFInitThunderScan (TIFF *, int)
 
int TIFFInitNeXT (TIFF *, int)
 
int TIFFInitLZW (TIFF *, int)
 
int TIFFInitZIP (TIFF *, int)
 
int TIFFInitPixarLog (TIFF *, int)
 
int TIFFInitSGILog (TIFF *, int)
 

Variables

TIFFErrorHandler _TIFFwarningHandler
 
TIFFErrorHandler _TIFFerrorHandler
 
TIFFErrorHandlerExt _TIFFwarningHandlerExt
 
TIFFErrorHandlerExt _TIFFerrorHandlerExt
 
TIFFCodec _TIFFBuiltinCODECS []
 

Macro Definition Documentation

◆ _TIFF_fseek_f

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

Definition at line 324 of file tiffiop.h.

◆ _TIFF_fstat_f

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

Definition at line 325 of file tiffiop.h.

◆ _TIFF_lseek_f

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

Definition at line 322 of file tiffiop.h.

◆ _TIFF_off_t

#define _TIFF_off_t   off_t

Definition at line 329 of file tiffiop.h.

◆ _TIFF_stat_s

#define _TIFF_stat_s   struct stat

Definition at line 328 of file tiffiop.h.

◆ FALSE

#define FALSE   0

Definition at line 77 of file tiffiop.h.

◆ isFillOrder

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

Definition at line 231 of file tiffiop.h.

◆ isMapped

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

Definition at line 230 of file tiffiop.h.

◆ isPseudoTag

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

Definition at line 227 of file tiffiop.h.

◆ isTiled

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

Definition at line 229 of file tiffiop.h.

◆ isUpSampled

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

Definition at line 232 of file tiffiop.h.

◆ ReadOK

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

Definition at line 252 of file tiffiop.h.

◆ SeekOK

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

Definition at line 256 of file tiffiop.h.

◆ streq

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

Definition at line 72 of file tiffiop.h.

◆ STRIP_SIZE_DEFAULT

#define STRIP_SIZE_DEFAULT   8192

Definition at line 69 of file tiffiop.h.

◆ strneq

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

Definition at line 73 of file tiffiop.h.

◆ TIFF_BEENWRITING

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

Definition at line 125 of file tiffiop.h.

◆ TIFF_BIGTIFF

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

Definition at line 138 of file tiffiop.h.

◆ TIFF_BUF4WRITE

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

Definition at line 139 of file tiffiop.h.

◆ TIFF_BUFFERMMAP

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

Definition at line 142 of file tiffiop.h.

◆ TIFF_BUFFERSETUP

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

Definition at line 123 of file tiffiop.h.

◆ TIFF_CHOPPEDUPARRAYS

#define TIFF_CHOPPEDUPARRAYS   0x4000000U /* set when allocChoppedUpStripArrays() has modified strip array */

Definition at line 145 of file tiffiop.h.

◆ TIFF_CODERSETUP

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

Definition at line 124 of file tiffiop.h.

◆ TIFF_DEFERSTRILELOAD

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

Definition at line 143 of file tiffiop.h.

◆ TIFF_DIRTYDIRECT

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

Definition at line 122 of file tiffiop.h.

◆ TIFF_DIRTYHEADER

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

Definition at line 121 of file tiffiop.h.

◆ TIFF_DIRTYSTRIP

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

Definition at line 140 of file tiffiop.h.

◆ TIFF_FILLORDER

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

Definition at line 120 of file tiffiop.h.

◆ TIFF_HEADERONLY

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

Definition at line 135 of file tiffiop.h.

◆ TIFF_INCUSTOMIFD

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

Definition at line 137 of file tiffiop.h.

◆ TIFF_INSUBIFD

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

Definition at line 132 of file tiffiop.h.

◆ TIFF_ISTILED

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

Definition at line 129 of file tiffiop.h.

◆ TIFF_LAZYSTRILELOAD

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

Definition at line 144 of file tiffiop.h.

◆ TIFF_MAPPED

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

Definition at line 130 of file tiffiop.h.

◆ TIFF_MYBUFFER

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

Definition at line 128 of file tiffiop.h.

◆ TIFF_NOBITREV

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

Definition at line 127 of file tiffiop.h.

◆ TIFF_NOREADRAW

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

Definition at line 136 of file tiffiop.h.

◆ TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW

#define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW

Definition at line 339 of file tiffiop.h.

◆ TIFF_PERSAMPLE

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

Definition at line 141 of file tiffiop.h.

◆ TIFF_POSTENCODE

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

Definition at line 131 of file tiffiop.h.

◆ TIFF_SIZE_T_MAX

#define TIFF_SIZE_T_MAX   ((size_t) ~ ((size_t)0))

Definition at line 80 of file tiffiop.h.

◆ TIFF_STRIPCHOP

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

Definition at line 134 of file tiffiop.h.

◆ TIFF_SWAB

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

Definition at line 126 of file tiffiop.h.

◆ TIFF_TMSIZE_T_MAX

#define TIFF_TMSIZE_T_MAX   (tmsize_t)(TIFF_SIZE_T_MAX >> 1)

Definition at line 81 of file tiffiop.h.

◆ TIFF_UINT32_MAX

#define TIFF_UINT32_MAX   0xFFFFFFFFU

Definition at line 86 of file tiffiop.h.

◆ TIFF_UINT64_MAX

#define TIFF_UINT64_MAX   (((uint64)(TIFF_UINT32_MAX)) << 32 | TIFF_UINT32_MAX)

Definition at line 91 of file tiffiop.h.

◆ TIFF_UPSAMPLED

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

Definition at line 133 of file tiffiop.h.

◆ TIFFArrayCount

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

Definition at line 283 of file tiffiop.h.

◆ TIFFCloseFile

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

Definition at line 239 of file tiffiop.h.

◆ TIFFGetFileSize

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

Definition at line 241 of file tiffiop.h.

◆ TIFFhowmany8_32

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

Definition at line 271 of file tiffiop.h.

◆ TIFFhowmany8_64

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

Definition at line 274 of file tiffiop.h.

◆ TIFFhowmany_32

#define TIFFhowmany_32 (   x,
  y 
)
Value:
(((uint32)x < (0xffffffff - (uint32)(y-1))) ? \
((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y))) : \
0U)
uint32
unsigned int uint32
Definition: types.h:32
U
#define U(x)
Definition: wordpad.c:45
x
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
y
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548

Definition at line 264 of file tiffiop.h.

◆ TIFFhowmany_32_maxuint_compat

#define TIFFhowmany_32_maxuint_compat (   x,
  y 
)     (((uint32)(x) / (uint32)(y)) + ((((uint32)(x) % (uint32)(y)) != 0) ? 1 : 0))

Definition at line 269 of file tiffiop.h.

◆ TIFFhowmany_64

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

Definition at line 273 of file tiffiop.h.

◆ TIFFMapFileContents

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

Definition at line 243 of file tiffiop.h.

◆ TIFFmax

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

Definition at line 280 of file tiffiop.h.

◆ TIFFmin

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

Definition at line 281 of file tiffiop.h.

◆ TIFFReadFile

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

Definition at line 233 of file tiffiop.h.

◆ TIFFroundup_32

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

Definition at line 272 of file tiffiop.h.

◆ TIFFroundup_64

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

Definition at line 275 of file tiffiop.h.

◆ TIFFSafeMultiply

#define TIFFSafeMultiply (   t,
  v,
  m 
)    ((((t)(m) != (t)0) && (((t)(((v)*(m))/(m))) == (t)(v))) ? (t)((v)*(m)) : (t)0)

Definition at line 278 of file tiffiop.h.

◆ TIFFSeekFile

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

Definition at line 237 of file tiffiop.h.

◆ TIFFUnmapFileContents

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

Definition at line 245 of file tiffiop.h.

◆ TIFFWriteFile

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

Definition at line 235 of file tiffiop.h.

◆ TRUE

#define TRUE   1

Definition at line 76 of file tiffiop.h.

◆ WriteOK

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

Definition at line 259 of file tiffiop.h.

Typedef Documentation

◆ tidata_t

typedef tidataval_t* tidata_t

Definition at line 104 of file tiffiop.h.

◆ tidataval_t

typedef unsigned char tidataval_t

Definition at line 103 of file tiffiop.h.

◆ TIFFBoolMethod

typedef int(* TIFFBoolMethod) (TIFF *)

Definition at line 107 of file tiffiop.h.

◆ TIFFClientInfoLink

typedef struct client_info TIFFClientInfoLink

◆ TIFFCodeMethod

typedef int(* TIFFCodeMethod) (TIFF *tif, uint8 *buf, tmsize_t size, uint16 sample)

Definition at line 109 of file tiffiop.h.

◆ TIFFIOSize_t

typedef size_t TIFFIOSize_t

Definition at line 321 of file tiffiop.h.

◆ TIFFPostMethod

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

Definition at line 111 of file tiffiop.h.

◆ TIFFPreMethod

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

Definition at line 108 of file tiffiop.h.

◆ TIFFSeekMethod

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

Definition at line 110 of file tiffiop.h.

◆ TIFFStripMethod

typedef uint32(* TIFFStripMethod) (TIFF *, uint32)

Definition at line 112 of file tiffiop.h.

◆ TIFFTileMethod

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

Definition at line 113 of file tiffiop.h.

◆ TIFFVoidMethod

typedef void(* TIFFVoidMethod) (TIFF *)

Definition at line 106 of file tiffiop.h.

Function Documentation

◆ _TIFFCastUInt64ToSSize()

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

Definition at line 83 of file tif_aux.c.

84{
85 if( val > (uint64)TIFF_TMSIZE_T_MAX )
86 {
87 if( tif != NULL && module != NULL )
88 {
89 TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
90 }
91 return 0;
92 }
93 return (tmsize_t)val;
94}
NULL
#define NULL
Definition: types.h:112
uint64
unsigned long long uint64
Definition: platform.h:18
val
GLuint GLfloat * val
Definition: glext.h:7180
tiff::tif_clientdata
thandle_t tif_clientdata
Definition: tiffiop.h:207
TIFFErrorExt
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
TIFF_TMSIZE_T_MAX
#define TIFF_TMSIZE_T_MAX
Definition: tiffiop.h:81

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

◆ _TIFFCheckMalloc()

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

Definition at line 121 of file tif_aux.c.

122{
123 return _TIFFCheckRealloc(tif, NULL, nmemb, elem_size, what);
124}
_TIFFCheckRealloc
void * _TIFFCheckRealloc(TIFF *tif, void *buffer, tmsize_t nmemb, tmsize_t elem_size, const char *what)
Definition: tif_aux.c:97

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

◆ _TIFFCheckRealloc()

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

Definition at line 97 of file tif_aux.c.

99{
100 void* cp = NULL;
101 tmsize_t count = _TIFFMultiplySSize(tif, nmemb, elem_size, NULL);
102 /*
103 * Check for integer overflow.
104 */
105 if (count != 0)
106 {
107 cp = _TIFFrealloc(buffer, count);
108 }
109
110 if (cp == NULL) {
111 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
112 "Failed to allocate memory for %s "
113 "(%ld elements of %ld bytes each)",
114 what,(long) nmemb, (long) elem_size);
115 }
116
117 return cp;
118}
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
buffer
GLuint buffer
Definition: glext.h:5915
cp
POINT cp
Definition: magnifier.c:59
tiff::tif_name
char * tif_name
Definition: tiffiop.h:116
_TIFFMultiplySSize
tmsize_t _TIFFMultiplySSize(TIFF *tif, tmsize_t first, tmsize_t second, const char *where)
Definition: tif_aux.c:59
_TIFFrealloc
void * _TIFFrealloc(void *p, tmsize_t s)
Definition: tif_unix.c:332

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

◆ _TIFFClampDoubleToFloat()

float _TIFFClampDoubleToFloat ( double  val)

Definition at line 397 of file tif_aux.c.

398{
399 if( val > FLT_MAX )
400 return FLT_MAX;
401 if( val < -FLT_MAX )
402 return -FLT_MAX;
403 return (float)val;
404}
FLT_MAX
#define FLT_MAX
Definition: gcc_float.h:107

Referenced by _TIFFVSetField(), and TIFFWriteDirectoryTagSampleformatArray().

◆ _TIFFDataSize()

int _TIFFDataSize ( TIFFDataType  type)

Definition at line 476 of file tif_dirinfo.c.

477{
478 switch (type)
479 {
480 case TIFF_BYTE:
481 case TIFF_SBYTE:
482 case TIFF_ASCII:
483 case TIFF_UNDEFINED:
484 return 1;
485 case TIFF_SHORT:
486 case TIFF_SSHORT:
487 return 2;
488 case TIFF_LONG:
489 case TIFF_SLONG:
490 case TIFF_FLOAT:
491 case TIFF_IFD:
492 case TIFF_RATIONAL:
493 case TIFF_SRATIONAL:
494 return 4;
495 case TIFF_DOUBLE:
496 case TIFF_LONG8:
497 case TIFF_SLONG8:
498 case TIFF_IFD8:
499 return 8;
500 default:
501 return 0;
502 }
503}
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
TIFF_SSHORT
@ TIFF_SSHORT
Definition: tiff.h:132
TIFF_SLONG
@ TIFF_SLONG
Definition: tiff.h:133
TIFF_BYTE
@ TIFF_BYTE
Definition: tiff.h:125
TIFF_SBYTE
@ TIFF_SBYTE
Definition: tiff.h:130
TIFF_IFD
@ TIFF_IFD
Definition: tiff.h:137
TIFF_SHORT
@ TIFF_SHORT
Definition: tiff.h:127
TIFF_UNDEFINED
@ TIFF_UNDEFINED
Definition: tiff.h:131
TIFF_LONG
@ TIFF_LONG
Definition: tiff.h:128
TIFF_SLONG8
@ TIFF_SLONG8
Definition: tiff.h:139
TIFF_LONG8
@ TIFF_LONG8
Definition: tiff.h:138
TIFF_ASCII
@ TIFF_ASCII
Definition: tiff.h:126
TIFF_FLOAT
@ TIFF_FLOAT
Definition: tiff.h:135
TIFF_DOUBLE
@ TIFF_DOUBLE
Definition: tiff.h:136
TIFF_IFD8
@ TIFF_IFD8
Definition: tiff.h:140
TIFF_SRATIONAL
@ TIFF_SRATIONAL
Definition: tiff.h:134
TIFF_RATIONAL
@ TIFF_RATIONAL
Definition: tiff.h:129

Referenced by _TIFFVSetField(), and TIFFPrintDirectory().

◆ _TIFFDefaultStripSize()

uint32 _TIFFDefaultStripSize ( TIFF *  tif,
uint32  s 
)

Definition at line 223 of file tif_strip.c.

224{
225 if ((int32) s < 1) {
226 /*
227 * If RowsPerStrip is unspecified, try to break the
228 * image up into strips that are approximately
229 * STRIP_SIZE_DEFAULT bytes long.
230 */
231 uint64 scanlinesize;
232 uint64 rows;
233 scanlinesize=TIFFScanlineSize64(tif);
234 if (scanlinesize==0)
235 scanlinesize=1;
236 rows=(uint64)STRIP_SIZE_DEFAULT/scanlinesize;
237 if (rows==0)
238 rows=1;
239 else if (rows>0xFFFFFFFF)
240 rows=0xFFFFFFFF;
241 s=(uint32)rows;
242 }
243 return (s);
244}
int32
long int32
Definition: platform.h:12
s
GLdouble s
Definition: gl.h:2039
TIFFScanlineSize64
uint64 TIFFScanlineSize64(TIFF *tif)
Definition: tif_strip.c:257
STRIP_SIZE_DEFAULT
#define STRIP_SIZE_DEFAULT
Definition: tiffiop.h:69

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFDefaultTileSize()

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

Definition at line 278 of file tif_tile.c.

279{
280 (void) tif;
281 if (*(int32*) tw < 1)
282 *tw = 256;
283 if (*(int32*) th < 1)
284 *th = 256;
285 /* roundup to a multiple of 16 per the spec */
286 if (*tw & 0xf)
287 *tw = TIFFroundup_32(*tw, 16);
288 if (*th & 0xf)
289 *th = TIFFroundup_32(*th, 16);
290}
TIFFroundup_32
#define TIFFroundup_32(x, y)
Definition: tiffiop.h:272

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFgetMode()

int _TIFFgetMode ( const char *  mode,
const char *  module 
)

Definition at line 47 of file tif_open.c.

48{
49 int m = -1;
50
51 switch (mode[0]) {
52 case 'r':
53 m = O_RDONLY;
54 if (mode[1] == '+')
55 m = O_RDWR;
56 break;
57 case 'w':
58 case 'a':
59 m = O_RDWR|O_CREAT;
60 if (mode[0] == 'w')
61 m |= O_TRUNC;
62 break;
63 default:
64 TIFFErrorExt(0, module, "\"%s\": Bad mode", mode);
65 break;
66 }
67 return (m);
68}
O_CREAT
#define O_CREAT
Definition: acwin.h:110
O_RDONLY
#define O_RDONLY
Definition: acwin.h:108
O_TRUNC
#define O_TRUNC
Definition: acwin.h:112
mode
GLenum mode
Definition: glext.h:6217
m
const GLfloat * m
Definition: glext.h:10848
O_RDWR
#define O_RDWR
Definition: fcntl.h:36

Referenced by TIFFClientOpen(), TIFFOpen(), and TIFFOpenW().

◆ _TIFFMultiply32()

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

Definition at line 37 of file tif_aux.c.

38{
39 if (second && first > TIFF_UINT32_MAX / second) {
40 TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
41 return 0;
42 }
43
44 return first * second;
45}
first
const GLint * first
Definition: glext.h:5794
TIFF_UINT32_MAX
#define TIFF_UINT32_MAX
Definition: tiffiop.h:86

Referenced by TIFFNumberOfStrips(), and TIFFNumberOfTiles().

◆ _TIFFMultiply64()

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

Definition at line 48 of file tif_aux.c.

49{
50 if (second && first > TIFF_UINT64_MAX / second) {
51 TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
52 return 0;
53 }
54
55 return first * second;
56}
TIFF_UINT64_MAX
#define TIFF_UINT64_MAX
Definition: tiffiop.h:91

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

◆ _TIFFMultiplySSize()

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

Definition at line 59 of file tif_aux.c.

60{
61 if( first <= 0 || second <= 0 )
62 {
63 if( tif != NULL && where != NULL )
64 {
65 TIFFErrorExt(tif->tif_clientdata, where,
66 "Invalid argument to _TIFFMultiplySSize() in %s", where);
67 }
68 return 0;
69 }
70
71 if( first > TIFF_TMSIZE_T_MAX / second )
72 {
73 if( tif != NULL && where != NULL )
74 {
75 TIFFErrorExt(tif->tif_clientdata, where,
76 "Integer overflow in %s", where);
77 }
78 return 0;
79 }
80 return first * second;
81}

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

◆ _TIFFNoPostDecode()

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

Definition at line 1603 of file tif_read.c.

1604{
1605 (void) tif; (void) buf; (void) cc;
1606}
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
cc
uint32_t cc
Definition: isohybrid.c:75

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

◆ _TIFFNoPreCode()

int _TIFFNoPreCode ( TIFF *  tif,
uint16  s 
)

Definition at line 125 of file tif_compress.c.

126{
127 (void) tif; (void) s;
128 return (1);
129}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoRowDecode()

int _TIFFNoRowDecode ( TIFF *  tif,
uint8 *  pp,
tmsize_t  cc,
uint16  s 
)

Definition at line 95 of file tif_compress.c.

96{
97 (void) pp; (void) cc; (void) s;
98 return (TIFFNoDecode(tif, "scanline"));
99}
TIFFNoDecode
static int TIFFNoDecode(TIFF *tif, const char *method)
Definition: tif_compress.c:72

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoRowEncode()

int _TIFFNoRowEncode ( TIFF *  tif,
uint8 *  pp,
tmsize_t  cc,
uint16  s 
)

Definition at line 51 of file tif_compress.c.

52{
53 (void) pp; (void) cc; (void) s;
54 return (TIFFNoEncode(tif, "scanline"));
55}
TIFFNoEncode
static int TIFFNoEncode(TIFF *tif, const char *method)
Definition: tif_compress.c:34

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoSeek()

int _TIFFNoSeek ( TIFF *  tif,
uint32  off 
)

Definition at line 116 of file tif_compress.c.

117{
118 (void) off;
119 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
120 "Compression algorithm does not support random access");
121 return (0);
122}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoStripDecode()

int _TIFFNoStripDecode ( TIFF *  tif,
uint8 *  pp,
tmsize_t  cc,
uint16  s 
)

Definition at line 102 of file tif_compress.c.

103{
104 (void) pp; (void) cc; (void) s;
105 return (TIFFNoDecode(tif, "strip"));
106}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoStripEncode()

int _TIFFNoStripEncode ( TIFF *  tif,
uint8 *  pp,
tmsize_t  cc,
uint16  s 
)

Definition at line 58 of file tif_compress.c.

59{
60 (void) pp; (void) cc; (void) s;
61 return (TIFFNoEncode(tif, "strip"));
62}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoTileDecode()

int _TIFFNoTileDecode ( TIFF *  tif,
uint8 *  pp,
tmsize_t  cc,
uint16  s 
)

Definition at line 109 of file tif_compress.c.

110{
111 (void) pp; (void) cc; (void) s;
112 return (TIFFNoDecode(tif, "tile"));
113}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFNoTileEncode()

int _TIFFNoTileEncode ( TIFF *  tif,
uint8 *  pp,
tmsize_t  cc,
uint16  s 
)

Definition at line 65 of file tif_compress.c.

66{
67 (void) pp; (void) cc; (void) s;
68 return (TIFFNoEncode(tif, "tile"));
69}

Referenced by _TIFFSetDefaultCompressionState().

◆ _TIFFprintAscii()

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

Definition at line 678 of file tif_print.c.

679{
680 _TIFFprintAsciiBounded( fd, cp, strlen(cp));
681}
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
fd
static int fd
Definition: io.c:51
_TIFFprintAsciiBounded
static void _TIFFprintAsciiBounded(FILE *fd, const char *cp, size_t max_chars)
Definition: tif_print.c:684

Referenced by _TIFFprintAsciiTag().

◆ _TIFFprintAsciiTag()

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

Definition at line 704 of file tif_print.c.

705{
706 fprintf(fd, " %s: \"", name);
707 _TIFFprintAscii(fd, value);
708 fprintf(fd, "\"\n");
709}
fprintf
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
name
Definition: name.c:39
_TIFFprintAscii
void _TIFFprintAscii(FILE *fd, const char *cp)
Definition: tif_print.c:678
value
Definition: pdh_main.c:94

◆ _TIFFReadEncodedStripAndAllocBuffer()

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

Definition at line 572 of file tif_read.c.

575{
576 tmsize_t this_stripsize;
577 uint16 plane;
578
579 if( *buf != NULL )
580 {
581 return TIFFReadEncodedStrip(tif, strip, *buf, size_to_read);
582 }
583
584 this_stripsize=TIFFReadEncodedStripGetStripSize(tif, strip, &plane);
585 if (this_stripsize==((tmsize_t)(-1)))
586 return((tmsize_t)(-1));
587
588 if ((size_to_read!=(tmsize_t)(-1))&&(size_to_read<this_stripsize))
589 this_stripsize=size_to_read;
590 if (!TIFFFillStrip(tif,strip))
591 return((tmsize_t)(-1));
592
593 *buf = _TIFFmalloc(bufsizetoalloc);
594 if (*buf == NULL) {
595 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for strip buffer");
596 return((tmsize_t)(-1));
597 }
598 _TIFFmemset(*buf, 0, bufsizetoalloc);
599
600 if ((*tif->tif_decodestrip)(tif,*buf,this_stripsize,plane)<=0)
601 return((tmsize_t)(-1));
602 (*tif->tif_postdecode)(tif,*buf,this_stripsize);
603 return(this_stripsize);
604
605
606}
uint16
unsigned short uint16
Definition: types.h:30
plane
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint GLenum GLenum GLenum GLint GLuint GLenum GLenum GLfloat GLenum GLfloat GLenum GLint const GLfloat GLenum GLint const GLushort GLint GLint GLsizei GLsizei GLenum GLsizei GLsizei GLenum GLenum const GLvoid GLenum plane
Definition: glfuncs.h:270
tiff::tif_decodestrip
TIFFCodeMethod tif_decodestrip
Definition: tiffiop.h:182
tiff::tif_postdecode
TIFFPostMethod tif_postdecode
Definition: tiffiop.h:214
TIFFFileName
const char * TIFFFileName(TIFF *tif)
Definition: tif_open.c:513
TIFFReadEncodedStripGetStripSize
static tmsize_t TIFFReadEncodedStripGetStripSize(TIFF *tif, uint32 strip, uint16 *pplane)
Definition: tif_read.c:488
TIFFReadEncodedStrip
tmsize_t TIFFReadEncodedStrip(TIFF *tif, uint32 strip, void *buf, tmsize_t size)
Definition: tif_read.c:527
TIFFFillStrip
int TIFFFillStrip(TIFF *tif, uint32 strip)
Definition: tif_read.c:766
_TIFFmemset
void _TIFFmemset(void *p, int v, tmsize_t c)
Definition: tif_unix.c:338
_TIFFmalloc
void * _TIFFmalloc(tmsize_t s)
Definition: tif_unix.c:309

Referenced by gtStripContig(), and gtStripSeparate().

◆ _TIFFReadEncodedTileAndAllocBuffer()

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

Definition at line 1048 of file tif_read.c.

1051{
1052 static const char module[] = "_TIFFReadEncodedTileAndAllocBuffer";
1053 TIFFDirectory *td = &tif->tif_dir;
1054 tmsize_t tilesize = tif->tif_tilesize;
1055
1056 if( *buf != NULL )
1057 {
1058 return TIFFReadEncodedTile(tif, tile, *buf, size_to_read);
1059 }
1060
1061 if (!TIFFCheckRead(tif, 1))
1062 return ((tmsize_t)(-1));
1063 if (tile >= td->td_nstrips) {
1064 TIFFErrorExt(tif->tif_clientdata, module,
1065 "%lu: Tile out of range, max %lu",
1066 (unsigned long) tile, (unsigned long) td->td_nstrips);
1067 return ((tmsize_t)(-1));
1068 }
1069
1070 if (!TIFFFillTile(tif,tile))
1071 return((tmsize_t)(-1));
1072
1073 *buf = _TIFFmalloc(bufsizetoalloc);
1074 if (*buf == NULL) {
1075 TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif),
1076 "No space for tile buffer");
1077 return((tmsize_t)(-1));
1078 }
1079 _TIFFmemset(*buf, 0, bufsizetoalloc);
1080
1081 if (size_to_read == (tmsize_t)(-1))
1082 size_to_read = tilesize;
1083 else if (size_to_read > tilesize)
1084 size_to_read = tilesize;
1085 if( (*tif->tif_decodetile)(tif,
1086 (uint8*) *buf, size_to_read, (uint16)(tile/td->td_stripsperimage))) {
1087 (*tif->tif_postdecode)(tif, (uint8*) *buf, size_to_read);
1088 return (size_to_read);
1089 } else
1090 return ((tmsize_t)(-1));
1091}
uint8
unsigned char uint8
Definition: types.h:28
TIFFDirectory::td_nstrips
uint32 td_nstrips
Definition: tif_dir.h:100
TIFFDirectory::td_stripsperimage
uint32 td_stripsperimage
Definition: tif_dir.h:99
tiff::tif_dir
TIFFDirectory tif_dir
Definition: tiffiop.h:151
tiff::tif_tilesize
tmsize_t tif_tilesize
Definition: tiffiop.h:170
tiff::tif_decodetile
TIFFCodeMethod tif_decodetile
Definition: tiffiop.h:184
TIFFReadEncodedTile
tmsize_t TIFFReadEncodedTile(TIFF *tif, uint32 tile, void *buf, tmsize_t size)
Definition: tif_read.c:978
TIFFCheckRead
static int TIFFCheckRead(TIFF *, int)
Definition: tif_read.c:1500
TIFFFillTile
int TIFFFillTile(TIFF *tif, uint32 tile)
Definition: tif_read.c:1204

Referenced by _TIFFReadTileAndAllocBuffer().

◆ _TIFFReadTileAndAllocBuffer()

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

Definition at line 1029 of file tif_read.c.

1032{
1033 if (!TIFFCheckRead(tif, 1) || !TIFFCheckTile(tif, x, y, z, s))
1034 return ((tmsize_t)(-1));
1035 return (_TIFFReadEncodedTileAndAllocBuffer(tif,
1036 TIFFComputeTile(tif, x, y, z, s),
1037 buf, bufsizetoalloc,
1038 (tmsize_t)(-1)));
1039}
z
GLdouble GLdouble z
Definition: glext.h:5874
_TIFFReadEncodedTileAndAllocBuffer
tmsize_t _TIFFReadEncodedTileAndAllocBuffer(TIFF *tif, uint32 tile, void **buf, tmsize_t bufsizetoalloc, tmsize_t size_to_read)
Definition: tif_read.c:1048
TIFFCheckTile
int TIFFCheckTile(TIFF *tif, uint32 x, uint32 y, uint32 z, uint16 s)
Definition: tif_tile.c:73
TIFFComputeTile
uint32 TIFFComputeTile(TIFF *tif, uint32 x, uint32 y, uint32 z, uint16 s)
Definition: tif_tile.c:36

Referenced by gtTileContig(), and gtTileSeparate().

◆ _TIFFRewriteField()

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

Definition at line 2824 of file tif_dirwrite.c.

2826{
2827 static const char module[] = "TIFFResetField";
2828 /* const TIFFField* fip = NULL; */
2829 uint16 dircount;
2830 tmsize_t dirsize;
2831 uint8 direntry_raw[20];
2832 uint16 entry_tag = 0;
2833 uint16 entry_type = 0;
2834 uint64 entry_count = 0;
2835 uint64 entry_offset = 0;
2836 int value_in_entry = 0;
2837 uint64 read_offset;
2838 uint8 *buf_to_write = NULL;
2839 TIFFDataType datatype;
2840
2841/* -------------------------------------------------------------------- */
2842/* Find field definition. */
2843/* -------------------------------------------------------------------- */
2844 /*fip =*/ TIFFFindField(tif, tag, TIFF_ANY);
2845
2846/* -------------------------------------------------------------------- */
2847/* Do some checking this is a straight forward case. */
2848/* -------------------------------------------------------------------- */
2849 if( isMapped(tif) )
2850 {
2851 TIFFErrorExt( tif->tif_clientdata, module,
2852 "Memory mapped files not currently supported for this operation." );
2853 return 0;
2854 }
2855
2856 if( tif->tif_diroff == 0 )
2857 {
2858 TIFFErrorExt( tif->tif_clientdata, module,
2859 "Attempt to reset field on directory not already on disk." );
2860 return 0;
2861 }
2862
2863/* -------------------------------------------------------------------- */
2864/* Read the directory entry count. */
2865/* -------------------------------------------------------------------- */
2866 if (!SeekOK(tif, tif->tif_diroff)) {
2867 TIFFErrorExt(tif->tif_clientdata, module,
2868 "%s: Seek error accessing TIFF directory",
2869 tif->tif_name);
2870 return 0;
2871 }
2872
2873 read_offset = tif->tif_diroff;
2874
2875 if (!(tif->tif_flags&TIFF_BIGTIFF))
2876 {
2877 if (!ReadOK(tif, &dircount, sizeof (uint16))) {
2878 TIFFErrorExt(tif->tif_clientdata, module,
2879 "%s: Can not read TIFF directory count",
2880 tif->tif_name);
2881 return 0;
2882 }
2883 if (tif->tif_flags & TIFF_SWAB)
2884 TIFFSwabShort(&dircount);
2885 dirsize = 12;
2886 read_offset += 2;
2887 } else {
2888 uint64 dircount64;
2889 if (!ReadOK(tif, &dircount64, sizeof (uint64))) {
2890 TIFFErrorExt(tif->tif_clientdata, module,
2891 "%s: Can not read TIFF directory count",
2892 tif->tif_name);
2893 return 0;
2894 }
2895 if (tif->tif_flags & TIFF_SWAB)
2896 TIFFSwabLong8(&dircount64);
2897 dircount = (uint16)dircount64;
2898 dirsize = 20;
2899 read_offset += 8;
2900 }
2901
2902/* -------------------------------------------------------------------- */
2903/* Read through directory to find target tag. */
2904/* -------------------------------------------------------------------- */
2905 while( dircount > 0 )
2906 {
2907 if (!ReadOK(tif, direntry_raw, dirsize)) {
2908 TIFFErrorExt(tif->tif_clientdata, module,
2909 "%s: Can not read TIFF directory entry.",
2910 tif->tif_name);
2911 return 0;
2912 }
2913
2914 memcpy( &entry_tag, direntry_raw + 0, sizeof(uint16) );
2915 if (tif->tif_flags&TIFF_SWAB)
2916 TIFFSwabShort( &entry_tag );
2917
2918 if( entry_tag == tag )
2919 break;
2920
2921 read_offset += dirsize;
2922 }
2923
2924 if( entry_tag != tag )
2925 {
2926 TIFFErrorExt(tif->tif_clientdata, module,
2927 "%s: Could not find tag %d.",
2928 tif->tif_name, tag );
2929 return 0;
2930 }
2931
2932/* -------------------------------------------------------------------- */
2933/* Extract the type, count and offset for this entry. */
2934/* -------------------------------------------------------------------- */
2935 memcpy( &entry_type, direntry_raw + 2, sizeof(uint16) );
2936 if (tif->tif_flags&TIFF_SWAB)
2937 TIFFSwabShort( &entry_type );
2938
2939 if (!(tif->tif_flags&TIFF_BIGTIFF))
2940 {
2941 uint32 value;
2942
2943 memcpy( &value, direntry_raw + 4, sizeof(uint32) );
2944 if (tif->tif_flags&TIFF_SWAB)
2945 TIFFSwabLong( &value );
2946 entry_count = value;
2947
2948 memcpy( &value, direntry_raw + 8, sizeof(uint32) );
2949 if (tif->tif_flags&TIFF_SWAB)
2950 TIFFSwabLong( &value );
2951 entry_offset = value;
2952 }
2953 else
2954 {
2955 memcpy( &entry_count, direntry_raw + 4, sizeof(uint64) );
2956 if (tif->tif_flags&TIFF_SWAB)
2957 TIFFSwabLong8( &entry_count );
2958
2959 memcpy( &entry_offset, direntry_raw + 12, sizeof(uint64) );
2960 if (tif->tif_flags&TIFF_SWAB)
2961 TIFFSwabLong8( &entry_offset );
2962 }
2963
2964/* -------------------------------------------------------------------- */
2965/* When a dummy tag was written due to TIFFDeferStrileArrayWriting() */
2966/* -------------------------------------------------------------------- */
2967 if( entry_offset == 0 && entry_count == 0 && entry_type == 0 )
2968 {
2969 if( tag == TIFFTAG_TILEOFFSETS || tag == TIFFTAG_STRIPOFFSETS )
2970 {
2971 entry_type = (tif->tif_flags&TIFF_BIGTIFF) ? TIFF_LONG8 : TIFF_LONG;
2972 }
2973 else
2974 {
2975 int write_aslong8 = 1;
2976 if( count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS )
2977 {
2978 write_aslong8 = WriteAsLong8(tif, TIFFStripSize64(tif));
2979 }
2980 else if( count > 1 && tag == TIFFTAG_TILEBYTECOUNTS )
2981 {
2982 write_aslong8 = WriteAsLong8(tif, TIFFTileSize64(tif));
2983 }
2984 if( write_aslong8 )
2985 {
2986 entry_type = TIFF_LONG8;
2987 }
2988 else
2989 {
2990 int write_aslong4 = 1;
2991 if( count > 1 && tag == TIFFTAG_STRIPBYTECOUNTS )
2992 {
2993 write_aslong4 = WriteAsLong4(tif, TIFFStripSize64(tif));
2994 }
2995 else if( count > 1 && tag == TIFFTAG_TILEBYTECOUNTS )
2996 {
2997 write_aslong4 = WriteAsLong4(tif, TIFFTileSize64(tif));
2998 }
2999 if( write_aslong4 )
3000 {
3001 entry_type = TIFF_LONG;
3002 }
3003 else
3004 {
3005 entry_type = TIFF_SHORT;
3006 }
3007 }
3008 }
3009 }
3010
3011/* -------------------------------------------------------------------- */
3012/* What data type do we want to write this as? */
3013/* -------------------------------------------------------------------- */
3014 if( TIFFDataWidth(in_datatype) == 8 && !(tif->tif_flags&TIFF_BIGTIFF) )
3015 {
3016 if( in_datatype == TIFF_LONG8 )
3017 datatype = entry_type == TIFF_SHORT ? TIFF_SHORT : TIFF_LONG;
3018 else if( in_datatype == TIFF_SLONG8 )
3019 datatype = TIFF_SLONG;
3020 else if( in_datatype == TIFF_IFD8 )
3021 datatype = TIFF_IFD;
3022 else
3023 datatype = in_datatype;
3024 }
3025 else
3026 {
3027 if( in_datatype == TIFF_LONG8 &&
3028 (entry_type == TIFF_SHORT || entry_type == TIFF_LONG ||
3029 entry_type == TIFF_LONG8 ) )
3030 datatype = entry_type;
3031 else if( in_datatype == TIFF_SLONG8 &&
3032 (entry_type == TIFF_SLONG || entry_type == TIFF_SLONG8 ) )
3033 datatype = entry_type;
3034 else if( in_datatype == TIFF_IFD8 &&
3035 (entry_type == TIFF_IFD || entry_type == TIFF_IFD8 ) )
3036 datatype = entry_type;
3037 else
3038 datatype = in_datatype;
3039 }
3040
3041/* -------------------------------------------------------------------- */
3042/* Prepare buffer of actual data to write. This includes */
3043/* swabbing as needed. */
3044/* -------------------------------------------------------------------- */
3045 buf_to_write =
3046 (uint8 *)_TIFFCheckMalloc(tif, count, TIFFDataWidth(datatype),
3047 "for field buffer.");
3048 if (!buf_to_write)
3049 return 0;
3050
3051 if( datatype == in_datatype )
3052 memcpy( buf_to_write, data, count * TIFFDataWidth(datatype) );
3053 else if( datatype == TIFF_SLONG && in_datatype == TIFF_SLONG8 )
3054 {
3055 tmsize_t i;
3056
3057 for( i = 0; i < count; i++ )
3058 {
3059 ((int32 *) buf_to_write)[i] =
3060 (int32) ((int64 *) data)[i];
3061 if( (int64) ((int32 *) buf_to_write)[i] != ((int64 *) data)[i] )
3062 {
3063 _TIFFfree( buf_to_write );
3064 TIFFErrorExt( tif->tif_clientdata, module,
3065 "Value exceeds 32bit range of output type." );
3066 return 0;
3067 }
3068 }
3069 }
3070 else if( (datatype == TIFF_LONG && in_datatype == TIFF_LONG8)
3071 || (datatype == TIFF_IFD && in_datatype == TIFF_IFD8) )
3072 {
3073 tmsize_t i;
3074
3075 for( i = 0; i < count; i++ )
3076 {
3077 ((uint32 *) buf_to_write)[i] =
3078 (uint32) ((uint64 *) data)[i];
3079 if( (uint64) ((uint32 *) buf_to_write)[i] != ((uint64 *) data)[i] )
3080 {
3081 _TIFFfree( buf_to_write );
3082 TIFFErrorExt( tif->tif_clientdata, module,
3083 "Value exceeds 32bit range of output type." );
3084 return 0;
3085 }
3086 }
3087 }
3088 else if( datatype == TIFF_SHORT && in_datatype == TIFF_LONG8 )
3089 {
3090 tmsize_t i;
3091
3092 for( i = 0; i < count; i++ )
3093 {
3094 ((uint16 *) buf_to_write)[i] =
3095 (uint16) ((uint64 *) data)[i];
3096 if( (uint64) ((uint16 *) buf_to_write)[i] != ((uint64 *) data)[i] )
3097 {
3098 _TIFFfree( buf_to_write );
3099 TIFFErrorExt( tif->tif_clientdata, module,
3100 "Value exceeds 16bit range of output type." );
3101 return 0;
3102 }
3103 }
3104 }
3105 else
3106 {
3107 TIFFErrorExt( tif->tif_clientdata, module,
3108 "Unhandled type conversion." );
3109 return 0;
3110 }
3111
3112 if( TIFFDataWidth(datatype) > 1 && (tif->tif_flags&TIFF_SWAB) )
3113 {
3114 if( TIFFDataWidth(datatype) == 2 )
3115 TIFFSwabArrayOfShort( (uint16 *) buf_to_write, count );
3116 else if( TIFFDataWidth(datatype) == 4 )
3117 TIFFSwabArrayOfLong( (uint32 *) buf_to_write, count );
3118 else if( TIFFDataWidth(datatype) == 8 )
3119 TIFFSwabArrayOfLong8( (uint64 *) buf_to_write, count );
3120 }
3121
3122/* -------------------------------------------------------------------- */
3123/* Is this a value that fits into the directory entry? */
3124/* -------------------------------------------------------------------- */
3125 if (!(tif->tif_flags&TIFF_BIGTIFF))
3126 {
3127 if( TIFFDataWidth(datatype) * count <= 4 )
3128 {
3129 entry_offset = read_offset + 8;
3130 value_in_entry = 1;
3131 }
3132 }
3133 else
3134 {
3135 if( TIFFDataWidth(datatype) * count <= 8 )
3136 {
3137 entry_offset = read_offset + 12;
3138 value_in_entry = 1;
3139 }
3140 }
3141
3142 if( (tag == TIFFTAG_TILEOFFSETS || tag == TIFFTAG_STRIPOFFSETS) &&
3143 tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
3144 tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
3145 tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 )
3146 {
3147 tif->tif_dir.td_stripoffset_entry.tdir_type = datatype;
3148 tif->tif_dir.td_stripoffset_entry.tdir_count = count;
3149 }
3150 else if( (tag == TIFFTAG_TILEBYTECOUNTS || tag == TIFFTAG_STRIPBYTECOUNTS) &&
3151 tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
3152 tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
3153 tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0 )
3154 {
3155 tif->tif_dir.td_stripbytecount_entry.tdir_type = datatype;
3156 tif->tif_dir.td_stripbytecount_entry.tdir_count = count;
3157 }
3158
3159/* -------------------------------------------------------------------- */
3160/* If the tag type, and count match, then we just write it out */
3161/* over the old values without altering the directory entry at */
3162/* all. */
3163/* -------------------------------------------------------------------- */
3164 if( entry_count == (uint64)count && entry_type == (uint16) datatype )
3165 {
3166 if (!SeekOK(tif, entry_offset)) {
3167 _TIFFfree( buf_to_write );
3168 TIFFErrorExt(tif->tif_clientdata, module,
3169 "%s: Seek error accessing TIFF directory",
3170 tif->tif_name);
3171 return 0;
3172 }
3173 if (!WriteOK(tif, buf_to_write, count*TIFFDataWidth(datatype))) {
3174 _TIFFfree( buf_to_write );
3175 TIFFErrorExt(tif->tif_clientdata, module,
3176 "Error writing directory link");
3177 return (0);
3178 }
3179
3180 _TIFFfree( buf_to_write );
3181 return 1;
3182 }
3183
3184/* -------------------------------------------------------------------- */
3185/* Otherwise, we write the new tag data at the end of the file. */
3186/* -------------------------------------------------------------------- */
3187 if( !value_in_entry )
3188 {
3189 entry_offset = TIFFSeekFile(tif,0,SEEK_END);
3190
3191 if (!WriteOK(tif, buf_to_write, count*TIFFDataWidth(datatype))) {
3192 _TIFFfree( buf_to_write );
3193 TIFFErrorExt(tif->tif_clientdata, module,
3194 "Error writing directory link");
3195 return (0);
3196 }
3197 }
3198 else
3199 {
3200 memcpy( &entry_offset, buf_to_write, count*TIFFDataWidth(datatype));
3201 }
3202
3203 _TIFFfree( buf_to_write );
3204 buf_to_write = 0;
3205
3206/* -------------------------------------------------------------------- */
3207/* Adjust the directory entry. */
3208/* -------------------------------------------------------------------- */
3209 entry_type = datatype;
3210 entry_count = (uint64)count;
3211 memcpy( direntry_raw + 2, &entry_type, sizeof(uint16) );
3212 if (tif->tif_flags&TIFF_SWAB)
3213 TIFFSwabShort( (uint16 *) (direntry_raw + 2) );
3214
3215 if (!(tif->tif_flags&TIFF_BIGTIFF))
3216 {
3217 uint32 value;
3218
3219 value = (uint32) entry_count;
3220 memcpy( direntry_raw + 4, &value, sizeof(uint32) );
3221 if (tif->tif_flags&TIFF_SWAB)
3222 TIFFSwabLong( (uint32 *) (direntry_raw + 4) );
3223
3224 value = (uint32) entry_offset;
3225 memcpy( direntry_raw + 8, &value, sizeof(uint32) );
3226 if (tif->tif_flags&TIFF_SWAB)
3227 TIFFSwabLong( (uint32 *) (direntry_raw + 8) );
3228 }
3229 else
3230 {
3231 memcpy( direntry_raw + 4, &entry_count, sizeof(uint64) );
3232 if (tif->tif_flags&TIFF_SWAB)
3233 TIFFSwabLong8( (uint64 *) (direntry_raw + 4) );
3234
3235 memcpy( direntry_raw + 12, &entry_offset, sizeof(uint64) );
3236 if (tif->tif_flags&TIFF_SWAB)
3237 TIFFSwabLong8( (uint64 *) (direntry_raw + 12) );
3238 }
3239
3240/* -------------------------------------------------------------------- */
3241/* Write the directory entry out to disk. */
3242/* -------------------------------------------------------------------- */
3243 if (!SeekOK(tif, read_offset )) {
3244 TIFFErrorExt(tif->tif_clientdata, module,
3245 "%s: Seek error accessing TIFF directory",
3246 tif->tif_name);
3247 return 0;
3248 }
3249
3250 if (!WriteOK(tif, direntry_raw,dirsize))
3251 {
3252 TIFFErrorExt(tif->tif_clientdata, module,
3253 "%s: Can not write TIFF directory entry.",
3254 tif->tif_name);
3255 return 0;
3256 }
3257
3258 return 1;
3259}
SEEK_END
#define SEEK_END
Definition: cabinet.c:29
int64
long long int64
Definition: platform.h:13
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
TIFFDirEntry::tdir_offset
union TIFFDirEntry::@3466 tdir_offset
TIFFDirEntry::toff_long8
uint64 toff_long8
Definition: tif_dir.h:59
TIFFDirEntry::tdir_count
uint64 tdir_count
Definition: tif_dir.h:55
TIFFDirEntry::tdir_type
uint16 tdir_type
Definition: tif_dir.h:54
TIFFDirectory::td_stripoffset_entry
TIFFDirEntry td_stripoffset_entry
Definition: tif_dir.h:107
TIFFDirectory::td_stripbytecount_entry
TIFFDirEntry td_stripbytecount_entry
Definition: tif_dir.h:108
tag
Definition: ecma_167.h:138
tiff::tif_flags
uint32 tif_flags
Definition: tiffiop.h:119
tiff::tif_diroff
uint64 tif_diroff
Definition: tiffiop.h:146
_TIFFCheckMalloc
void * _TIFFCheckMalloc(TIFF *tif, tmsize_t nmemb, tmsize_t elem_size, const char *what)
Definition: tif_aux.c:121
TIFFDataWidth
int TIFFDataWidth(TIFFDataType type)
Definition: tif_dirinfo.c:438
TIFFFindField
const TIFFField * TIFFFindField(TIFF *tif, uint32 tag, TIFFDataType dt)
Definition: tif_dirinfo.c:506
WriteAsLong4
static int WriteAsLong4(TIFF *tif, uint64 strile_size)
Definition: tif_dirwrite.c:1728
WriteAsLong8
static int WriteAsLong8(TIFF *tif, uint64 strile_size)
Definition: tif_dirwrite.c:1723
TIFFStripSize64
uint64 TIFFStripSize64(TIFF *tif)
Definition: tif_strip.c:193
TIFFSwabArrayOfShort
void TIFFSwabArrayOfShort(register uint16 *wp, tmsize_t n)
Definition: tif_swab.c:71
TIFFSwabLong
void TIFFSwabLong(uint32 *lp)
Definition: tif_swab.c:45
TIFFSwabShort
void TIFFSwabShort(uint16 *wp)
Definition: tif_swab.c:34
TIFFSwabArrayOfLong8
void TIFFSwabArrayOfLong8(register uint64 *lp, tmsize_t n)
Definition: tif_swab.c:120
TIFFSwabLong8
void TIFFSwabLong8(uint64 *lp)
Definition: tif_swab.c:57
TIFFSwabArrayOfLong
void TIFFSwabArrayOfLong(register uint32 *lp, tmsize_t n)
Definition: tif_swab.c:103
TIFFTileSize64
uint64 TIFFTileSize64(TIFF *tif)
Definition: tif_tile.c:252
_TIFFfree
void _TIFFfree(void *p)
Definition: tif_unix.c:326
TIFFDataType
TIFFDataType
Definition: tiff.h:123
TIFFTAG_TILEBYTECOUNTS
#define TIFFTAG_TILEBYTECOUNTS
Definition: tiff.h:288
TIFFTAG_STRIPBYTECOUNTS
#define TIFFTAG_STRIPBYTECOUNTS
Definition: tiff.h:233
TIFFTAG_TILEOFFSETS
#define TIFFTAG_TILEOFFSETS
Definition: tiff.h:287
TIFFTAG_STRIPOFFSETS
#define TIFFTAG_STRIPOFFSETS
Definition: tiff.h:221
TIFF_ANY
#define TIFF_ANY
Definition: tiffio.h:307
WriteOK
#define WriteOK(tif, buf, size)
Definition: tiffiop.h:259
ReadOK
#define ReadOK(tif, buf, size)
Definition: tiffiop.h:252
SeekOK
#define SeekOK(tif, off)
Definition: tiffiop.h:256
isMapped
#define isMapped(tif)
Definition: tiffiop.h:230
TIFFSeekFile
#define TIFFSeekFile(tif, off, whence)
Definition: tiffiop.h:237
TIFF_BIGTIFF
#define TIFF_BIGTIFF
Definition: tiffiop.h:138
TIFF_SWAB
#define TIFF_SWAB
Definition: tiffiop.h:126

Referenced by TIFFForceStrileArrayWriting().

◆ _TIFFSeekOK()

int _TIFFSeekOK ( TIFF *  tif,
toff_t  off 
)

Definition at line 406 of file tif_aux.c.

407{
408 /* Huge offsets, especially -1 / UINT64_MAX, can cause issues */
409 /* See http://bugzilla.maptools.org/show_bug.cgi?id=2726 */
410 return off <= (~(uint64)0)/2 && TIFFSeekFile(tif,off,SEEK_SET)==off;
411}
SEEK_SET
#define SEEK_SET
Definition: jmemansi.c:26

◆ _TIFFsetByteArray()

void _TIFFsetByteArray ( void **  vpp,
void *  vp,
uint32  n 
)

Definition at line 57 of file tif_dir.c.

58 { setByteArray(vpp, vp, n, 1); }
n
GLdouble n
Definition: glext.h:7729
setByteArray
static void setByteArray(void **vpp, void *vp, size_t nmemb, size_t elem_size)
Definition: tif_dir.c:43

◆ _TIFFSetDefaultCompressionState()

void _TIFFSetDefaultCompressionState ( TIFF *  tif)

Definition at line 135 of file tif_compress.c.

136{
137 tif->tif_fixuptags = _TIFFNoFixupTags;
138 tif->tif_decodestatus = TRUE;
139 tif->tif_setupdecode = _TIFFtrue;
140 tif->tif_predecode = _TIFFNoPreCode;
141 tif->tif_decoderow = _TIFFNoRowDecode;
142 tif->tif_decodestrip = _TIFFNoStripDecode;
143 tif->tif_decodetile = _TIFFNoTileDecode;
144 tif->tif_encodestatus = TRUE;
145 tif->tif_setupencode = _TIFFtrue;
146 tif->tif_preencode = _TIFFNoPreCode;
147 tif->tif_postencode = _TIFFtrue;
148 tif->tif_encoderow = _TIFFNoRowEncode;
149 tif->tif_encodestrip = _TIFFNoStripEncode;
150 tif->tif_encodetile = _TIFFNoTileEncode;
151 tif->tif_close = _TIFFvoid;
152 tif->tif_seek = _TIFFNoSeek;
153 tif->tif_cleanup = _TIFFvoid;
154 tif->tif_defstripsize = _TIFFDefaultStripSize;
155 tif->tif_deftilesize = _TIFFDefaultTileSize;
156 tif->tif_flags &= ~(TIFF_NOBITREV|TIFF_NOREADRAW);
157}
TRUE
#define TRUE
Definition: types.h:120
tiff::tif_deftilesize
TIFFTileMethod tif_deftilesize
Definition: tiffiop.h:190
tiff::tif_encodestrip
TIFFCodeMethod tif_encodestrip
Definition: tiffiop.h:183
tiff::tif_seek
TIFFSeekMethod tif_seek
Definition: tiffiop.h:187
tiff::tif_encodetile
TIFFCodeMethod tif_encodetile
Definition: tiffiop.h:185
tiff::tif_preencode
TIFFPreMethod tif_preencode
Definition: tiffiop.h:178
tiff::tif_fixuptags
TIFFBoolMethod tif_fixuptags
Definition: tiffiop.h:173
tiff::tif_predecode
TIFFPreMethod tif_predecode
Definition: tiffiop.h:175
tiff::tif_defstripsize
TIFFStripMethod tif_defstripsize
Definition: tiffiop.h:189
tiff::tif_decoderow
TIFFCodeMethod tif_decoderow
Definition: tiffiop.h:180
tiff::tif_setupencode
TIFFBoolMethod tif_setupencode
Definition: tiffiop.h:176
tiff::tif_postencode
TIFFBoolMethod tif_postencode
Definition: tiffiop.h:179
tiff::tif_encoderow
TIFFCodeMethod tif_encoderow
Definition: tiffiop.h:181
tiff::tif_close
TIFFVoidMethod tif_close
Definition: tiffiop.h:186
tiff::tif_decodestatus
int tif_decodestatus
Definition: tiffiop.h:172
tiff::tif_encodestatus
int tif_encodestatus
Definition: tiffiop.h:177
tiff::tif_cleanup
TIFFVoidMethod tif_cleanup
Definition: tiffiop.h:188
tiff::tif_setupdecode
TIFFBoolMethod tif_setupdecode
Definition: tiffiop.h:174
_TIFFNoPreCode
int _TIFFNoPreCode(TIFF *tif, uint16 s)
Definition: tif_compress.c:125
_TIFFNoSeek
int _TIFFNoSeek(TIFF *tif, uint32 off)
Definition: tif_compress.c:116
_TIFFvoid
static void _TIFFvoid(TIFF *tif)
Definition: tif_compress.c:132
_TIFFNoStripDecode
int _TIFFNoStripDecode(TIFF *tif, uint8 *pp, tmsize_t cc, uint16 s)
Definition: tif_compress.c:102
_TIFFNoTileEncode
int _TIFFNoTileEncode(TIFF *tif, uint8 *pp, tmsize_t cc, uint16 s)
Definition: tif_compress.c:65
_TIFFtrue
static int _TIFFtrue(TIFF *tif)
Definition: tif_compress.c:131
_TIFFNoFixupTags
static int _TIFFNoFixupTags(TIFF *tif)
Definition: tif_compress.c:88
_TIFFNoRowEncode
int _TIFFNoRowEncode(TIFF *tif, uint8 *pp, tmsize_t cc, uint16 s)
Definition: tif_compress.c:51
_TIFFNoStripEncode
int _TIFFNoStripEncode(TIFF *tif, uint8 *pp, tmsize_t cc, uint16 s)
Definition: tif_compress.c:58
_TIFFNoTileDecode
int _TIFFNoTileDecode(TIFF *tif, uint8 *pp, tmsize_t cc, uint16 s)
Definition: tif_compress.c:109
_TIFFNoRowDecode
int _TIFFNoRowDecode(TIFF *tif, uint8 *pp, tmsize_t cc, uint16 s)
Definition: tif_compress.c:95
_TIFFDefaultStripSize
uint32 _TIFFDefaultStripSize(TIFF *tif, uint32 s)
Definition: tif_strip.c:223
_TIFFDefaultTileSize
void _TIFFDefaultTileSize(TIFF *tif, uint32 *tw, uint32 *th)
Definition: tif_tile.c:278
TIFF_NOREADRAW
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
TIFF_NOBITREV
#define TIFF_NOBITREV
Definition: tiffiop.h:127

Referenced by TIFFClientOpen(), and TIFFSetCompressionScheme().

◆ _TIFFsetDoubleArray()

void _TIFFsetDoubleArray ( double **  dpp,
double *  dp,
uint32  n 
)

Definition at line 71 of file tif_dir.c.

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

Referenced by _TIFFVSetField().

◆ _TIFFsetFloatArray()

void _TIFFsetFloatArray ( float **  fpp,
float *  fp,
uint32  n 
)

Definition at line 69 of file tif_dir.c.

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

Referenced by _TIFFVSetField().

◆ _TIFFsetLongArray()

void _TIFFsetLongArray ( uint32 **  lpp,
uint32 *  lp,
uint32  n 
)

Definition at line 65 of file tif_dir.c.

66 { setByteArray((void**) lpp, (void*) lp, n, sizeof (uint32)); }

◆ _TIFFsetShortArray()

void _TIFFsetShortArray ( uint16 **  wpp,
uint16 *  wp,
uint32  n 
)

Definition at line 63 of file tif_dir.c.

64 { setByteArray((void**) wpp, (void*) wp, n, sizeof (uint16)); }

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

◆ _TIFFsetString()

void _TIFFsetString ( char **  cpp,
char *  cp 
)

Definition at line 59 of file tif_dir.c.

60 { setByteArray((void**) cpp, (void*) cp, strlen(cp)+1, 1); }

◆ _TIFFSwab16BitData()

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

Definition at line 1609 of file tif_read.c.

1610{
1611 (void) tif;
1612 assert((cc & 1) == 0);
1613 TIFFSwabArrayOfShort((uint16*) buf, cc/2);
1614}
assert
#define assert(x)
Definition: debug.h:53

Referenced by _TIFFVSetField().

◆ _TIFFSwab24BitData()

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

Definition at line 1617 of file tif_read.c.

1618{
1619 (void) tif;
1620 assert((cc % 3) == 0);
1621 TIFFSwabArrayOfTriples((uint8*) buf, cc/3);
1622}
TIFFSwabArrayOfTriples
void TIFFSwabArrayOfTriples(register uint8 *tp, tmsize_t n)
Definition: tif_swab.c:87

Referenced by _TIFFVSetField().

◆ _TIFFSwab32BitData()

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

Definition at line 1625 of file tif_read.c.

1626{
1627 (void) tif;
1628 assert((cc & 3) == 0);
1629 TIFFSwabArrayOfLong((uint32*) buf, cc/4);
1630}

Referenced by _TIFFVSetField().

◆ _TIFFSwab64BitData()

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

Definition at line 1633 of file tif_read.c.

1634{
1635 (void) tif;
1636 assert((cc & 7) == 0);
1637 TIFFSwabArrayOfDouble((double*) buf, cc/8);
1638}
TIFFSwabArrayOfDouble
void TIFFSwabArrayOfDouble(double *dp, tmsize_t n)
Definition: tif_swab.c:182

Referenced by _TIFFVSetField().

◆ _TIFFUInt64ToDouble()

double _TIFFUInt64ToDouble ( uint64  ui64)

Definition at line 382 of file tif_aux.c.

383{
384 _Int64 i;
385
386 i.value = ui64;
387 if (i.part.high >= 0) {
388 return (double)i.value;
389 } else {
390 long double df;
391 df = (long double)i.value;
392 df += 18446744073709551616.0; /* adding 2**64 */
393 return (double)df;
394 }
395}
return
return
Definition: dirsup.c:529
double
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
_Int64
Definition: tif_aux.c:360

Referenced by TIFFReadDirEntryDouble(), and TIFFReadDirEntryDoubleArray().

◆ _TIFFUInt64ToFloat()

float _TIFFUInt64ToFloat ( uint64  ui64)

Definition at line 366 of file tif_aux.c.

367{
368 _Int64 i;
369
370 i.value = ui64;
371 if (i.part.high >= 0) {
372 return (float)i.value;
373 } else {
374 long double df;
375 df = (long double)i.value;
376 df += 18446744073709551616.0; /* adding 2**64 */
377 return (float)df;
378 }
379}

Referenced by TIFFReadDirEntryFloat(), and TIFFReadDirEntryFloatArray().

◆ TIFFDefaultDirectory()

int TIFFDefaultDirectory ( TIFF *  tif)

Definition at line 1372 of file tif_dir.c.

1373{
1374 register TIFFDirectory* td = &tif->tif_dir;
1375 const TIFFFieldArray* tiffFieldArray;
1376
1377 tiffFieldArray = _TIFFGetFields();
1378 _TIFFSetupFields(tif, tiffFieldArray);
1379
1380 _TIFFmemset(td, 0, sizeof (*td));
1381 td->td_fillorder = FILLORDER_MSB2LSB;
1382 td->td_bitspersample = 1;
1383 td->td_threshholding = THRESHHOLD_BILEVEL;
1384 td->td_orientation = ORIENTATION_TOPLEFT;
1385 td->td_samplesperpixel = 1;
1386 td->td_rowsperstrip = (uint32) -1;
1387 td->td_tilewidth = 0;
1388 td->td_tilelength = 0;
1389 td->td_tiledepth = 1;
1390#ifdef STRIPBYTECOUNTSORTED_UNUSED
1391 td->td_stripbytecountsorted = 1; /* Our own arrays always sorted. */
1392#endif
1393 td->td_resolutionunit = RESUNIT_INCH;
1394 td->td_sampleformat = SAMPLEFORMAT_UINT;
1395 td->td_imagedepth = 1;
1396 td->td_ycbcrsubsampling[0] = 2;
1397 td->td_ycbcrsubsampling[1] = 2;
1398 td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
1399 tif->tif_postdecode = _TIFFNoPostDecode;
1400 tif->tif_foundfield = NULL;
1401 tif->tif_tagmethods.vsetfield = _TIFFVSetField;
1402 tif->tif_tagmethods.vgetfield = _TIFFVGetField;
1403 tif->tif_tagmethods.printdir = NULL;
1404 /*
1405 * Give client code a chance to install their own
1406 * tag extensions & methods, prior to compression overloads,
1407 * but do some prior cleanup first. (http://trac.osgeo.org/gdal/ticket/5054)
1408 */
1409 if (tif->tif_nfieldscompat > 0) {
1410 uint32 i;
1411
1412 for (i = 0; i < tif->tif_nfieldscompat; i++) {
1413 if (tif->tif_fieldscompat[i].allocated_size)
1414 _TIFFfree(tif->tif_fieldscompat[i].fields);
1415 }
1416 _TIFFfree(tif->tif_fieldscompat);
1417 tif->tif_nfieldscompat = 0;
1418 tif->tif_fieldscompat = NULL;
1419 }
1420 if (_TIFFextender)
1421 (*_TIFFextender)(tif);
1422 (void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
1423 /*
1424 * NB: The directory is marked dirty as a result of setting
1425 * up the default compression scheme. However, this really
1426 * isn't correct -- we want TIFF_DIRTYDIRECT to be set only
1427 * if the user does something. We could just do the setup
1428 * by hand, but it seems better to use the normal mechanism
1429 * (i.e. TIFFSetField).
1430 */
1431 tif->tif_flags &= ~TIFF_DIRTYDIRECT;
1432
1433 /*
1434 * As per http://bugzilla.remotesensing.org/show_bug.cgi?id=19
1435 * we clear the ISTILED flag when setting up a new directory.
1436 * Should we also be clearing stuff like INSUBIFD?
1437 */
1438 tif->tif_flags &= ~TIFF_ISTILED;
1439
1440 return (1);
1441}
TIFFDirectory::td_resolutionunit
uint16 td_resolutionunit
Definition: tif_dir.h:88
TIFFDirectory::td_sampleformat
uint16 td_sampleformat
Definition: tif_dir.h:76
TIFFDirectory::td_samplesperpixel
uint16 td_samplesperpixel
Definition: tif_dir.h:82
TIFFDirectory::td_imagedepth
uint32 td_imagedepth
Definition: tif_dir.h:72
TIFFDirectory::td_bitspersample
uint16 td_bitspersample
Definition: tif_dir.h:75
TIFFDirectory::td_rowsperstrip
uint32 td_rowsperstrip
Definition: tif_dir.h:83
TIFFDirectory::td_tiledepth
uint32 td_tiledepth
Definition: tif_dir.h:73
TIFFDirectory::td_fillorder
uint16 td_fillorder
Definition: tif_dir.h:80
TIFFDirectory::td_threshholding
uint16 td_threshholding
Definition: tif_dir.h:79
TIFFDirectory::td_tilelength
uint32 td_tilelength
Definition: tif_dir.h:73
TIFFDirectory::td_ycbcrpositioning
uint16 td_ycbcrpositioning
Definition: tif_dir.h:113
TIFFDirectory::td_tilewidth
uint32 td_tilewidth
Definition: tif_dir.h:73
TIFFDirectory::td_orientation
uint16 td_orientation
Definition: tif_dir.h:81
TIFFDirectory::td_ycbcrsubsampling
uint16 td_ycbcrsubsampling[2]
Definition: tif_dir.h:112
TIFFTagMethods::vgetfield
TIFFVGetMethod vgetfield
Definition: tiffio.h:334
TIFFTagMethods::vsetfield
TIFFVSetMethod vsetfield
Definition: tiffio.h:333
TIFFTagMethods::printdir
TIFFPrintMethod printdir
Definition: tiffio.h:335
_TIFFFieldArray
Definition: tif_dir.h:275
_TIFFFieldArray::fields
TIFFField * fields
Definition: tif_dir.h:279
_TIFFFieldArray::allocated_size
uint32 allocated_size
Definition: tif_dir.h:277
tiff::tif_foundfield
const TIFFField * tif_foundfield
Definition: tiffiop.h:218
tiff::tif_tagmethods
TIFFTagMethods tif_tagmethods
Definition: tiffiop.h:219
tiff::tif_nfieldscompat
size_t tif_nfieldscompat
Definition: tiffiop.h:224
tiff::tif_fieldscompat
TIFFFieldArray * tif_fieldscompat
Definition: tiffiop.h:223
_TIFFVGetField
static int _TIFFVGetField(TIFF *tif, uint32 tag, va_list ap)
Definition: tif_dir.c:873
TIFFSetField
int TIFFSetField(TIFF *tif, uint32 tag,...)
Definition: tif_dir.c:807
_TIFFextender
static TIFFExtendProc _TIFFextender
Definition: tif_dir.c:1309
_TIFFVSetField
static int _TIFFVSetField(TIFF *tif, uint32 tag, va_list ap)
Definition: tif_dir.c:171
_TIFFGetFields
const TIFFFieldArray * _TIFFGetFields(void)
Definition: tif_dirinfo.c:305
tiffFieldArray
static const TIFFFieldArray tiffFieldArray
Definition: tif_dirinfo.c:48
_TIFFSetupFields
void _TIFFSetupFields(TIFF *tif, const TIFFFieldArray *fieldarray)
Definition: tif_dirinfo.c:317
_TIFFNoPostDecode
void _TIFFNoPostDecode(TIFF *tif, uint8 *buf, tmsize_t cc)
Definition: tif_read.c:1603
COMPRESSION_NONE
#define COMPRESSION_NONE
Definition: tiff.h:158
YCBCRPOSITION_CENTERED
#define YCBCRPOSITION_CENTERED
Definition: tiff.h:364
ORIENTATION_TOPLEFT
#define ORIENTATION_TOPLEFT
Definition: tiff.h:223
SAMPLEFORMAT_UINT
#define SAMPLEFORMAT_UINT
Definition: tiff.h:308
FILLORDER_MSB2LSB
#define FILLORDER_MSB2LSB
Definition: tiff.h:215
RESUNIT_INCH
#define RESUNIT_INCH
Definition: tiff.h:263
THRESHHOLD_BILEVEL
#define THRESHHOLD_BILEVEL
Definition: tiff.h:209
TIFFTAG_COMPRESSION
#define TIFFTAG_COMPRESSION
Definition: tiff.h:157

Referenced by TIFFClientOpen(), TIFFCreateCustomDirectory(), TIFFCreateDirectory(), TIFFReadDirectory(), and TIFFUnlinkDirectory().

◆ TIFFFlushData1()

int TIFFFlushData1 ( TIFF *  tif)

Definition at line 803 of file tif_write.c.

804{
805 if (tif->tif_rawcc > 0 && tif->tif_flags & TIFF_BUF4WRITE ) {
806 if (!isFillOrder(tif, tif->tif_dir.td_fillorder) &&
807 (tif->tif_flags & TIFF_NOBITREV) == 0)
808 TIFFReverseBits((uint8*)tif->tif_rawdata,
809 tif->tif_rawcc);
810 if (!TIFFAppendToStrip(tif,
811 isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip,
812 tif->tif_rawdata, tif->tif_rawcc))
813 {
814 /* We update those variables even in case of error since there's */
815 /* code that doesn't really check the return code of this */
816 /* function */
817 tif->tif_rawcc = 0;
818 tif->tif_rawcp = tif->tif_rawdata;
819 return (0);
820 }
821 tif->tif_rawcc = 0;
822 tif->tif_rawcp = tif->tif_rawdata;
823 }
824 return (1);
825}
tiff::tif_rawcc
tmsize_t tif_rawcc
Definition: tiffiop.h:200
tiff::tif_curstrip
uint32 tif_curstrip
Definition: tiffiop.h:161
tiff::tif_curtile
uint32 tif_curtile
Definition: tiffiop.h:169
tiff::tif_rawcp
uint8 * tif_rawcp
Definition: tiffiop.h:199
tiff::tif_rawdata
uint8 * tif_rawdata
Definition: tiffiop.h:195
TIFFReverseBits
void TIFFReverseBits(uint8 *cp, tmsize_t n)
Definition: tif_swab.c:284
TIFFAppendToStrip
static int TIFFAppendToStrip(TIFF *tif, uint32 strip, uint8 *data, tmsize_t cc)
Definition: tif_write.c:728
isTiled
#define isTiled(tif)
Definition: tiffiop.h:229
TIFF_BUF4WRITE
#define TIFF_BUF4WRITE
Definition: tiffiop.h:139
isFillOrder
#define isFillOrder(tif, o)
Definition: tiffiop.h:231

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

◆ TIFFInitCCITTFax3()

int TIFFInitCCITTFax3 ( TIFF *  ,
int   
)

◆ TIFFInitCCITTFax4()

int TIFFInitCCITTFax4 ( TIFF *  ,
int   
)

◆ TIFFInitCCITTRLE()

int TIFFInitCCITTRLE ( TIFF *  ,
int   
)

◆ TIFFInitCCITTRLEW()

int TIFFInitCCITTRLEW ( TIFF *  ,
int   
)

◆ TIFFInitDumpMode()

int TIFFInitDumpMode ( TIFF *  tif,
int  scheme 
)

Definition at line 123 of file tif_dumpmode.c.

124{
125 (void) scheme;
126 tif->tif_fixuptags = DumpFixupTags;
127 tif->tif_decoderow = DumpModeDecode;
128 tif->tif_decodestrip = DumpModeDecode;
129 tif->tif_decodetile = DumpModeDecode;
130 tif->tif_encoderow = DumpModeEncode;
131 tif->tif_encodestrip = DumpModeEncode;
132 tif->tif_encodetile = DumpModeEncode;
133 tif->tif_seek = DumpModeSeek;
134 return (1);
135}
scheme
DWORD scheme
Definition: rpc_transport.c:2726
DumpModeSeek
static int DumpModeSeek(TIFF *tif, uint32 nrows)
Definition: tif_dumpmode.c:112
DumpModeDecode
static int DumpModeDecode(TIFF *tif, uint8 *buf, tmsize_t cc, uint16 s)
Definition: tif_dumpmode.c:77
DumpFixupTags
static int DumpFixupTags(TIFF *tif)
Definition: tif_dumpmode.c:34
DumpModeEncode
static int DumpModeEncode(TIFF *tif, uint8 *pp, tmsize_t cc, uint16 s)
Definition: tif_dumpmode.c:44

◆ TIFFInitLZW()

int TIFFInitLZW ( TIFF *  ,
int   
)

◆ TIFFInitNeXT()

int TIFFInitNeXT ( TIFF *  ,
int   
)

◆ TIFFInitPackBits()

int TIFFInitPackBits ( TIFF *  ,
int   
)

◆ TIFFInitPixarLog()

int TIFFInitPixarLog ( TIFF *  ,
int   
)

◆ TIFFInitSGILog()

int TIFFInitSGILog ( TIFF *  ,
int   
)

◆ TIFFInitThunderScan()

int TIFFInitThunderScan ( TIFF *  ,
int   
)

◆ TIFFInitZIP()

int TIFFInitZIP ( TIFF *  ,
int   
)

◆ TIFFSetCompressionScheme()

int TIFFSetCompressionScheme ( TIFF *  tif,
int  scheme 
)

Definition at line 160 of file tif_compress.c.

161{
162 const TIFFCodec *c = TIFFFindCODEC((uint16) scheme);
163
164 _TIFFSetDefaultCompressionState(tif);
165 /*
166 * Don't treat an unknown compression scheme as an error.
167 * This permits applications to open files with data that
168 * the library does not have builtin support for, but which
169 * may still be meaningful.
170 */
171 return (c ? (*c->init)(tif, scheme) : 1);
172}
c
const GLubyte * c
Definition: glext.h:8905
_TIFFSetDefaultCompressionState
void _TIFFSetDefaultCompressionState(TIFF *tif)
Definition: tif_compress.c:135
TIFFFindCODEC
const TIFFCodec * TIFFFindCODEC(uint16 scheme)
Definition: tif_compress.c:186

Referenced by _TIFFVSetField().

◆ TIFFSetDefaultCompressionState()

int TIFFSetDefaultCompressionState ( TIFF *  tif)

Variable Documentation

◆ _TIFFBuiltinCODECS

TIFFCodec _TIFFBuiltinCODECS[]
extern

Definition at line 87 of file tif_codec.c.

Referenced by TIFFFindCODEC(), and TIFFGetConfiguredCODECs().

◆ _TIFFerrorHandler

TIFFErrorHandler _TIFFerrorHandler
extern

Definition at line 374 of file tif_unix.c.

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

◆ _TIFFerrorHandlerExt

TIFFErrorHandlerExt _TIFFerrorHandlerExt
extern

Definition at line 30 of file tif_error.c.

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

◆ _TIFFwarningHandler

TIFFErrorHandler _TIFFwarningHandler
extern

Definition at line 364 of file tif_unix.c.

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

◆ _TIFFwarningHandlerExt

TIFFErrorHandlerExt _TIFFwarningHandlerExt
extern

Definition at line 30 of file tif_warning.c.

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