src/tiff/libtiff/tif_open.c

   1 /* $Id$ */
   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 /*
  28  * TIFF Library.
  29  */
  30 #include "tiffiop.h"
  31
  32 /*
  33  * Dummy functions to fill the omitted client procedures.
  34  */
  35 static int
  36 _tiffDummyMapProc(thandle_t fd, void** pbase, toff_t* psize)
  37 {
  38         (void) fd; (void) pbase; (void) psize;
  39         return (0);
  40 }
  41
  42 static void
  43 _tiffDummyUnmapProc(thandle_t fd, void* base, toff_t size)
  44 {
  45         (void) fd; (void) base; (void) size;
  46 }
  47
  48 int
  49 _TIFFgetMode(const char* mode, const char* module)
  50 {
  51         int m = -1;
  52
  53         switch (mode[0]) {
  54         case 'r':
  55                 m = O_RDONLY;
  56                 if (mode[1] == '+')
  57                         m = O_RDWR;
  58                 break;
  59         case 'w':
  60         case 'a':
  61                 m = O_RDWR|O_CREAT;
  62                 if (mode[0] == 'w')
  63                         m |= O_TRUNC;
  64                 break;
  65         default:
  66                 TIFFErrorExt(0, module, "\"%s\": Bad mode", mode);
  67                 break;
  68         }
  69         return (m);
  70 }
  71
  72 TIFF*
  73 TIFFClientOpen(
  74         const char* name, const char* mode,
  75         thandle_t clientdata,
  76         TIFFReadWriteProc readproc,
  77         TIFFReadWriteProc writeproc,
  78         TIFFSeekProc seekproc,
  79         TIFFCloseProc closeproc,
  80         TIFFSizeProc sizeproc,
  81         TIFFMapFileProc mapproc,
  82         TIFFUnmapFileProc unmapproc
  83 )
  84 {
  85         static const char module[] = "TIFFClientOpen";
  86         TIFF *tif;
  87         int m;
  88         const char* cp;
  89
  90         /* The following are configuration checks. They should be redundant, but should not
  91          * compile to any actual code in an optimised release build anyway. If any of them
  92          * fail, (makefile-based or other) configuration is not correct */
  93         assert(sizeof(uint8)==1);
  94         assert(sizeof(int8)==1);
  95         assert(sizeof(uint16)==2);
  96         assert(sizeof(int16)==2);
  97         assert(sizeof(uint32)==4);
  98         assert(sizeof(int32)==4);
  99         assert(sizeof(uint64)==8);
 100         assert(sizeof(int64)==8);
 101         assert(sizeof(tmsize_t)==sizeof(void*));
 102         {
 103                 union{
 104                         uint8 a8[2];
 105                         uint16 a16;
 106                 } n;
 107                 n.a8[0]=1;
 108                 n.a8[1]=0;
 109                 #ifdef WORDS_BIGENDIAN
 110                 assert(n.a16==256);
 111                 #else
 112                 assert(n.a16==1);
 113                 #endif
 114         }
 115
 116         m = _TIFFgetMode(mode, module);
 117         if (m == -1)
 118                 goto bad2;
 119         tif = (TIFF *)_TIFFmalloc((tmsize_t)(sizeof (TIFF) + strlen(name) + 1));
 120         if (tif == NULL) {
 121                 TIFFErrorExt(clientdata, module, "%s: Out of memory (TIFF structure)", name);
 122                 goto bad2;
 123         }
 124         _TIFFmemset(tif, 0, sizeof (*tif));
 125         tif->tif_name = (char *)tif + sizeof (TIFF);
 126         strcpy(tif->tif_name, name);
 127         tif->tif_mode = m &~ (O_CREAT|O_TRUNC);
 128         tif->tif_curdir = (uint16) -1;          /* non-existent directory */
 129         tif->tif_curoff = 0;
 130         tif->tif_curstrip = (uint32) -1;        /* invalid strip */
 131         tif->tif_row = (uint32) -1;             /* read/write pre-increment */
 132         tif->tif_clientdata = clientdata;
 133         if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc) {
 134                 TIFFErrorExt(clientdata, module,
 135                     "One of the client procedures is NULL pointer.");
 136                 goto bad2;
 137         }
 138         tif->tif_readproc = readproc;
 139         tif->tif_writeproc = writeproc;
 140         tif->tif_seekproc = seekproc;
 141         tif->tif_closeproc = closeproc;
 142         tif->tif_sizeproc = sizeproc;
 143         if (mapproc)
 144                 tif->tif_mapproc = mapproc;
 145         else
 146                 tif->tif_mapproc = _tiffDummyMapProc;
 147         if (unmapproc)
 148                 tif->tif_unmapproc = unmapproc;
 149         else
 150                 tif->tif_unmapproc = _tiffDummyUnmapProc;
 151         _TIFFSetDefaultCompressionState(tif);    /* setup default state */
 152         /*
 153          * Default is to return data MSB2LSB and enable the
 154          * use of memory-mapped files and strip chopping when
 155          * a file is opened read-only.
 156          */
 157         tif->tif_flags = FILLORDER_MSB2LSB;
 158         if (m == O_RDONLY )
 159                 tif->tif_flags |= TIFF_MAPPED;
 160
 161         #ifdef STRIPCHOP_DEFAULT
 162         if (m == O_RDONLY || m == O_RDWR)
 163                 tif->tif_flags |= STRIPCHOP_DEFAULT;
 164         #endif
 165
 166         /*
 167          * Process library-specific flags in the open mode string.
 168          * The following flags may be used to control intrinsic library
 169          * behaviour that may or may not be desirable (usually for
 170          * compatibility with some application that claims to support
 171          * TIFF but only supports some braindead idea of what the
 172          * vendor thinks TIFF is):
 173          *
 174          * 'l' use little-endian byte order for creating a file
 175          * 'b' use big-endian byte order for creating a file
 176          * 'L' read/write information using LSB2MSB bit order
 177          * 'B' read/write information using MSB2LSB bit order
 178          * 'H' read/write information using host bit order
 179          * 'M' enable use of memory-mapped files when supported
 180          * 'm' disable use of memory-mapped files
 181          * 'C' enable strip chopping support when reading
 182          * 'c' disable strip chopping support
 183          * 'h' read TIFF header only, do not load the first IFD
 184          * '4' ClassicTIFF for creating a file (default)
 185          * '8' BigTIFF for creating a file
 186          *
 187          * The use of the 'l' and 'b' flags is strongly discouraged.
 188          * These flags are provided solely because numerous vendors,
 189          * typically on the PC, do not correctly support TIFF; they
 190          * only support the Intel little-endian byte order.  This
 191          * support is not configured by default because it supports
 192          * the violation of the TIFF spec that says that readers *MUST*
 193          * support both byte orders.  It is strongly recommended that
 194          * you not use this feature except to deal with busted apps
 195          * that write invalid TIFF.  And even in those cases you should
 196          * bang on the vendors to fix their software.
 197          *
 198          * The 'L', 'B', and 'H' flags are intended for applications
 199          * that can optimize operations on data by using a particular
 200          * bit order.  By default the library returns data in MSB2LSB
 201          * bit order for compatibiltiy with older versions of this
 202          * library.  Returning data in the bit order of the native cpu
 203          * makes the most sense but also requires applications to check
 204          * the value of the FillOrder tag; something they probably do
 205          * not do right now.
 206          *
 207          * The 'M' and 'm' flags are provided because some virtual memory
 208          * systems exhibit poor behaviour when large images are mapped.
 209          * These options permit clients to control the use of memory-mapped
 210          * files on a per-file basis.
 211          *
 212          * The 'C' and 'c' flags are provided because the library support
 213          * for chopping up large strips into multiple smaller strips is not
 214          * application-transparent and as such can cause problems.  The 'c'
 215          * option permits applications that only want to look at the tags,
 216          * for example, to get the unadulterated TIFF tag information.
 217          */
 218         for (cp = mode; *cp; cp++)
 219                 switch (*cp) {
 220                         case 'b':
 221                                 #ifndef WORDS_BIGENDIAN
 222                                 if (m&O_CREAT)
 223                                         tif->tif_flags |= TIFF_SWAB;
 224                                 #endif
 225                                 break;
 226                         case 'l':
 227                                 #ifdef WORDS_BIGENDIAN
 228                                 if ((m&O_CREAT))
 229                                         tif->tif_flags |= TIFF_SWAB;
 230                                 #endif
 231                                 break;
 232                         case 'B':
 233                                 tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
 234                                     FILLORDER_MSB2LSB;
 235                                 break;
 236                         case 'L':
 237                                 tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
 238                                     FILLORDER_LSB2MSB;
 239                                 break;
 240                         case 'H':
 241                                 tif->tif_flags = (tif->tif_flags &~ TIFF_FILLORDER) |
 242                                     HOST_FILLORDER;
 243                                 break;
 244                         case 'M':
 245                                 if (m == O_RDONLY)
 246                                         tif->tif_flags |= TIFF_MAPPED;
 247                                 break;
 248                         case 'm':
 249                                 if (m == O_RDONLY)
 250                                         tif->tif_flags &= ~TIFF_MAPPED;
 251                                 break;
 252                         case 'C':
 253                                 if (m == O_RDONLY)
 254                                         tif->tif_flags |= TIFF_STRIPCHOP;
 255                                 break;
 256                         case 'c':
 257                                 if (m == O_RDONLY)
 258                                         tif->tif_flags &= ~TIFF_STRIPCHOP;
 259                                 break;
 260                         case 'h':
 261                                 tif->tif_flags |= TIFF_HEADERONLY;
 262                                 break;
 263                         case '8':
 264                                 if (m&O_CREAT)
 265                                         tif->tif_flags |= TIFF_BIGTIFF;
 266                                 break;
 267                 }
 268         /*
 269          * Read in TIFF header.
 270          */
 271         if ((m & O_TRUNC) ||
 272             !ReadOK(tif, &tif->tif_header, sizeof (TIFFHeaderClassic))) {
 273                 if (tif->tif_mode == O_RDONLY) {
 274                         TIFFErrorExt(tif->tif_clientdata, name,
 275                             "Cannot read TIFF header");
 276                         goto bad;
 277                 }
 278                 /*
 279                  * Setup header and write.
 280                  */
 281                 #ifdef WORDS_BIGENDIAN
 282                 tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB
 283                     ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
 284                 #else
 285                 tif->tif_header.common.tiff_magic = tif->tif_flags & TIFF_SWAB
 286                     ? TIFF_BIGENDIAN : TIFF_LITTLEENDIAN;
 287                 #endif
 288                 if (!(tif->tif_flags&TIFF_BIGTIFF))
 289                 {
 290                         tif->tif_header.common.tiff_version = TIFF_VERSION_CLASSIC;
 291                         tif->tif_header.classic.tiff_diroff = 0;
 292                         if (tif->tif_flags & TIFF_SWAB)
 293                                 TIFFSwabShort(&tif->tif_header.common.tiff_version);
 294                         tif->tif_header_size = sizeof(TIFFHeaderClassic);
 295                 }
 296                 else
 297                 {
 298                         tif->tif_header.common.tiff_version = TIFF_VERSION_BIG;
 299                         tif->tif_header.big.tiff_offsetsize = 8;
 300                         tif->tif_header.big.tiff_unused = 0;
 301                         tif->tif_header.big.tiff_diroff = 0;
 302                         if (tif->tif_flags & TIFF_SWAB)
 303                         {
 304                                 TIFFSwabShort(&tif->tif_header.common.tiff_version);
 305                                 TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
 306                         }
 307                         tif->tif_header_size = sizeof (TIFFHeaderBig);
 308                 }
 309                 /*
 310                  * The doc for "fopen" for some STD_C_LIBs says that if you
 311                  * open a file for modify ("+"), then you must fseek (or
 312                  * fflush?) between any freads and fwrites.  This is not
 313                  * necessary on most systems, but has been shown to be needed
 314                  * on Solaris.
 315                  */
 316                 TIFFSeekFile( tif, 0, SEEK_SET );
 317                 if (!WriteOK(tif, &tif->tif_header, (tmsize_t)(tif->tif_header_size))) {
 318                         TIFFErrorExt(tif->tif_clientdata, name,
 319                             "Error writing TIFF header");
 320                         goto bad;
 321                 }
 322                 /*
 323                  * Setup the byte order handling.
 324                  */
 325                 if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
 326                         #ifndef WORDS_BIGENDIAN
 327                         tif->tif_flags |= TIFF_SWAB;
 328                         #endif
 329                 } else {
 330                         #ifdef WORDS_BIGENDIAN
 331                         tif->tif_flags |= TIFF_SWAB;
 332                         #endif
 333                 }
 334                 /*
 335                  * Setup default directory.
 336                  */
 337                 if (!TIFFDefaultDirectory(tif))
 338                         goto bad;
 339                 tif->tif_diroff = 0;
 340                 tif->tif_dirlist = NULL;
 341                 tif->tif_dirlistsize = 0;
 342                 tif->tif_dirnumber = 0;
 343                 return (tif);
 344         }
 345         /*
 346          * Setup the byte order handling.
 347          */
 348         if (tif->tif_header.common.tiff_magic != TIFF_BIGENDIAN &&
 349             tif->tif_header.common.tiff_magic != TIFF_LITTLEENDIAN
 350             #if MDI_SUPPORT
 351             &&
 352             #if HOST_BIGENDIAN
 353             tif->tif_header.common.tiff_magic != MDI_BIGENDIAN
 354             #else
 355             tif->tif_header.common.tiff_magic != MDI_LITTLEENDIAN
 356             #endif
 357             ) {
 358                 TIFFErrorExt(tif->tif_clientdata, name,
 359                     "Not a TIFF or MDI file, bad magic number %d (0x%x)",
 360             #else
 361             ) {
 362                 TIFFErrorExt(tif->tif_clientdata, name,
 363                     "Not a TIFF file, bad magic number %d (0x%x)",
 364             #endif
 365                     tif->tif_header.common.tiff_magic,
 366                     tif->tif_header.common.tiff_magic);
 367                 goto bad;
 368         }
 369         if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN) {
 370                 #ifndef WORDS_BIGENDIAN
 371                 tif->tif_flags |= TIFF_SWAB;
 372                 #endif
 373         } else {
 374                 #ifdef WORDS_BIGENDIAN
 375                 tif->tif_flags |= TIFF_SWAB;
 376                 #endif
 377         }
 378         if (tif->tif_flags & TIFF_SWAB)
 379                 TIFFSwabShort(&tif->tif_header.common.tiff_version);
 380         if ((tif->tif_header.common.tiff_version != TIFF_VERSION_CLASSIC)&&
 381             (tif->tif_header.common.tiff_version != TIFF_VERSION_BIG)) {
 382                 TIFFErrorExt(tif->tif_clientdata, name,
 383                     "Not a TIFF file, bad version number %d (0x%x)",
 384                     tif->tif_header.common.tiff_version,
 385                     tif->tif_header.common.tiff_version);
 386                 goto bad;
 387         }
 388         if (tif->tif_header.common.tiff_version == TIFF_VERSION_CLASSIC)
 389         {
 390                 if (tif->tif_flags & TIFF_SWAB)
 391                         TIFFSwabLong(&tif->tif_header.classic.tiff_diroff);
 392                 tif->tif_header_size = sizeof(TIFFHeaderClassic);
 393         }
 394         else
 395         {
 396                 if (!ReadOK(tif, ((uint8*)(&tif->tif_header) + sizeof(TIFFHeaderClassic)), (sizeof(TIFFHeaderBig)-sizeof(TIFFHeaderClassic))))
 397                 {
 398                         TIFFErrorExt(tif->tif_clientdata, name,
 399                             "Cannot read TIFF header");
 400                         goto bad;
 401                 }
 402                 if (tif->tif_flags & TIFF_SWAB)
 403                 {
 404                         TIFFSwabShort(&tif->tif_header.big.tiff_offsetsize);
 405                         TIFFSwabLong8(&tif->tif_header.big.tiff_diroff);
 406                 }
 407                 if (tif->tif_header.big.tiff_offsetsize != 8)
 408                 {
 409                         TIFFErrorExt(tif->tif_clientdata, name,
 410                             "Not a TIFF file, bad BigTIFF offsetsize %d (0x%x)",
 411                             tif->tif_header.big.tiff_offsetsize,
 412                             tif->tif_header.big.tiff_offsetsize);
 413                         goto bad;
 414                 }
 415                 if (tif->tif_header.big.tiff_unused != 0)
 416                 {
 417                         TIFFErrorExt(tif->tif_clientdata, name,
 418                             "Not a TIFF file, bad BigTIFF unused %d (0x%x)",
 419                             tif->tif_header.big.tiff_unused,
 420                             tif->tif_header.big.tiff_unused);
 421                         goto bad;
 422                 }
 423                 tif->tif_header_size = sizeof(TIFFHeaderBig);
 424                 tif->tif_flags |= TIFF_BIGTIFF;
 425         }
 426         tif->tif_flags |= TIFF_MYBUFFER;
 427         tif->tif_rawcp = tif->tif_rawdata = 0;
 428         tif->tif_rawdatasize = 0;
 429         tif->tif_rawdataoff = 0;
 430         tif->tif_rawdataloaded = 0;
 431
 432         switch (mode[0]) {
 433                 case 'r':
 434                         if (!(tif->tif_flags&TIFF_BIGTIFF))
 435                                 tif->tif_nextdiroff = tif->tif_header.classic.tiff_diroff;
 436                         else
 437                                 tif->tif_nextdiroff = tif->tif_header.big.tiff_diroff;
 438                         /*
 439                          * Try to use a memory-mapped file if the client
 440                          * has not explicitly suppressed usage with the
 441                          * 'm' flag in the open mode (see above).
 442                          */
 443                         if (tif->tif_flags & TIFF_MAPPED)
 444                         {
 445                                 toff_t n;
 446                                 if (TIFFMapFileContents(tif,(void**)(&tif->tif_base),&n))
 447                                 {
 448                                         tif->tif_size=(tmsize_t)n;
 449                                         assert((toff_t)tif->tif_size==n);
 450                                 }
 451                                 else
 452                                         tif->tif_flags &= ~TIFF_MAPPED;
 453                         }
 454                         /*
 455                          * Sometimes we do not want to read the first directory (for example,
 456                          * it may be broken) and want to proceed to other directories. I this
 457                          * case we use the TIFF_HEADERONLY flag to open file and return
 458                          * immediately after reading TIFF header.
 459                          */
 460                         if (tif->tif_flags & TIFF_HEADERONLY)
 461                                 return (tif);
 462
 463                         /*
 464                          * Setup initial directory.
 465                          */
 466                         if (TIFFReadDirectory(tif)) {
 467                                 tif->tif_rawcc = (tmsize_t)-1;
 468                                 tif->tif_flags |= TIFF_BUFFERSETUP;
 469                                 return (tif);
 470                         }
 471                         break;
 472                 case 'a':
 473                         /*
 474                          * New directories are automatically append
 475                          * to the end of the directory chain when they
 476                          * are written out (see TIFFWriteDirectory).
 477                          */
 478                         if (!TIFFDefaultDirectory(tif))
 479                                 goto bad;
 480                         return (tif);
 481         }
 482 bad:
 483         tif->tif_mode = O_RDONLY;       /* XXX avoid flush */
 484         TIFFCleanup(tif);
 485 bad2:
 486         return ((TIFF*)0);
 487 }
 488
 489 /*
 490  * Query functions to access private data.
 491  */
 492
 493 /*
 494  * Return open file's name.
 495  */
 496 const char *
 497 TIFFFileName(TIFF* tif)
 498 {
 499         return (tif->tif_name);
 500 }
 501
 502 /*
 503  * Set the file name.
 504  */
 505 const char *
 506 TIFFSetFileName(TIFF* tif, const char *name)
 507 {
 508         const char* old_name = tif->tif_name;
 509         tif->tif_name = (char *)name;
 510         return (old_name);
 511 }
 512
 513 /*
 514  * Return open file's I/O descriptor.
 515  */
 516 int
 517 TIFFFileno(TIFF* tif)
 518 {
 519         return (tif->tif_fd);
 520 }
 521
 522 /*
 523  * Set open file's I/O descriptor, and return previous value.
 524  */
 525 int
 526 TIFFSetFileno(TIFF* tif, int fd)
 527 {
 528         int old_fd = tif->tif_fd;
 529         tif->tif_fd = fd;
 530         return old_fd;
 531 }
 532
 533 /*
 534  * Return open file's clientdata.
 535  */
 536 thandle_t
 537 TIFFClientdata(TIFF* tif)
 538 {
 539         return (tif->tif_clientdata);
 540 }
 541
 542 /*
 543  * Set open file's clientdata, and return previous value.
 544  */
 545 thandle_t
 546 TIFFSetClientdata(TIFF* tif, thandle_t newvalue)
 547 {
 548         thandle_t m = tif->tif_clientdata;
 549         tif->tif_clientdata = newvalue;
 550         return m;
 551 }
 552
 553 /*
 554  * Return read/write mode.
 555  */
 556 int
 557 TIFFGetMode(TIFF* tif)
 558 {
 559         return (tif->tif_mode);
 560 }
 561
 562 /*
 563  * Return read/write mode.
 564  */
 565 int
 566 TIFFSetMode(TIFF* tif, int mode)
 567 {
 568         int old_mode = tif->tif_mode;
 569         tif->tif_mode = mode;
 570         return (old_mode);
 571 }
 572
 573 /*
 574  * Return nonzero if file is organized in
 575  * tiles; zero if organized as strips.
 576  */
 577 int
 578 TIFFIsTiled(TIFF* tif)
 579 {
 580         return (isTiled(tif));
 581 }
 582
 583 /*
 584  * Return current row being read/written.
 585  */
 586 uint32
 587 TIFFCurrentRow(TIFF* tif)
 588 {
 589         return (tif->tif_row);
 590 }
 591
 592 /*
 593  * Return index of the current directory.
 594  */
 595 uint16
 596 TIFFCurrentDirectory(TIFF* tif)
 597 {
 598         return (tif->tif_curdir);
 599 }
 600
 601 /*
 602  * Return current strip.
 603  */
 604 uint32
 605 TIFFCurrentStrip(TIFF* tif)
 606 {
 607         return (tif->tif_curstrip);
 608 }
 609
 610 /*
 611  * Return current tile.
 612  */
 613 uint32
 614 TIFFCurrentTile(TIFF* tif)
 615 {
 616         return (tif->tif_curtile);
 617 }
 618
 619 /*
 620  * Return nonzero if the file has byte-swapped data.
 621  */
 622 int
 623 TIFFIsByteSwapped(TIFF* tif)
 624 {
 625         return ((tif->tif_flags & TIFF_SWAB) != 0);
 626 }
 627
 628 /*
 629  * Return nonzero if the data is returned up-sampled.
 630  */
 631 int
 632 TIFFIsUpSampled(TIFF* tif)
 633 {
 634         return (isUpSampled(tif));
 635 }
 636
 637 /*
 638  * Return nonzero if the data is returned in MSB-to-LSB bit order.
 639  */
 640 int
 641 TIFFIsMSB2LSB(TIFF* tif)
 642 {
 643         return (isFillOrder(tif, FILLORDER_MSB2LSB));
 644 }
 645
 646 /*
 647  * Return nonzero if given file was written in big-endian order.
 648  */
 649 int
 650 TIFFIsBigEndian(TIFF* tif)
 651 {
 652         return (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN);
 653 }
 654
 655 /*
 656  * Return pointer to file read method.
 657  */
 658 TIFFReadWriteProc
 659 TIFFGetReadProc(TIFF* tif)
 660 {
 661         return (tif->tif_readproc);
 662 }
 663
 664 /*
 665  * Return pointer to file write method.
 666  */
 667 TIFFReadWriteProc
 668 TIFFGetWriteProc(TIFF* tif)
 669 {
 670         return (tif->tif_writeproc);
 671 }
 672
 673 /*
 674  * Return pointer to file seek method.
 675  */
 676 TIFFSeekProc
 677 TIFFGetSeekProc(TIFF* tif)
 678 {
 679         return (tif->tif_seekproc);
 680 }
 681
 682 /*
 683  * Return pointer to file close method.
 684  */
 685 TIFFCloseProc
 686 TIFFGetCloseProc(TIFF* tif)
 687 {
 688         return (tif->tif_closeproc);
 689 }
 690
 691 /*
 692  * Return pointer to file size requesting method.
 693  */
 694 TIFFSizeProc
 695 TIFFGetSizeProc(TIFF* tif)
 696 {
 697         return (tif->tif_sizeproc);
 698 }
 699
 700 /*
 701  * Return pointer to memory mapping method.
 702  */
 703 TIFFMapFileProc
 704 TIFFGetMapFileProc(TIFF* tif)
 705 {
 706         return (tif->tif_mapproc);
 707 }
 708
 709 /*
 710  * Return pointer to memory unmapping method.
 711  */
 712 TIFFUnmapFileProc
 713 TIFFGetUnmapFileProc(TIFF* tif)
 714 {
 715         return (tif->tif_unmapproc);
 716 }
 717
 718 /* vim: set ts=8 sts=8 sw=8 noet: */
 719 /*
 720  * Local Variables:
 721  * mode: c
 722  * c-basic-offset: 8
 723  * fill-column: 78
 724  * End:
 725  */