1 /* $Id: tiffiop.h,v 1.95 2017-09-07 14:02:52 erouault Exp $ */ 2 3 /* 4 * Copyright (c) 1988-1997 Sam Leffler 5 * Copyright (c) 1991-1997 Silicon Graphics, Inc. 6 * 7 * Permission to use, copy, modify, distribute, and sell this software and 8 * its documentation for any purpose is hereby granted without fee, provided 9 * that (i) the above copyright notices and this permission notice appear in 10 * all copies of the software and related documentation, and (ii) the names of 11 * Sam Leffler and Silicon Graphics may not be used in any advertising or 12 * publicity relating to the software without the specific, prior written 13 * permission of Sam Leffler and Silicon Graphics. 14 * 15 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 16 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 17 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 18 * 19 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR 20 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, 21 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 22 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 23 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 24 * OF THIS SOFTWARE. 25 */ 26 27 #ifndef _TIFFIOP_ 28 #define _TIFFIOP_ 29 /* 30 * ``Library-private'' definitions. 31 */ 32 33 #include "tif_config.h" 34 35 #ifdef HAVE_FCNTL_H 36 # include <fcntl.h> 37 #endif 38 39 #ifdef HAVE_SYS_TYPES_H 40 # include <sys/types.h> 41 #endif 42 43 #ifdef HAVE_STRING_H 44 # include <string.h> 45 #endif 46 47 #ifdef HAVE_ASSERT_H 48 # include <assert.h> 49 #else 50 # define assert(x) 51 #endif 52 53 #ifdef HAVE_SEARCH_H 54 # include <search.h> 55 #else 56 extern void *lfind(const void *, const void *, size_t *, size_t, 57 int (*)(const void *, const void *)); 58 #endif 59 60 #if !defined(HAVE_SNPRINTF) && !defined(HAVE__SNPRINTF) 61 #undef snprintf 62 #define snprintf _TIFF_snprintf_f 63 extern int snprintf(char* str, size_t size, const char* format, ...); 64 #endif 65 66 #include "tiffio.h" 67 68 #include "tif_dir.h" 69 70 #ifndef STRIP_SIZE_DEFAULT 71 # define STRIP_SIZE_DEFAULT 8192 72 #endif 73 74 #define streq(a,b) (strcmp(a,b) == 0) 75 76 #ifndef TRUE 77 #define TRUE 1 78 #define FALSE 0 79 #endif 80 81 typedef struct client_info { 82 struct client_info *next; 83 void *data; 84 char *name; 85 } TIFFClientInfoLink; 86 87 /* 88 * Typedefs for ``method pointers'' used internally. 89 * these are deprecated and provided only for backwards compatibility. 90 */ 91 typedef unsigned char tidataval_t; /* internal image data value type */ 92 typedef tidataval_t* tidata_t; /* reference to internal image data */ 93 94 typedef void (*TIFFVoidMethod)(TIFF*); 95 typedef int (*TIFFBoolMethod)(TIFF*); 96 typedef int (*TIFFPreMethod)(TIFF*, uint16); 97 typedef int (*TIFFCodeMethod)(TIFF* tif, uint8* buf, tmsize_t size, uint16 sample); 98 typedef int (*TIFFSeekMethod)(TIFF*, uint32); 99 typedef void (*TIFFPostMethod)(TIFF* tif, uint8* buf, tmsize_t size); 100 typedef uint32 (*TIFFStripMethod)(TIFF*, uint32); 101 typedef void (*TIFFTileMethod)(TIFF*, uint32*, uint32*); 102 103 struct tiff { 104 char* tif_name; /* name of open file */ 105 int tif_fd; /* open file descriptor */ 106 int tif_mode; /* open mode (O_*) */ 107 uint32 tif_flags; 108 #define TIFF_FILLORDER 0x00003U /* natural bit fill order for machine */ 109 #define TIFF_DIRTYHEADER 0x00004U /* header must be written on close */ 110 #define TIFF_DIRTYDIRECT 0x00008U /* current directory must be written */ 111 #define TIFF_BUFFERSETUP 0x00010U /* data buffers setup */ 112 #define TIFF_CODERSETUP 0x00020U /* encoder/decoder setup done */ 113 #define TIFF_BEENWRITING 0x00040U /* written 1+ scanlines to file */ 114 #define TIFF_SWAB 0x00080U /* byte swap file information */ 115 #define TIFF_NOBITREV 0x00100U /* inhibit bit reversal logic */ 116 #define TIFF_MYBUFFER 0x00200U /* my raw data buffer; free on close */ 117 #define TIFF_ISTILED 0x00400U /* file is tile, not strip- based */ 118 #define TIFF_MAPPED 0x00800U /* file is mapped into memory */ 119 #define TIFF_POSTENCODE 0x01000U /* need call to postencode routine */ 120 #define TIFF_INSUBIFD 0x02000U /* currently writing a subifd */ 121 #define TIFF_UPSAMPLED 0x04000U /* library is doing data up-sampling */ 122 #define TIFF_STRIPCHOP 0x08000U /* enable strip chopping support */ 123 #define TIFF_HEADERONLY 0x10000U /* read header only, do not process the first directory */ 124 #define TIFF_NOREADRAW 0x20000U /* skip reading of raw uncompressed image data */ 125 #define TIFF_INCUSTOMIFD 0x40000U /* currently writing a custom IFD */ 126 #define TIFF_BIGTIFF 0x80000U /* read/write bigtiff */ 127 #define TIFF_BUF4WRITE 0x100000U /* rawcc bytes are for writing */ 128 #define TIFF_DIRTYSTRIP 0x200000U /* stripoffsets/stripbytecount dirty*/ 129 #define TIFF_PERSAMPLE 0x400000U /* get/set per sample tags as arrays */ 130 #define TIFF_BUFFERMMAP 0x800000U /* read buffer (tif_rawdata) points into mmap() memory */ 131 uint64 tif_diroff; /* file offset of current directory */ 132 uint64 tif_nextdiroff; /* file offset of following directory */ 133 uint64* tif_dirlist; /* list of offsets to already seen directories to prevent IFD looping */ 134 uint16 tif_dirlistsize; /* number of entries in offset list */ 135 uint16 tif_dirnumber; /* number of already seen directories */ 136 TIFFDirectory tif_dir; /* internal rep of current directory */ 137 TIFFDirectory tif_customdir; /* custom IFDs are separated from the main ones */ 138 union { 139 TIFFHeaderCommon common; 140 TIFFHeaderClassic classic; 141 TIFFHeaderBig big; 142 } tif_header; 143 uint16 tif_header_size; /* file's header block and its length */ 144 uint32 tif_row; /* current scanline */ 145 uint16 tif_curdir; /* current directory (index) */ 146 uint32 tif_curstrip; /* current strip for read/write */ 147 uint64 tif_curoff; /* current offset for read/write */ 148 uint64 tif_dataoff; /* current offset for writing dir */ 149 /* SubIFD support */ 150 uint16 tif_nsubifd; /* remaining subifds to write */ 151 uint64 tif_subifdoff; /* offset for patching SubIFD link */ 152 /* tiling support */ 153 uint32 tif_col; /* current column (offset by row too) */ 154 uint32 tif_curtile; /* current tile for read/write */ 155 tmsize_t tif_tilesize; /* # of bytes in a tile */ 156 /* compression scheme hooks */ 157 int tif_decodestatus; 158 TIFFBoolMethod tif_fixuptags; /* called in TIFFReadDirectory */ 159 TIFFBoolMethod tif_setupdecode; /* called once before predecode */ 160 TIFFPreMethod tif_predecode; /* pre- row/strip/tile decoding */ 161 TIFFBoolMethod tif_setupencode; /* called once before preencode */ 162 int tif_encodestatus; 163 TIFFPreMethod tif_preencode; /* pre- row/strip/tile encoding */ 164 TIFFBoolMethod tif_postencode; /* post- row/strip/tile encoding */ 165 TIFFCodeMethod tif_decoderow; /* scanline decoding routine */ 166 TIFFCodeMethod tif_encoderow; /* scanline encoding routine */ 167 TIFFCodeMethod tif_decodestrip; /* strip decoding routine */ 168 TIFFCodeMethod tif_encodestrip; /* strip encoding routine */ 169 TIFFCodeMethod tif_decodetile; /* tile decoding routine */ 170 TIFFCodeMethod tif_encodetile; /* tile encoding routine */ 171 TIFFVoidMethod tif_close; /* cleanup-on-close routine */ 172 TIFFSeekMethod tif_seek; /* position within a strip routine */ 173 TIFFVoidMethod tif_cleanup; /* cleanup state routine */ 174 TIFFStripMethod tif_defstripsize; /* calculate/constrain strip size */ 175 TIFFTileMethod tif_deftilesize; /* calculate/constrain tile size */ 176 uint8* tif_data; /* compression scheme private data */ 177 /* input/output buffering */ 178 tmsize_t tif_scanlinesize; /* # of bytes in a scanline */ 179 tmsize_t tif_scanlineskew; /* scanline skew for reading strips */ 180 uint8* tif_rawdata; /* raw data buffer */ 181 tmsize_t tif_rawdatasize; /* # of bytes in raw data buffer */ 182 tmsize_t tif_rawdataoff; /* rawdata offset within strip */ 183 tmsize_t tif_rawdataloaded;/* amount of data in rawdata */ 184 uint8* tif_rawcp; /* current spot in raw buffer */ 185 tmsize_t tif_rawcc; /* bytes unread from raw buffer */ 186 /* memory-mapped file support */ 187 uint8* tif_base; /* base of mapped file */ 188 tmsize_t tif_size; /* size of mapped file region (bytes, thus tmsize_t) */ 189 TIFFMapFileProc tif_mapproc; /* map file method */ 190 TIFFUnmapFileProc tif_unmapproc; /* unmap file method */ 191 /* input/output callback methods */ 192 thandle_t tif_clientdata; /* callback parameter */ 193 TIFFReadWriteProc tif_readproc; /* read method */ 194 TIFFReadWriteProc tif_writeproc; /* write method */ 195 TIFFSeekProc tif_seekproc; /* lseek method */ 196 TIFFCloseProc tif_closeproc; /* close method */ 197 TIFFSizeProc tif_sizeproc; /* filesize method */ 198 /* post-decoding support */ 199 TIFFPostMethod tif_postdecode; /* post decoding routine */ 200 /* tag support */ 201 TIFFField** tif_fields; /* sorted table of registered tags */ 202 size_t tif_nfields; /* # entries in registered tag table */ 203 const TIFFField* tif_foundfield; /* cached pointer to already found tag */ 204 TIFFTagMethods tif_tagmethods; /* tag get/set/print routines */ 205 TIFFClientInfoLink* tif_clientinfo; /* extra client information. */ 206 /* Backward compatibility stuff. We need these two fields for 207 * setting up an old tag extension scheme. */ 208 TIFFFieldArray* tif_fieldscompat; 209 size_t tif_nfieldscompat; 210 }; 211 212 #define isPseudoTag(t) (t > 0xffff) /* is tag value normal or pseudo */ 213 214 #define isTiled(tif) (((tif)->tif_flags & TIFF_ISTILED) != 0) 215 #define isMapped(tif) (((tif)->tif_flags & TIFF_MAPPED) != 0) 216 #define isFillOrder(tif, o) (((tif)->tif_flags & (o)) != 0) 217 #define isUpSampled(tif) (((tif)->tif_flags & TIFF_UPSAMPLED) != 0) 218 #define TIFFReadFile(tif, buf, size) \ 219 ((*(tif)->tif_readproc)((tif)->tif_clientdata,(buf),(size))) 220 #define TIFFWriteFile(tif, buf, size) \ 221 ((*(tif)->tif_writeproc)((tif)->tif_clientdata,(buf),(size))) 222 #define TIFFSeekFile(tif, off, whence) \ 223 ((*(tif)->tif_seekproc)((tif)->tif_clientdata,(off),(whence))) 224 #define TIFFCloseFile(tif) \ 225 ((*(tif)->tif_closeproc)((tif)->tif_clientdata)) 226 #define TIFFGetFileSize(tif) \ 227 ((*(tif)->tif_sizeproc)((tif)->tif_clientdata)) 228 #define TIFFMapFileContents(tif, paddr, psize) \ 229 ((*(tif)->tif_mapproc)((tif)->tif_clientdata,(paddr),(psize))) 230 #define TIFFUnmapFileContents(tif, addr, size) \ 231 ((*(tif)->tif_unmapproc)((tif)->tif_clientdata,(addr),(size))) 232 233 /* 234 * Default Read/Seek/Write definitions. 235 */ 236 #ifndef ReadOK 237 #define ReadOK(tif, buf, size) \ 238 (TIFFReadFile((tif),(buf),(size))==(size)) 239 #endif 240 #ifndef SeekOK 241 #define SeekOK(tif, off) _TIFFSeekOK(tif, off) 242 #endif 243 #ifndef WriteOK 244 #define WriteOK(tif, buf, size) \ 245 (TIFFWriteFile((tif),(buf),(size))==(size)) 246 #endif 247 248 /* NB: the uint32 casts are to silence certain ANSI-C compilers */ 249 #define TIFFhowmany_32(x, y) (((uint32)x < (0xffffffff - (uint32)(y-1))) ? \ 250 ((((uint32)(x))+(((uint32)(y))-1))/((uint32)(y))) : \ 251 0U) 252 /* Variant of TIFFhowmany_32() that doesn't return 0 if x close to MAXUINT. */ 253 /* Caution: TIFFhowmany_32_maxuint_compat(x,y)*y might overflow */ 254 #define TIFFhowmany_32_maxuint_compat(x, y) \ 255 (((uint32)(x) / (uint32)(y)) + ((((uint32)(x) % (uint32)(y)) != 0) ? 1 : 0)) 256 #define TIFFhowmany8_32(x) (((x)&0x07)?((uint32)(x)>>3)+1:(uint32)(x)>>3) 257 #define TIFFroundup_32(x, y) (TIFFhowmany_32(x,y)*(y)) 258 #define TIFFhowmany_64(x, y) ((((uint64)(x))+(((uint64)(y))-1))/((uint64)(y))) 259 #define TIFFhowmany8_64(x) (((x)&0x07)?((uint64)(x)>>3)+1:(uint64)(x)>>3) 260 #define TIFFroundup_64(x, y) (TIFFhowmany_64(x,y)*(y)) 261 262 /* Safe multiply which returns zero if there is an integer overflow */ 263 #define TIFFSafeMultiply(t,v,m) ((((t)(m) != (t)0) && (((t)(((v)*(m))/(m))) == (t)(v))) ? (t)((v)*(m)) : (t)0) 264 265 #define TIFFmax(A,B) ((A)>(B)?(A):(B)) 266 #define TIFFmin(A,B) ((A)<(B)?(A):(B)) 267 268 #define TIFFArrayCount(a) (sizeof (a) / sizeof ((a)[0])) 269 270 /* 271 Support for large files. 272 273 Windows read/write APIs support only 'unsigned int' rather than 'size_t'. 274 Windows off_t is only 32-bit, even in 64-bit builds. 275 */ 276 #if defined(HAVE_FSEEKO) 277 /* 278 Use fseeko() and ftello() if they are available since they use 279 'off_t' rather than 'long'. It is wrong to use fseeko() and 280 ftello() only on systems with special LFS support since some systems 281 (e.g. FreeBSD) support a 64-bit off_t by default. 282 283 For MinGW, __MSVCRT_VERSION__ must be at least 0x800 to expose these 284 interfaces. The MinGW compiler must support the requested version. MinGW 285 does not distribute the CRT (it is supplied by Microsoft) so the correct CRT 286 must be available on the target computer in order for the program to run. 287 */ 288 #if defined(HAVE_FSEEKO) 289 # define fseek(stream,offset,whence) fseeko(stream,offset,whence) 290 # define ftell(stream,offset,whence) ftello(stream,offset,whence) 291 #endif 292 #endif 293 #if defined(__WIN32__) && \ 294 !(defined(_MSC_VER) && _MSC_VER < 1400) && \ 295 !(defined(__MSVCRT_VERSION__) && __MSVCRT_VERSION__ < 0x800) 296 typedef unsigned int TIFFIOSize_t; 297 #define _TIFF_lseek_f(fildes,offset,whence) _lseeki64(fildes,/* __int64 */ offset,whence) 298 /* #define _TIFF_tell_f(fildes) /\* __int64 *\/ _telli64(fildes) */ 299 #define _TIFF_fseek_f(stream,offset,whence) _fseeki64(stream,/* __int64 */ offset,whence) 300 #define _TIFF_fstat_f(fildes,stat_buff) _fstati64(fildes,/* struct _stati64 */ stat_buff) 301 /* #define _TIFF_ftell_f(stream) /\* __int64 *\/ _ftelli64(stream) */ 302 /* #define _TIFF_stat_f(path,stat_buff) _stati64(path,/\* struct _stati64 *\/ stat_buff) */ 303 #define _TIFF_stat_s struct _stati64 304 #define _TIFF_off_t __int64 305 #else 306 typedef size_t TIFFIOSize_t; 307 #define _TIFF_lseek_f(fildes,offset,whence) lseek(fildes,offset,whence) 308 /* #define _TIFF_tell_f(fildes) (_TIFF_lseek_f(fildes,0,SEEK_CUR)) */ 309 #define _TIFF_fseek_f(stream,offset,whence) fseek(stream,offset,whence) 310 #define _TIFF_fstat_f(fildes,stat_buff) fstat(fildes,stat_buff) 311 /* #define _TIFF_ftell_f(stream) ftell(stream) */ 312 /* #define _TIFF_stat_f(path,stat_buff) stat(path,stat_buff) */ 313 #define _TIFF_stat_s struct stat 314 #define _TIFF_off_t off_t 315 #endif 316 317 #if __clang_major__ >= 4 || (__clang_major__ == 3 && __clang_minor__ >= 8) 318 #define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW __attribute__((no_sanitize("unsigned-integer-overflow"))) 319 #else 320 #define TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW 321 #endif 322 323 324 #if defined(__cplusplus) 325 extern "C" { 326 #endif 327 extern int _TIFFgetMode(const char* mode, const char* module); 328 extern int _TIFFNoRowEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s); 329 extern int _TIFFNoStripEncode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s); 330 extern int _TIFFNoTileEncode(TIFF*, uint8* pp, tmsize_t cc, uint16 s); 331 extern int _TIFFNoRowDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s); 332 extern int _TIFFNoStripDecode(TIFF* tif, uint8* pp, tmsize_t cc, uint16 s); 333 extern int _TIFFNoTileDecode(TIFF*, uint8* pp, tmsize_t cc, uint16 s); 334 extern void _TIFFNoPostDecode(TIFF* tif, uint8* buf, tmsize_t cc); 335 extern int _TIFFNoPreCode(TIFF* tif, uint16 s); 336 extern int _TIFFNoSeek(TIFF* tif, uint32 off); 337 extern void _TIFFSwab16BitData(TIFF* tif, uint8* buf, tmsize_t cc); 338 extern void _TIFFSwab24BitData(TIFF* tif, uint8* buf, tmsize_t cc); 339 extern void _TIFFSwab32BitData(TIFF* tif, uint8* buf, tmsize_t cc); 340 extern void _TIFFSwab64BitData(TIFF* tif, uint8* buf, tmsize_t cc); 341 extern int TIFFFlushData1(TIFF* tif); 342 extern int TIFFDefaultDirectory(TIFF* tif); 343 extern void _TIFFSetDefaultCompressionState(TIFF* tif); 344 extern int _TIFFRewriteField(TIFF *, uint16, TIFFDataType, tmsize_t, void *); 345 extern int TIFFSetCompressionScheme(TIFF* tif, int scheme); 346 extern int TIFFSetDefaultCompressionState(TIFF* tif); 347 extern uint32 _TIFFDefaultStripSize(TIFF* tif, uint32 s); 348 extern void _TIFFDefaultTileSize(TIFF* tif, uint32* tw, uint32* th); 349 extern int _TIFFDataSize(TIFFDataType type); 350 351 extern void _TIFFsetByteArray(void**, void*, uint32); 352 extern void _TIFFsetString(char**, char*); 353 extern void _TIFFsetShortArray(uint16**, uint16*, uint32); 354 extern void _TIFFsetLongArray(uint32**, uint32*, uint32); 355 extern void _TIFFsetFloatArray(float**, float*, uint32); 356 extern void _TIFFsetDoubleArray(double**, double*, uint32); 357 358 extern void _TIFFprintAscii(FILE*, const char*); 359 extern void _TIFFprintAsciiTag(FILE*, const char*, const char*); 360 361 extern TIFFErrorHandler _TIFFwarningHandler; 362 extern TIFFErrorHandler _TIFFerrorHandler; 363 extern TIFFErrorHandlerExt _TIFFwarningHandlerExt; 364 extern TIFFErrorHandlerExt _TIFFerrorHandlerExt; 365 366 extern uint32 _TIFFMultiply32(TIFF*, uint32, uint32, const char*); 367 extern uint64 _TIFFMultiply64(TIFF*, uint64, uint64, const char*); 368 extern void* _TIFFCheckMalloc(TIFF*, tmsize_t, tmsize_t, const char*); 369 extern void* _TIFFCheckRealloc(TIFF*, void*, tmsize_t, tmsize_t, const char*); 370 371 extern double _TIFFUInt64ToDouble(uint64); 372 extern float _TIFFUInt64ToFloat(uint64); 373 374 extern tmsize_t 375 _TIFFReadEncodedStripAndAllocBuffer(TIFF* tif, uint32 strip, 376 void **buf, tmsize_t bufsizetoalloc, 377 tmsize_t size_to_read); 378 extern tmsize_t 379 _TIFFReadEncodedTileAndAllocBuffer(TIFF* tif, uint32 tile, 380 void **buf, tmsize_t bufsizetoalloc, 381 tmsize_t size_to_read); 382 extern tmsize_t 383 _TIFFReadTileAndAllocBuffer(TIFF* tif, 384 void **buf, tmsize_t bufsizetoalloc, 385 uint32 x, uint32 y, uint32 z, uint16 s); 386 extern int _TIFFSeekOK(TIFF* tif, toff_t off); 387 388 extern int TIFFInitDumpMode(TIFF*, int); 389 #ifdef PACKBITS_SUPPORT 390 extern int TIFFInitPackBits(TIFF*, int); 391 #endif 392 #ifdef CCITT_SUPPORT 393 extern int TIFFInitCCITTRLE(TIFF*, int), TIFFInitCCITTRLEW(TIFF*, int); 394 extern int TIFFInitCCITTFax3(TIFF*, int), TIFFInitCCITTFax4(TIFF*, int); 395 #endif 396 #ifdef THUNDER_SUPPORT 397 extern int TIFFInitThunderScan(TIFF*, int); 398 #endif 399 #ifdef NEXT_SUPPORT 400 extern int TIFFInitNeXT(TIFF*, int); 401 #endif 402 #ifdef LZW_SUPPORT 403 extern int TIFFInitLZW(TIFF*, int); 404 #endif 405 #ifdef OJPEG_SUPPORT 406 extern int TIFFInitOJPEG(TIFF*, int); 407 #endif 408 #ifdef JPEG_SUPPORT 409 extern int TIFFInitJPEG(TIFF*, int); 410 extern int TIFFJPEGIsFullStripRequired(TIFF*); 411 #endif 412 #ifdef JBIG_SUPPORT 413 extern int TIFFInitJBIG(TIFF*, int); 414 #endif 415 #ifdef ZIP_SUPPORT 416 extern int TIFFInitZIP(TIFF*, int); 417 #endif 418 #ifdef PIXARLOG_SUPPORT 419 extern int TIFFInitPixarLog(TIFF*, int); 420 #endif 421 #ifdef LOGLUV_SUPPORT 422 extern int TIFFInitSGILog(TIFF*, int); 423 #endif 424 #ifdef LZMA_SUPPORT 425 extern int TIFFInitLZMA(TIFF*, int); 426 #endif 427 #ifdef VMS 428 extern const TIFFCodec _TIFFBuiltinCODECS[]; 429 #else 430 extern TIFFCodec _TIFFBuiltinCODECS[]; 431 #endif 432 433 #if defined(__cplusplus) 434 } 435 #endif 436 #endif /* _TIFFIOP_ */ 437 438 /* vim: set ts=8 sts=8 sw=8 noet: */ 439 /* 440 * Local Variables: 441 * mode: c 442 * c-basic-offset: 8 443 * fill-column: 78 444 * End: 445 */ 446