home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / hensa / graphics / libtiff_1 / c / tif_read < prev    next >
Text File  |  1995-10-12  |  17KB  |  601 lines
  1. /* $Header: /usr/people/sam/tiff/libtiff/RCS/tif_read.c,v 1.69 1995/06/06 23:49:31 sam Exp $ */
  2.  
  3. /*
  4.  * Copyright (c) 1988-1995 Sam Leffler
  5.  * Copyright (c) 1991-1995 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.  * Scanline-oriented Read Support
  30.  */
  31. #include "tiffiop.h"
  32. #include <stdio.h>
  33. #include <assert.h>
  34.  
  35. static    int TIFFFillStrip(TIFF*, tstrip_t);
  36. static    int TIFFFillTile(TIFF*, ttile_t);
  37. static    int TIFFStartStrip(TIFF*, tstrip_t);
  38. static    int TIFFStartTile(TIFF*, ttile_t);
  39. static    int TIFFCheckRead(TIFF*, int);
  40.  
  41. #define    NOSTRIP    ((tstrip_t) -1)            /* undefined state */
  42. #define    NOTILE    ((ttile_t) -1)            /* undefined state */
  43.  
  44. /*
  45.  * Seek to a random row+sample in a file.
  46.  */
  47. static int
  48. TIFFSeek(TIFF* tif, uint32 row, tsample_t sample)
  49. {
  50.     register TIFFDirectory *td = &tif->tif_dir;
  51.     tstrip_t strip;
  52.  
  53.     if (row >= td->td_imagelength) {    /* out of range */
  54.         TIFFError(tif->tif_name, "%lu: Row out of range, max %lu",
  55.             (u_long) row, (u_long) td->td_imagelength);
  56.         return (0);
  57.     }
  58.     if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
  59.         if (sample >= td->td_samplesperpixel) {
  60.             TIFFError(tif->tif_name,
  61.                 "%lu: Sample out of range, max %lu",
  62.                 (u_long) sample, (u_long) td->td_samplesperpixel);
  63.             return (0);
  64.         }
  65.         strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip;
  66.     } else
  67.         strip = row / td->td_rowsperstrip;
  68.     if (strip != tif->tif_curstrip) {     /* different strip, refill */
  69.         if (!TIFFFillStrip(tif, strip))
  70.             return (0);
  71.     } else if (row < tif->tif_row) {
  72.         /*
  73.          * Moving backwards within the same strip: backup
  74.          * to the start and then decode forward (below).
  75.          *
  76.          * NB: If you're planning on lots of random access within a
  77.          * strip, it's better to just read and decode the entire
  78.          * strip, and then access the decoded data in a random fashion.
  79.          */
  80.         if (!TIFFStartStrip(tif, strip))
  81.             return (0);
  82.     }
  83.     if (row != tif->tif_row) {
  84.         /*
  85.          * Seek forward to the desired row.
  86.          */
  87.         if (!(*tif->tif_seek)(tif, row - tif->tif_row))
  88.             return (0);
  89.         tif->tif_row = row;
  90.     }
  91.     return (1);
  92. }
  93.  
  94. int
  95. TIFFReadScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
  96. {
  97.     int e;
  98.  
  99.     if (!TIFFCheckRead(tif, 0))
  100.         return (-1);
  101.     if (e = TIFFSeek(tif, row, sample)) {
  102.         /*
  103.          * Decompress desired row into user buffer.
  104.          */
  105.         e = (*tif->tif_decoderow)
  106.             (tif, (tidata_t) buf, tif->tif_scanlinesize, sample);
  107.         tif->tif_row++;
  108.         if (e)
  109.             (*tif->tif_postdecode)(tif, (tidata_t) buf,
  110.                 tif->tif_scanlinesize);
  111.     }
  112.     return (e ? 1 : -1);
  113. }
  114.  
  115. /*
  116.  * Read a strip of data and decompress the specified
  117.  * amount into the user-supplied buffer.
  118.  */
  119. tsize_t
  120. TIFFReadEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
  121. {
  122.     TIFFDirectory *td = &tif->tif_dir;
  123.     uint32 nrows;
  124.     tsize_t stripsize;
  125.  
  126.     if (!TIFFCheckRead(tif, 0))
  127.         return (-1);
  128.     if (strip >= td->td_nstrips) {
  129.         TIFFError(tif->tif_name, "%ld: Strip out of range, max %ld",
  130.             (long) strip, (long) td->td_nstrips);
  131.         return (-1);
  132.     }
  133.     /*
  134.      * Calculate the strip size according to the number of
  135.      * rows in the strip (check for truncated last strip).
  136.      */
  137.     if (strip != td->td_nstrips-1 ||
  138.         (nrows = td->td_imagelength % td->td_rowsperstrip) == 0)
  139.         nrows = td->td_rowsperstrip;
  140.     stripsize = TIFFVStripSize(tif, nrows);
  141.     if (size == (tsize_t) -1)
  142.         size = stripsize;
  143.     else if (size > stripsize)
  144.         size = stripsize;
  145.     if (TIFFFillStrip(tif, strip) && (*tif->tif_decodestrip)(tif,
  146.         (tidata_t) buf, size, (tsample_t)(strip / td->td_stripsperimage))) {
  147.         (*tif->tif_postdecode)(tif, (tidata_t) buf, size);
  148.         return (size);
  149.     } else
  150.         return ((tsize_t) -1);
  151. }
  152.  
  153. static tsize_t
  154. TIFFReadRawStrip1(TIFF* tif,
  155.     tstrip_t strip, tdata_t buf, tsize_t size, const char* module)
  156. {
  157.     TIFFDirectory *td = &tif->tif_dir;
  158.  
  159.     if (!isMapped(tif)) {
  160.         if (!SeekOK(tif, td->td_stripoffset[strip])) {
  161.             TIFFError(module,
  162.                 "%s: Seek error at scanline %lu, strip %lu",
  163.                 tif->tif_name,
  164.                 (u_long) tif->tif_row, (u_long) strip);
  165.             return (-1);
  166.         }
  167.         if (!ReadOK(tif, buf, size)) {
  168.             TIFFError(module, "%s: Read error at scanline %lu",
  169.                 tif->tif_name, (u_long) tif->tif_row);
  170.             return (-1);
  171.         }
  172.     } else {
  173.         if (td->td_stripoffset[strip] + size > tif->tif_size) {
  174.             TIFFError(module,
  175.                 "%s: Seek error at scanline %lu, strip %lu",
  176.                 tif->tif_name,
  177.                 (u_long) tif->tif_row, (u_long) strip);
  178.             return (-1);
  179.         }
  180.         _TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[strip], size);
  181.     }
  182.     return (size);
  183. }
  184.  
  185. /*
  186.  * Read a strip of data from the file.
  187.  */
  188. tsize_t
  189. TIFFReadRawStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
  190. {
  191.     static const char module[] = "TIFFReadRawStrip";
  192.     TIFFDirectory *td = &tif->tif_dir;
  193.     tsize_t bytecount;
  194.  
  195.     if (!TIFFCheckRead(tif, 0))
  196.         return ((tsize_t) -1);
  197.     if (strip >= td->td_nstrips) {
  198.         TIFFError(tif->tif_name, "%lu: Strip out of range, max %lu",
  199.             (u_long) strip, (u_long) td->td_nstrips);
  200.         return ((tsize_t) -1);
  201.     }
  202.     bytecount = td->td_stripbytecount[strip];
  203.     if (bytecount <= 0) {
  204.         TIFFError(tif->tif_name,
  205.             "%lu: Invalid strip byte count, strip %lu",
  206.             (u_long) bytecount, (u_long) strip);
  207.         return ((tsize_t) -1);
  208.     }
  209.     if (size != (tsize_t)-1 && size < bytecount)
  210.         bytecount = size;
  211.     return (TIFFReadRawStrip1(tif, strip, buf, bytecount, module));
  212. }
  213.  
  214. /*
  215.  * Read the specified strip and setup for decoding. 
  216.  * The data buffer is expanded, as necessary, to
  217.  * hold the strip's data.
  218.  */
  219. static int
  220. TIFFFillStrip(TIFF* tif, tstrip_t strip)
  221. {
  222.     static const char module[] = "TIFFFillStrip";
  223.     TIFFDirectory *td = &tif->tif_dir;
  224.     tsize_t bytecount;
  225.  
  226.     bytecount = td->td_stripbytecount[strip];
  227.     if (bytecount <= 0) {
  228.         TIFFError(tif->tif_name,
  229.             "%lu: Invalid strip byte count, strip %lu",
  230.             (u_long) bytecount, (u_long) strip);
  231.         return (0);
  232.     }
  233.     if (isMapped(tif) &&
  234.         (isFillOrder(tif, td->td_fillorder) || (tif->tif_flags & TIFF_NOBITREV))) {
  235.         /*
  236.          * The image is mapped into memory and we either don't
  237.          * need to flip bits or the compression routine is going
  238.          * to handle this operation itself.  In this case, avoid
  239.          * copying the raw data and instead just reference the
  240.          * data from the memory mapped file image.  This assumes
  241.          * that the decompression routines do not modify the
  242.          * contents of the raw data buffer (if they try to,
  243.          * the application will get a fault since the file is
  244.          * mapped read-only).
  245.          */
  246.         if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
  247.             _TIFFfree(tif->tif_rawdata);
  248.         tif->tif_flags &= ~TIFF_MYBUFFER;
  249.         if (td->td_stripoffset[strip] + bytecount > tif->tif_size) {
  250.             /*
  251.              * This error message might seem strange, but it's
  252.              * what would happen if a read were done instead.
  253.              */
  254.             TIFFError(module, "%s: Read error on strip %lu",
  255.                 tif->tif_name, (u_long) strip);
  256.             tif->tif_curstrip = NOSTRIP;
  257.             return (0);
  258.         }
  259.         tif->tif_rawdatasize = bytecount;
  260.         tif->tif_rawdata = tif->tif_base + td->td_stripoffset[strip];
  261.     } else {
  262.         /*
  263.          * Expand raw data buffer, if needed, to
  264.          * hold data strip coming from file
  265.          * (perhaps should set upper bound on
  266.          *  the size of a buffer we'll use?).
  267.          */
  268.         if (bytecount > tif->tif_rawdatasize) {
  269.             tif->tif_curstrip = NOSTRIP;
  270.             if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
  271.                 TIFFError(module,
  272.                 "%s: Data buffer too small to hold strip %lu",
  273.                     tif->tif_name, (u_long) strip);
  274.                 return (0);
  275.             }
  276.             if (!TIFFReadBufferSetup(tif, 0,
  277.                 TIFFroundup(bytecount, 1024)))
  278.                 return (0);
  279.         }
  280.         if (TIFFReadRawStrip1(tif, strip, (u_char *)tif->tif_rawdata,
  281.             bytecount, module) != bytecount)
  282.             return (0);
  283.         if (!isFillOrder(tif, td->td_fillorder) &&
  284.             (tif->tif_flags & TIFF_NOBITREV) == 0)
  285.             TIFFReverseBits(tif->tif_rawdata, bytecount);
  286.     }
  287.     return (TIFFStartStrip(tif, strip));
  288. }
  289.  
  290. /*
  291.  * Tile-oriented Read Support
  292.  * Contributed by Nancy Cam (Silicon Graphics).
  293.  */
  294.  
  295. /*
  296.  * Read and decompress a tile of data.  The
  297.  * tile is selected by the (x,y,z,s) coordinates.
  298.  */
  299. tsize_t
  300. TIFFReadTile(TIFF* tif,
  301.     tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
  302. {
  303.     if (!TIFFCheckRead(tif, 1) || !TIFFCheckTile(tif, x, y, z, s))
  304.         return (-1);
  305.     return (TIFFReadEncodedTile(tif,
  306.         TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1));
  307. }
  308.  
  309. /*
  310.  * Read a tile of data and decompress the specified
  311.  * amount into the user-supplied buffer.
  312.  */
  313. tsize_t
  314. TIFFReadEncodedTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
  315. {
  316.     TIFFDirectory *td = &tif->tif_dir;
  317.     tsize_t tilesize = tif->tif_tilesize;
  318.  
  319.     if (!TIFFCheckRead(tif, 1))
  320.         return (-1);
  321.     if (tile >= td->td_nstrips) {
  322.         TIFFError(tif->tif_name, "%ld: Tile out of range, max %ld",
  323.             (long) tile, (u_long) td->td_nstrips);
  324.         return (-1);
  325.     }
  326.     if (size == (tsize_t) -1)
  327.         size = tilesize;
  328.     else if (size > tilesize)
  329.         size = tilesize;
  330.     if (TIFFFillTile(tif, tile) && (*tif->tif_decodetile)(tif,
  331.         (tidata_t) buf, size, (tsample_t)(tile/td->td_stripsperimage))) {
  332.         (*tif->tif_postdecode)(tif, (tidata_t) buf, size);
  333.         return (size);
  334.     } else
  335.         return (-1);
  336. }
  337.  
  338. static tsize_t
  339. TIFFReadRawTile1(TIFF* tif,
  340.     ttile_t tile, tdata_t buf, tsize_t size, const char* module)
  341. {
  342.     TIFFDirectory *td = &tif->tif_dir;
  343.  
  344.     if (!isMapped(tif)) {
  345.         if (!SeekOK(tif, td->td_stripoffset[tile])) {
  346.             TIFFError(module,
  347.                 "%s: Seek error at row %ld, col %ld, tile %ld",
  348.                 tif->tif_name,
  349.                 (long) tif->tif_row,
  350.                 (long) tif->tif_col,
  351.                 (long) tile);
  352.             return ((tsize_t) -1);
  353.         }
  354.         if (!ReadOK(tif, buf, size)) {
  355.             TIFFError(module, "%s: Read error at row %ld, col %ld",
  356.                 tif->tif_name,
  357.                 (long) tif->tif_row,
  358.                 (long) tif->tif_col);
  359.             return ((tsize_t) -1);
  360.         }
  361.     } else {
  362.         if (td->td_stripoffset[tile] + size > tif->tif_size) {
  363.             TIFFError(module,
  364.                 "%s: Seek error at row %ld, col %ld, tile %ld",
  365.                 tif->tif_name,
  366.                 (long) tif->tif_row,
  367.                 (long) tif->tif_col,
  368.                 (long) tile);
  369.             return ((tsize_t) -1);
  370.         }
  371.         _TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[tile], size);
  372.     }
  373.     return (size);
  374. }
  375.  
  376. /*
  377.  * Read a tile of data from the file.
  378.  */
  379. tsize_t
  380. TIFFReadRawTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
  381. {
  382.     static const char module[] = "TIFFReadRawTile";
  383.     TIFFDirectory *td = &tif->tif_dir;
  384.     tsize_t bytecount;
  385.  
  386.     if (!TIFFCheckRead(tif, 1))
  387.         return ((tsize_t) -1);
  388.     if (tile >= td->td_nstrips) {
  389.         TIFFError(tif->tif_name, "%lu: Tile out of range, max %lu",
  390.             (u_long) tile, (u_long) td->td_nstrips);
  391.         return ((tsize_t) -1);
  392.     }
  393.     bytecount = td->td_stripbytecount[tile];
  394.     if (size != (tsize_t) -1 && size < bytecount)
  395.         bytecount = size;
  396.     return (TIFFReadRawTile1(tif, tile, buf, bytecount, module));
  397. }
  398.  
  399. /*
  400.  * Read the specified tile and setup for decoding. 
  401.  * The data buffer is expanded, as necessary, to
  402.  * hold the tile's data.
  403.  */
  404. static int
  405. TIFFFillTile(TIFF* tif, ttile_t tile)
  406. {
  407.     static const char module[] = "TIFFFillTile";
  408.     TIFFDirectory *td = &tif->tif_dir;
  409.     tsize_t bytecount;
  410.  
  411.     bytecount = td->td_stripbytecount[tile];
  412.     if (bytecount <= 0) {
  413.         TIFFError(tif->tif_name,
  414.             "%lu: Invalid tile byte count, tile %lu",
  415.             (u_long) bytecount, (u_long) tile);
  416.         return (0);
  417.     }
  418.     if (isMapped(tif) &&
  419.         (isFillOrder(tif, td->td_fillorder) || (tif->tif_flags & TIFF_NOBITREV))) {
  420.         /*
  421.          * The image is mapped into memory and we either don't
  422.          * need to flip bits or the compression routine is going
  423.          * to handle this operation itself.  In this case, avoid
  424.          * copying the raw data and instead just reference the
  425.          * data from the memory mapped file image.  This assumes
  426.          * that the decompression routines do not modify the
  427.          * contents of the raw data buffer (if they try to,
  428.          * the application will get a fault since the file is
  429.          * mapped read-only).
  430.          */
  431.         if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
  432.             _TIFFfree(tif->tif_rawdata);
  433.         tif->tif_flags &= ~TIFF_MYBUFFER;
  434.         if (td->td_stripoffset[tile] + bytecount > tif->tif_size) {
  435.             tif->tif_curtile = NOTILE;
  436.             return (0);
  437.         }
  438.         tif->tif_rawdatasize = bytecount;
  439.         tif->tif_rawdata = tif->tif_base + td->td_stripoffset[tile];
  440.     } else {
  441.         /*
  442.          * Expand raw data buffer, if needed, to
  443.          * hold data tile coming from file
  444.          * (perhaps should set upper bound on
  445.          *  the size of a buffer we'll use?).
  446.          */
  447.         if (bytecount > tif->tif_rawdatasize) {
  448.             tif->tif_curtile = NOTILE;
  449.             if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
  450.                 TIFFError(module,
  451.                 "%s: Data buffer too small to hold tile %ld",
  452.                     tif->tif_name, (long) tile);
  453.                 return (0);
  454.             }
  455.             if (!TIFFReadBufferSetup(tif, 0,
  456.                 TIFFroundup(bytecount, 1024)))
  457.                 return (0);
  458.         }
  459.         if (TIFFReadRawTile1(tif, tile, (u_char *)tif->tif_rawdata,
  460.             bytecount, module) != bytecount)
  461.             return (0);
  462.         if (!isFillOrder(tif, td->td_fillorder) &&
  463.             (tif->tif_flags & TIFF_NOBITREV) == 0)
  464.             TIFFReverseBits(tif->tif_rawdata, bytecount);
  465.     }
  466.     return (TIFFStartTile(tif, tile));
  467. }
  468.  
  469. /*
  470.  * Setup the raw data buffer in preparation for
  471.  * reading a strip of raw data.  If the buffer
  472.  * is specified as zero, then a buffer of appropriate
  473.  * size is allocated by the library.  Otherwise,
  474.  * the client must guarantee that the buffer is
  475.  * large enough to hold any individual strip of
  476.  * raw data.
  477.  */
  478. int
  479. TIFFReadBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
  480. {
  481.     static const char module[] = "TIFFReadBufferSetup";
  482.  
  483.     if (tif->tif_rawdata) {
  484.         if (tif->tif_flags & TIFF_MYBUFFER)
  485.             _TIFFfree(tif->tif_rawdata);
  486.         tif->tif_rawdata = NULL;
  487.     }
  488.     if (bp) {
  489.         tif->tif_rawdatasize = size;
  490.         tif->tif_rawdata = (tidata_t) bp;
  491.         tif->tif_flags &= ~TIFF_MYBUFFER;
  492.     } else {
  493.         tif->tif_rawdatasize = TIFFroundup(size, 1024);
  494.         tif->tif_rawdata = (tidata_t) _TIFFmalloc(tif->tif_rawdatasize);
  495.         tif->tif_flags |= TIFF_MYBUFFER;
  496.     }
  497.     if (tif->tif_rawdata == NULL) {
  498.         TIFFError(module,
  499.             "%s: No space for data buffer at scanline %ld",
  500.             tif->tif_name, (long) tif->tif_row);
  501.         tif->tif_rawdatasize = 0;
  502.         return (0);
  503.     }
  504.     return (1);
  505. }
  506.  
  507. /*
  508.  * Set state to appear as if a
  509.  * strip has just been read in.
  510.  */
  511. static int
  512. TIFFStartStrip(TIFF* tif, tstrip_t strip)
  513. {
  514.     TIFFDirectory *td = &tif->tif_dir;
  515.  
  516.     if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
  517.         if (!(*tif->tif_setupdecode)(tif))
  518.             return (0);
  519.         tif->tif_flags |= TIFF_CODERSETUP;
  520.     }
  521.     tif->tif_curstrip = strip;
  522.     tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
  523.     tif->tif_rawcp = tif->tif_rawdata;
  524.     tif->tif_rawcc = td->td_stripbytecount[strip];
  525.     return ((*tif->tif_predecode)(tif,
  526.             (tsample_t)(strip / td->td_stripsperimage)));
  527. }
  528.  
  529. /*
  530.  * Set state to appear as if a
  531.  * tile has just been read in.
  532.  */
  533. static int
  534. TIFFStartTile(TIFF* tif, ttile_t tile)
  535. {
  536.     TIFFDirectory *td = &tif->tif_dir;
  537.  
  538.     if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
  539.         if (!(*tif->tif_setupdecode)(tif))
  540.             return (0);
  541.         tif->tif_flags |= TIFF_CODERSETUP;
  542.     }
  543.     tif->tif_curtile = tile;
  544.     tif->tif_row =
  545.         (tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth)) *
  546.         td->td_tilelength;
  547.     tif->tif_col =
  548.         (tile % TIFFhowmany(td->td_imagelength, td->td_tilelength)) *
  549.         td->td_tilewidth;
  550.     tif->tif_rawcp = tif->tif_rawdata;
  551.     tif->tif_rawcc = td->td_stripbytecount[tile];
  552.     return ((*tif->tif_predecode)(tif,
  553.             (tsample_t)(tile/td->td_stripsperimage)));
  554. }
  555.  
  556. static int
  557. TIFFCheckRead(TIFF* tif, int tiles)
  558. {
  559.     if (tif->tif_mode == O_WRONLY) {
  560.         TIFFError(tif->tif_name, "File not open for reading");
  561.         return (0);
  562.     }
  563.     if (tiles ^ isTiled(tif)) {
  564.         TIFFError(tif->tif_name, tiles ?
  565.             "Can not read tiles from a stripped image" :
  566.             "Can not read scanlines from a tiled image");
  567.         return (0);
  568.     }
  569.     return (1);
  570. }
  571.  
  572. void
  573. _TIFFNoPostDecode(TIFF* tif, tidata_t buf, tsize_t cc)
  574. {
  575.     (void) tif; (void) buf; (void) cc;
  576. }
  577.  
  578. void
  579. _TIFFSwab16BitData(TIFF* tif, tidata_t buf, tsize_t cc)
  580. {
  581.     (void) tif;
  582.     assert((cc & 1) == 0);
  583.     TIFFSwabArrayOfShort((uint16*) buf, cc/2);
  584. }
  585.  
  586. void
  587. _TIFFSwab32BitData(TIFF* tif, tidata_t buf, tsize_t cc)
  588. {
  589.     (void) tif;
  590.     assert((cc & 3) == 0);
  591.     TIFFSwabArrayOfLong((uint32*) buf, cc/4);
  592. }
  593.  
  594. void
  595. _TIFFSwab64BitData(TIFF* tif, tidata_t buf, tsize_t cc)
  596. {
  597.     (void) tif;
  598.     assert((cc & 7) == 0);
  599.     TIFFSwabArrayOfDouble((double*) buf, cc/8);
  600. }
  601.