forked from Mirrors/freeswitch
726 lines
18 KiB
C
726 lines
18 KiB
C
/* $Id: tif_open.c,v 1.46 2010-12-06 16:54:54 faxguy Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1988-1997 Sam Leffler
|
|
* Copyright (c) 1991-1997 Silicon Graphics, Inc.
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and
|
|
* its documentation for any purpose is hereby granted without fee, provided
|
|
* that (i) the above copyright notices and this permission notice appear in
|
|
* all copies of the software and related documentation, and (ii) the names of
|
|
* Sam Leffler and Silicon Graphics may not be used in any advertising or
|
|
* publicity relating to the software without the specific, prior written
|
|
* permission of Sam Leffler and Silicon Graphics.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
|
|
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
* IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
|
|
* ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
|
|
* OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
|
* WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
|
|
* LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
|
|
* OF THIS SOFTWARE.
|
|
*/
|
|
|
|
/*
|
|
* TIFF Library.
|
|
*/
|
|
#include "tiffiop.h"
|
|
|
|
/*
|
|
* Dummy functions to fill the omitted client procedures.
|
|
*/
|
|
static int
|
|
_tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
|
|
{
|
|
(void) fd; (void) pbase; (void) psize;
|
|
return (0);
|
|
}
|
|
|
|
static void
|
|
_tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size)
|
|
{
|
|
(void) fd; (void) base; (void) size;
|
|
}
|
|
|
|
int
|
|
_TIFFgetMode(const char* mode, const char* module)
|
|
{
|
|
int m = -1;
|
|
|
|
switch (mode[0]) {
|
|
case 'r':
|
|
m = O_RDONLY;
|
|
if (mode[1] == '+')
|
|
m = O_RDWR;
|
|
break;
|
|
case 'w':
|
|
case 'a':
|
|
m = O_RDWR|O_CREAT;
|
|
if (mode[0] == 'w')
|
|
m |= O_TRUNC;
|
|
break;
|
|
default:
|
|
TIFFErrorExt(0, module, "\"%s\": Bad mode", mode);
|
|
break;
|
|
}
|
|
return (m);
|
|
}
|
|
|
|
TIFF*
|
|
TIFFClientOpen(
|
|
const char* name, const char* mode,
|
|
thandle_t clientdata,
|
|
TIFFReadWriteProc readproc,
|
|
TIFFReadWriteProc writeproc,
|
|
TIFFSeekProc seekproc,
|
|
TIFFCloseProc closeproc,
|
|
TIFFSizeProc sizeproc,
|
|
TIFFMapFileProc mapproc,
|
|
TIFFUnmapFileProc unmapproc
|
|
)
|
|
{
|
|
static const char module[] = "TIFFClientOpen";
|
|
TIFF *tif;
|
|
int m;
|
|
const char* cp;
|
|
|
|
/* The following are configuration checks. They should be redundant, but should not
|
|
* compile to any actual code in an optimised release build anyway. If any of them
|
|
* fail, (makefile-based or other) configuration is not correct */
|
|
assert(sizeof(uint8)==1);
|
|
assert(sizeof(int8)==1);
|
|
assert(sizeof(uint16)==2);
|
|
assert(sizeof(int16)==2);
|
|
assert(sizeof(uint32)==4);
|
|
assert(sizeof(int32)==4);
|
|
assert(sizeof(uint64)==8);
|
|
assert(sizeof(int64)==8);
|
|
assert(sizeof(tmsize_t)==sizeof(void*));
|
|
{
|
|
union{
|
|
uint8 a8[2];
|
|
uint16 a16;
|
|
} n;
|
|
n.a8[0]=1;
|
|
n.a8[1]=0;
|
|
#ifdef WORDS_BIGENDIAN
|
|
assert(n.a16==256);
|
|
#else
|
|
assert(n.a16==1);
|
|
#endif
|
|
}
|
|
|
|
m = _TIFFgetMode(mode, module);
|
|
if (m == -1)
|
|
goto bad2;
|
|
tif = (TIFF *)_TIFFmalloc((tmsize_t)(sizeof (TIFF) + strlen(name) + 1));
|
|
if (tif == NULL) {
|
|
TIFFErrorExt(clientdata, module, "%s: Out of memory (TIFF structure)", name);
|
|
goto bad2;
|
|
}
|
|
_TIFFmemset(tif, 0, sizeof (*tif));
|
|
tif->tif_name = (char *)tif + sizeof (TIFF);
|
|
strcpy(tif->tif_name, name);
|
|
tif->tif_mode = m &~ (O_CREAT|O_TRUNC);
|
|
tif->tif_curdir = (uint16) -1; /* non-existent directory */
|
|
tif->tif_curoff = 0;
|
|
tif->tif_curstrip = (uint32) -1; /* invalid strip */
|
|
tif->tif_row = (uint32) -1; /* read/write pre-increment */
|
|
tif->tif_clientdata = clientdata;
|
|
if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc) {
|
|
TIFFErrorExt(clientdata, module,
|
|
"One of the client procedures is NULL pointer.");
|
|
goto bad2;
|
|
}
|
|
tif->tif_readproc = readproc;
|
|
tif->tif_writeproc = writeproc;
|
|
tif->tif_seekproc = seekproc;
|
|
tif->tif_closeproc = closeproc;
|
|
tif->tif_sizeproc = sizeproc;
|
|
if (mapproc)
|
|
tif->tif_mapproc = mapproc;
|
|
else
|
|
tif->tif_mapproc = _tiffDummyMapProc;
|
|
if (unmapproc)
|
|
tif->tif_unmapproc = unmapproc;
|
|
else
|
|
tif->tif_unmapproc = _tiffDummyUnmapProc;
|
|
_TIFFSetDefaultCompressionState(tif); /* setup default state */
|
|
/*
|
|
* Default is to return data MSB2LSB and enable the
|
|
* use of memory-mapped files and strip chopping when
|
|
* a file is opened read-only.
|
|
*/
|
|
tif->tif_flags = FILLORDER_MSB2LSB;
|
|
if (m == O_RDONLY )
|
|
tif->tif_flags |= TIFF_MAPPED;
|
|
|
|
#ifdef STRIPCHOP_DEFAULT
|
|
if (m == O_RDONLY || m == O_RDWR)
|
|
tif->tif_flags |= STRIPCHOP_DEFAULT;
|
|
#endif
|
|
|
|
/*
|
|
* Process library-specific flags in the open mode string.
|
|
* The following flags may be used to control intrinsic library
|
|
* behaviour that may or may not be desirable (usually for
|
|
* compatibility with some application that claims to support
|
|
* TIFF but only supports some braindead idea of what the
|
|
* vendor thinks TIFF is):
|
|
*
|
|
* 'l' use little-endian byte order for creating a file
|
|
* 'b' use big-endian byte order for creating a file
|
|
* 'L' read/write information using LSB2MSB bit order
|
|
* 'B' read/write information using MSB2LSB bit order
|
|
* 'H' read/write information using host bit order
|
|
* 'M' enable use of memory-mapped files when supported
|
|
* 'm' disable use of memory-mapped files
|
|
* 'C' enable strip chopping support when reading
|
|
* 'c' disable strip chopping support
|
|
* 'h' read TIFF header only, do not load the first IFD
|
|
* '4' ClassicTIFF for creating a file (default)
|
|
* '8' BigTIFF for creating a file
|
|
*
|
|
* The use of the 'l' and 'b' flags is strongly discouraged.
|
|
* These flags are provided solely because numerous vendors,
|
|
* typically on the PC, do not correctly support TIFF; they
|
|
* only support the Intel little-endian byte order. This
|
|
* support is not configured by default because it supports
|
|
* the violation of the TIFF spec that says that readers *MUST*
|
|
* support both byte orders. It is strongly recommended that
|
|
* you not use this feature except to deal with busted apps
|
|
* that write invalid TIFF. And even in those cases you should
|
|
* bang on the vendors to fix their software.
|
|
*
|
|
* The 'L', 'B', and 'H' flags are intended for applications
|
|
* that can optimize operations on data by using a particular
|
|
* bit order. By default the library returns data in MSB2LSB
|
|
* bit order for compatibiltiy with older versions of this
|
|
* library. Returning data in the bit order of the native cpu
|
|
* makes the most sense but also requires applications to check
|
|
* the value of the FillOrder tag; something they probably do
|
|
* not do right now.
|
|
*
|
|
* The 'M' and 'm' flags are provided because some virtual memory
|
|
* systems exhibit poor behaviour when large images are mapped.
|
|
* These options permit clients to control the use of memory-mapped
|
|
* files on a per-file basis.
|
|
*
|
|
* The 'C' and 'c' flags are provided because the library support
|
|
* for chopping up large strips into multiple smaller strips is not
|
|
* application-transparent and as such can cause problems. The 'c'
|
|
* option permits applications that only want to look at the tags,
|
|
* for example, to get the unadulterated TIFF tag information.
|
|
*/
|
|
for (cp = mode; *cp; cp++)
|
|
switch (*cp) {
|
|
case 'b':
|
|
#ifndef WORDS_BIGENDIAN
|
|
if (m&O_CREAT)
|
|
tif->tif_flags |= TIFF_SWAB;
|
|
#endif
|
|
break;
|
|
case 'l':
|
|
#ifdef WORDS_BIGENDIAN
|
|
if ((m&O_CREAT))
|
|
tif->tif_flags |= TIFF_SWAB;
|
|
#endif
|
|
break;
|
|
case 'B':
|
|
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
|
|
FILLORDER_MSB2LSB;
|
|
break;
|
|
case 'L':
|
|
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
|
|
FILLORDER_LSB2MSB;
|
|
break;
|
|
case 'H':
|
|
tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
|
|
HOST_FILLORDER;
|
|
break;
|
|
case 'M':
|
|
if (m == O_RDONLY)
|
|
tif->tif_flags |= TIFF_MAPPED;
|
|
break;
|
|
case 'm':
|
|
if (m == O_RDONLY)
|
|
tif->tif_flags &= ~TIFF_MAPPED;
|
|
break;
|
|
case 'C':
|
|
if (m == O_RDONLY)
|
|
tif->tif_flags |= TIFF_STRIPCHOP;
|
|
break;
|
|
case 'c':
|
|
if (m == O_RDONLY)
|
|
tif->tif_flags &= ~TIFF_STRIPCHOP;
|
|
break;
|
|
case 'h':
|
|
tif->tif_flags |= TIFF_HEADERONLY;
|
|
break;
|
|
case '8':
|
|
if (m&O_CREAT)
|
|
tif->tif_flags |= TIFF_BIGTIFF;
|
|
break;
|
|
}
|
|
/*
|
|
* Read in TIFF header.
|
|
*/
|
|
if ((m & O_TRUNC) ||
|
|
!ReadOK(tif, &tif->tif_header, sizeof (TIFFHeaderClassic))) {
|
|
if (tif->tif_mode == O_RDONLY) {
|
|
TIFFErrorExt(tif->tif_clientdata, name,
|
|
"Cannot read TIFF header");
|
|
goto bad;
|
|
}
|
|
/*
|
|
* Setup header and write.
|
|
*/
|
|
#ifdef WORDS_BIGENDIAN
|
|
tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB
|
|
? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
|
|
#else
|
|
tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB
|
|
? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
|
|
#endif
|
|
if (!(tif->tif_flags&TIFF_BIGTIFF))
|
|
{
|
|
tif->tif_header.common.tiff_version = TIFF_VERSION_CLASSIC;
|
|
tif->tif_header.classic.tiff_diroff = 0;
|
|
if (tif->tif_flags & TIFF_SWAB)
|
|
TIFFSwabShort(&tif->tif_header.common.tiff_version);
|
|
tif->tif_header_size = sizeof(TIFFHeaderClassic);
|
|
}
|
|
else
|
|
{
|
|
tif->tif_header.common.tiff_version = TIFF_VERSION_BIG;
|
|
tif->tif_header.big.tiff_offsetsize = 8;
|
|
tif->tif_header.big.tiff_unused = 0;
|
|
tif->tif_header.big.tiff_diroff = 0;
|
|
if (tif->tif_flags & TIFF_SWAB)
|
|
{
|
|
TIFFSwabShort(&tif->tif_header.common.tiff_version);
|
|
TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
|
|
}
|
|
tif->tif_header_size = sizeof (TIFFHeaderBig);
|
|
}
|
|
/*
|
|
* The doc for "fopen" for some STD_C_LIBs says that if you
|
|
* open a file for modify ("+"), then you must fseek (or
|
|
* fflush?) between any freads and fwrites. This is not
|
|
* necessary on most systems, but has been shown to be needed
|
|
* on Solaris.
|
|
*/
|
|
TIFFSeekFile( tif, 0, SEEK_SET );
|
|
if (!WriteOK(tif, &tif->tif_header, (tmsize_t)(tif->tif_header_size))) {
|
|
TIFFErrorExt(tif->tif_clientdata, name,
|
|
"Error writing TIFF header");
|
|
goto bad;
|
|
}
|
|
/*
|
|
* Setup the byte order handling.
|
|
*/
|
|
if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
|
|
#ifndef WORDS_BIGENDIAN
|
|
tif->tif_flags |= TIFF_SWAB;
|
|
#endif
|
|
} else {
|
|
#ifdef WORDS_BIGENDIAN
|
|
tif->tif_flags |= TIFF_SWAB;
|
|
#endif
|
|
}
|
|
/*
|
|
* Setup default directory.
|
|
*/
|
|
if (!TIFFDefaultDirectory(tif))
|
|
goto bad;
|
|
tif->tif_diroff = 0;
|
|
tif->tif_dirlist = NULL;
|
|
tif->tif_dirlistsize = 0;
|
|
tif->tif_dirnumber = 0;
|
|
return (tif);
|
|
}
|
|
/*
|
|
* Setup the byte order handling.
|
|
*/
|
|
if (tif->tif_header.common.tiff_magic != TIFF_BIGENDIAN &&
|
|
tif->tif_header.common.tiff_magic != TIFF_LITTLEENDIAN
|
|
#if MDI_SUPPORT
|
|
&&
|
|
#if HOST_BIGENDIAN
|
|
tif->tif_header.common.tiff_magic != MDI_BIGENDIAN
|
|
#else
|
|
tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN
|
|
#endif
|
|
) {
|
|
TIFFErrorExt(tif->tif_clientdata, name,
|
|
"Not a TIFF or MDI file, bad magic number %d (0x%x)",
|
|
#else
|
|
) {
|
|
TIFFErrorExt(tif->tif_clientdata, name,
|
|
"Not a TIFF file, bad magic number %d (0x%x)",
|
|
#endif
|
|
tif->tif_header.common.tiff_magic,
|
|
tif->tif_header.common.tiff_magic);
|
|
goto bad;
|
|
}
|
|
if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
|
|
#ifndef WORDS_BIGENDIAN
|
|
tif->tif_flags |= TIFF_SWAB;
|
|
#endif
|
|
} else {
|
|
#ifdef WORDS_BIGENDIAN
|
|
tif->tif_flags |= TIFF_SWAB;
|
|
#endif
|
|
}
|
|
if (tif->tif_flags & TIFF_SWAB)
|
|
TIFFSwabShort(&tif->tif_header.common.tiff_version);
|
|
if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC)&&
|
|
(tif->tif_header.common.tiff_version != TIFF_VERSION_BIG)) {
|
|
TIFFErrorExt(tif->tif_clientdata, name,
|
|
"Not a TIFF file, bad version number %d (0x%x)",
|
|
tif->tif_header.common.tiff_version,
|
|
tif->tif_header.common.tiff_version);
|
|
goto bad;
|
|
}
|
|
if (tif->tif_header.common.tiff_version == TIFF_VERSION_CLASSIC)
|
|
{
|
|
if (tif->tif_flags & TIFF_SWAB)
|
|
TIFFSwabLong(&tif->tif_header.classic.tiff_diroff);
|
|
tif->tif_header_size = sizeof(TIFFHeaderClassic);
|
|
}
|
|
else
|
|
{
|
|
if (!ReadOK(tif, ((uint8*)(&tif->tif_header) + sizeof(TIFFHeaderClassic)), (sizeof(TIFFHeaderBig)-sizeof(TIFFHeaderClassic))))
|
|
{
|
|
TIFFErrorExt(tif->tif_clientdata, name,
|
|
"Cannot read TIFF header");
|
|
goto bad;
|
|
}
|
|
if (tif->tif_flags & TIFF_SWAB)
|
|
{
|
|
TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
|
|
TIFFSwabLong8(&tif->tif_header.big.tiff_diroff);
|
|
}
|
|
if (tif->tif_header.big.tiff_offsetsize != 8)
|
|
{
|
|
TIFFErrorExt(tif->tif_clientdata, name,
|
|
"Not a TIFF file, bad BigTIFF offsetsize %d (0x%x)",
|
|
tif->tif_header.big.tiff_offsetsize,
|
|
tif->tif_header.big.tiff_offsetsize);
|
|
goto bad;
|
|
}
|
|
if (tif->tif_header.big.tiff_unused != 0)
|
|
{
|
|
TIFFErrorExt(tif->tif_clientdata, name,
|
|
"Not a TIFF file, bad BigTIFF unused %d (0x%x)",
|
|
tif->tif_header.big.tiff_unused,
|
|
tif->tif_header.big.tiff_unused);
|
|
goto bad;
|
|
}
|
|
tif->tif_header_size = sizeof(TIFFHeaderBig);
|
|
tif->tif_flags |= TIFF_BIGTIFF;
|
|
}
|
|
tif->tif_flags |= TIFF_MYBUFFER;
|
|
tif->tif_rawcp = tif->tif_rawdata = 0;
|
|
tif->tif_rawdatasize = 0;
|
|
tif->tif_rawdataoff = 0;
|
|
tif->tif_rawdataloaded = 0;
|
|
|
|
switch (mode[0]) {
|
|
case 'r':
|
|
if (!(tif->tif_flags&TIFF_BIGTIFF))
|
|
tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff;
|
|
else
|
|
tif->tif_nextdiroff = tif->tif_header.big.tiff_diroff;
|
|
/*
|
|
* Try to use a memory-mapped file if the client
|
|
* has not explicitly suppressed usage with the
|
|
* 'm' flag in the open mode (see above).
|
|
*/
|
|
if (tif->tif_flags & TIFF_MAPPED)
|
|
{
|
|
toff_t n;
|
|
if (TIFFMapFileContents(tif,(void**)(&tif->tif_base),&n))
|
|
{
|
|
tif->tif_size=(tmsize_t)n;
|
|
assert((toff_t)tif->tif_size==n);
|
|
}
|
|
else
|
|
tif->tif_flags &= ~TIFF_MAPPED;
|
|
}
|
|
/*
|
|
* Sometimes we do not want to read the first directory (for example,
|
|
* it may be broken) and want to proceed to other directories. I this
|
|
* case we use the TIFF_HEADERONLY flag to open file and return
|
|
* immediately after reading TIFF header.
|
|
*/
|
|
if (tif->tif_flags & TIFF_HEADERONLY)
|
|
return (tif);
|
|
|
|
/*
|
|
* Setup initial directory.
|
|
*/
|
|
if (TIFFReadDirectory(tif)) {
|
|
tif->tif_rawcc = (tmsize_t)-1;
|
|
tif->tif_flags |= TIFF_BUFFERSETUP;
|
|
return (tif);
|
|
}
|
|
break;
|
|
case 'a':
|
|
/*
|
|
* New directories are automatically append
|
|
* to the end of the directory chain when they
|
|
* are written out (see TIFFWriteDirectory).
|
|
*/
|
|
if (!TIFFDefaultDirectory(tif))
|
|
goto bad;
|
|
return (tif);
|
|
}
|
|
bad:
|
|
tif->tif_mode = O_RDONLY; /* XXX avoid flush */
|
|
TIFFCleanup(tif);
|
|
bad2:
|
|
return ((TIFF*)0);
|
|
}
|
|
|
|
/*
|
|
* Query functions to access private data.
|
|
*/
|
|
|
|
/*
|
|
* Return open file's name.
|
|
*/
|
|
const char *
|
|
TIFFFileName(TIFF* tif)
|
|
{
|
|
return (tif->tif_name);
|
|
}
|
|
|
|
/*
|
|
* Set the file name.
|
|
*/
|
|
const char *
|
|
TIFFSetFileName(TIFF* tif, const char *name)
|
|
{
|
|
const char* old_name = tif->tif_name;
|
|
tif->tif_name = (char *)name;
|
|
return (old_name);
|
|
}
|
|
|
|
/*
|
|
* Return open file's I/O descriptor.
|
|
*/
|
|
int
|
|
TIFFFileno(TIFF* tif)
|
|
{
|
|
return (tif->tif_fd);
|
|
}
|
|
|
|
/*
|
|
* Set open file's I/O descriptor, and return previous value.
|
|
*/
|
|
int
|
|
TIFFSetFileno(TIFF* tif, int fd)
|
|
{
|
|
int old_fd = tif->tif_fd;
|
|
tif->tif_fd = fd;
|
|
return old_fd;
|
|
}
|
|
|
|
/*
|
|
* Return open file's clientdata.
|
|
*/
|
|
thandle_t
|
|
TIFFClientdata(TIFF* tif)
|
|
{
|
|
return (tif->tif_clientdata);
|
|
}
|
|
|
|
/*
|
|
* Set open file's clientdata, and return previous value.
|
|
*/
|
|
thandle_t
|
|
TIFFSetClientdata(TIFF* tif, thandle_t newvalue)
|
|
{
|
|
thandle_t m = tif->tif_clientdata;
|
|
tif->tif_clientdata = newvalue;
|
|
return m;
|
|
}
|
|
|
|
/*
|
|
* Return read/write mode.
|
|
*/
|
|
int
|
|
TIFFGetMode(TIFF* tif)
|
|
{
|
|
return (tif->tif_mode);
|
|
}
|
|
|
|
/*
|
|
* Return read/write mode.
|
|
*/
|
|
int
|
|
TIFFSetMode(TIFF* tif, int mode)
|
|
{
|
|
int old_mode = tif->tif_mode;
|
|
tif->tif_mode = mode;
|
|
return (old_mode);
|
|
}
|
|
|
|
/*
|
|
* Return nonzero if file is organized in
|
|
* tiles; zero if organized as strips.
|
|
*/
|
|
int
|
|
TIFFIsTiled(TIFF* tif)
|
|
{
|
|
return (isTiled(tif));
|
|
}
|
|
|
|
/*
|
|
* Return current row being read/written.
|
|
*/
|
|
uint32
|
|
TIFFCurrentRow(TIFF* tif)
|
|
{
|
|
return (tif->tif_row);
|
|
}
|
|
|
|
/*
|
|
* Return index of the current directory.
|
|
*/
|
|
uint16
|
|
TIFFCurrentDirectory(TIFF* tif)
|
|
{
|
|
return (tif->tif_curdir);
|
|
}
|
|
|
|
/*
|
|
* Return current strip.
|
|
*/
|
|
uint32
|
|
TIFFCurrentStrip(TIFF* tif)
|
|
{
|
|
return (tif->tif_curstrip);
|
|
}
|
|
|
|
/*
|
|
* Return current tile.
|
|
*/
|
|
uint32
|
|
TIFFCurrentTile(TIFF* tif)
|
|
{
|
|
return (tif->tif_curtile);
|
|
}
|
|
|
|
/*
|
|
* Return nonzero if the file has byte-swapped data.
|
|
*/
|
|
int
|
|
TIFFIsByteSwapped(TIFF* tif)
|
|
{
|
|
return ((tif->tif_flags & TIFF_SWAB) != 0);
|
|
}
|
|
|
|
/*
|
|
* Return nonzero if the data is returned up-sampled.
|
|
*/
|
|
int
|
|
TIFFIsUpSampled(TIFF* tif)
|
|
{
|
|
return (isUpSampled(tif));
|
|
}
|
|
|
|
/*
|
|
* Return nonzero if the data is returned in MSB-to-LSB bit order.
|
|
*/
|
|
int
|
|
TIFFIsMSB2LSB(TIFF* tif)
|
|
{
|
|
return (isFillOrder(tif, FILLORDER_MSB2LSB));
|
|
}
|
|
|
|
/*
|
|
* Return nonzero if given file was written in big-endian order.
|
|
*/
|
|
int
|
|
TIFFIsBigEndian(TIFF* tif)
|
|
{
|
|
return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN);
|
|
}
|
|
|
|
/*
|
|
* Return pointer to file read method.
|
|
*/
|
|
TIFFReadWriteProc
|
|
TIFFGetReadProc(TIFF* tif)
|
|
{
|
|
return (tif->tif_readproc);
|
|
}
|
|
|
|
/*
|
|
* Return pointer to file write method.
|
|
*/
|
|
TIFFReadWriteProc
|
|
TIFFGetWriteProc(TIFF* tif)
|
|
{
|
|
return (tif->tif_writeproc);
|
|
}
|
|
|
|
/*
|
|
* Return pointer to file seek method.
|
|
*/
|
|
TIFFSeekProc
|
|
TIFFGetSeekProc(TIFF* tif)
|
|
{
|
|
return (tif->tif_seekproc);
|
|
}
|
|
|
|
/*
|
|
* Return pointer to file close method.
|
|
*/
|
|
TIFFCloseProc
|
|
TIFFGetCloseProc(TIFF* tif)
|
|
{
|
|
return (tif->tif_closeproc);
|
|
}
|
|
|
|
/*
|
|
* Return pointer to file size requesting method.
|
|
*/
|
|
TIFFSizeProc
|
|
TIFFGetSizeProc(TIFF* tif)
|
|
{
|
|
return (tif->tif_sizeproc);
|
|
}
|
|
|
|
/*
|
|
* Return pointer to memory mapping method.
|
|
*/
|
|
TIFFMapFileProc
|
|
TIFFGetMapFileProc(TIFF* tif)
|
|
{
|
|
return (tif->tif_mapproc);
|
|
}
|
|
|
|
/*
|
|
* Return pointer to memory unmapping method.
|
|
*/
|
|
TIFFUnmapFileProc
|
|
TIFFGetUnmapFileProc(TIFF* tif)
|
|
{
|
|
return (tif->tif_unmapproc);
|
|
}
|
|
|
|
/* vim: set ts=8 sts=8 sw=8 noet: */
|
|
/*
|
|
* Local Variables:
|
|
* mode: c
|
|
* c-basic-offset: 8
|
|
* fill-column: 78
|
|
* End:
|
|
*/
|