reactos/dll/3rdparty/libtiff/tif_open.c

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