ReactOS  0.4.15-dev-448-gd6c4411
tif_read.c File Reference
#include <precomp.h>
Include dependency graph for tif_read.c:

Go to the source code of this file.

Macros

#define NOSTRIP   ((uint32)(-1)) /* undefined state */
 
#define NOTILE   ((uint32)(-1)) /* undefined state */
 
#define INITIAL_THRESHOLD   (1024 * 1024)
 
#define THRESHOLD_MULTIPLIER   10
 
#define MAX_THRESHOLD   (THRESHOLD_MULTIPLIER * THRESHOLD_MULTIPLIER * THRESHOLD_MULTIPLIER * INITIAL_THRESHOLD)
 
#define TIFF_INT64_MAX   ((((int64)0x7FFFFFFF) << 32) | 0xFFFFFFFF)
 

Functions

int TIFFFillStrip (TIFF *tif, uint32 strip)
 
int TIFFFillTile (TIFF *tif, uint32 tile)
 
static int TIFFStartStrip (TIFF *tif, uint32 strip)
 
static int TIFFStartTile (TIFF *tif, uint32 tile)
 
static int TIFFCheckRead (TIFF *, int)
 
static tmsize_t TIFFReadRawStrip1 (TIFF *tif, uint32 strip, void *buf, tmsize_t size, const char *module)
 
static tmsize_t TIFFReadRawTile1 (TIFF *tif, uint32 tile, void *buf, tmsize_t size, const char *module)
 
static int TIFFReadAndRealloc (TIFF *tif, tmsize_t size, tmsize_t rawdata_offset, int is_strip, uint32 strip_or_tile, const char *module)
 
static int TIFFFillStripPartial (TIFF *tif, int strip, tmsize_t read_ahead, int restart)
 
static int TIFFSeek (TIFF *tif, uint32 row, uint16 sample)
 
int TIFFReadScanline (TIFF *tif, void *buf, uint32 row, uint16 sample)
 
static tmsize_t TIFFReadEncodedStripGetStripSize (TIFF *tif, uint32 strip, uint16 *pplane)
 
tmsize_t TIFFReadEncodedStrip (TIFF *tif, uint32 strip, void *buf, tmsize_t size)
 
tmsize_t _TIFFReadEncodedStripAndAllocBuffer (TIFF *tif, uint32 strip, void **buf, tmsize_t bufsizetoalloc, tmsize_t size_to_read)
 
static tmsize_t TIFFReadRawStripOrTile2 (TIFF *tif, uint32 strip_or_tile, int is_strip, tmsize_t size, const char *module)
 
tmsize_t TIFFReadRawStrip (TIFF *tif, uint32 strip, void *buf, tmsize_t size)
 
static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW uint64 NoSantizeSubUInt64 (uint64 a, uint64 b)
 
tmsize_t TIFFReadTile (TIFF *tif, void *buf, uint32 x, uint32 y, uint32 z, uint16 s)
 
tmsize_t TIFFReadEncodedTile (TIFF *tif, uint32 tile, void *buf, tmsize_t size)
 
tmsize_t _TIFFReadTileAndAllocBuffer (TIFF *tif, void **buf, tmsize_t bufsizetoalloc, uint32 x, uint32 y, uint32 z, uint16 s)
 
tmsize_t _TIFFReadEncodedTileAndAllocBuffer (TIFF *tif, uint32 tile, void **buf, tmsize_t bufsizetoalloc, tmsize_t size_to_read)
 
tmsize_t TIFFReadRawTile (TIFF *tif, uint32 tile, void *buf, tmsize_t size)
 
int TIFFReadBufferSetup (TIFF *tif, void *bp, tmsize_t size)
 
int TIFFReadFromUserBuffer (TIFF *tif, uint32 strile, void *inbuf, tmsize_t insize, void *outbuf, tmsize_t outsize)
 
void _TIFFNoPostDecode (TIFF *tif, uint8 *buf, tmsize_t cc)
 
void _TIFFSwab16BitData (TIFF *tif, uint8 *buf, tmsize_t cc)
 
void _TIFFSwab24BitData (TIFF *tif, uint8 *buf, tmsize_t cc)
 
void _TIFFSwab32BitData (TIFF *tif, uint8 *buf, tmsize_t cc)
 
void _TIFFSwab64BitData (TIFF *tif, uint8 *buf, tmsize_t cc)
 

Macro Definition Documentation

◆ INITIAL_THRESHOLD

#define INITIAL_THRESHOLD   (1024 * 1024)

Definition at line 45 of file tif_read.c.

◆ MAX_THRESHOLD

Definition at line 47 of file tif_read.c.

◆ NOSTRIP

#define NOSTRIP   ((uint32)(-1)) /* undefined state */

Definition at line 42 of file tif_read.c.

◆ NOTILE

#define NOTILE   ((uint32)(-1)) /* undefined state */

Definition at line 43 of file tif_read.c.

◆ THRESHOLD_MULTIPLIER

#define THRESHOLD_MULTIPLIER   10

Definition at line 46 of file tif_read.c.

◆ TIFF_INT64_MAX

#define TIFF_INT64_MAX   ((((int64)0x7FFFFFFF) << 32) | 0xFFFFFFFF)

Definition at line 49 of file tif_read.c.

Function Documentation

◆ _TIFFNoPostDecode()

void _TIFFNoPostDecode ( TIFF tif,
uint8 buf,
tmsize_t  cc 
)

Definition at line 1603 of file tif_read.c.

1604 {
1605  (void) tif; (void) buf; (void) cc;
1606 }
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
uint32_t cc
Definition: isohybrid.c:75

Referenced by _TIFFVSetField(), PredictorSetupDecode(), PredictorSetupEncode(), and TIFFDefaultDirectory().

◆ _TIFFReadEncodedStripAndAllocBuffer()

tmsize_t _TIFFReadEncodedStripAndAllocBuffer ( TIFF tif,
uint32  strip,
void **  buf,
tmsize_t  bufsizetoalloc,
tmsize_t  size_to_read 
)

Definition at line 572 of file tif_read.c.

575 {
576  tmsize_t this_stripsize;
577  uint16 plane;
578 
579  if( *buf != NULL )
580  {
581  return TIFFReadEncodedStrip(tif, strip, *buf, size_to_read);
582  }
583 
584  this_stripsize=TIFFReadEncodedStripGetStripSize(tif, strip, &plane);
585  if (this_stripsize==((tmsize_t)(-1)))
586  return((tmsize_t)(-1));
587 
588  if ((size_to_read!=(tmsize_t)(-1))&&(size_to_read<this_stripsize))
589  this_stripsize=size_to_read;
590  if (!TIFFFillStrip(tif,strip))
591  return((tmsize_t)(-1));
592 
593  *buf = _TIFFmalloc(bufsizetoalloc);
594  if (*buf == NULL) {
595  TIFFErrorExt(tif->tif_clientdata, TIFFFileName(tif), "No space for strip buffer");
596  return((tmsize_t)(-1));
597  }
598  _TIFFmemset(*buf, 0, bufsizetoalloc);
599 
600  if ((*tif->tif_decodestrip)(tif,*buf,this_stripsize,plane)<=0)
601  return((tmsize_t)(-1));
602  (*tif->tif_postdecode)(tif,*buf,this_stripsize);
603  return(this_stripsize);
604 
605 
606 }
void _TIFFmemset(void *p, int v, tmsize_t c)
Definition: tif_unix.c:338
static tmsize_t TIFFReadEncodedStripGetStripSize(TIFF *tif, uint32 strip, uint16 *pplane)
Definition: tif_read.c:488
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint GLenum GLenum GLenum GLint GLuint GLenum GLenum GLfloat GLenum GLfloat GLenum GLint const GLfloat GLenum GLint const GLushort GLint GLint GLsizei GLsizei GLenum GLsizei GLsizei GLenum GLenum const GLvoid GLenum plane
Definition: glfuncs.h:270
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
thandle_t tif_clientdata
Definition: tiffiop.h:207
int TIFFFillStrip(TIFF *tif, uint32 strip)
Definition: tif_read.c:766
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
smooth NULL
Definition: ftsmooth.c:416
TIFFCodeMethod tif_decodestrip
Definition: tiffiop.h:182
void * _TIFFmalloc(tmsize_t s)
Definition: tif_unix.c:309
TIFFPostMethod tif_postdecode
Definition: tiffiop.h:214
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t TIFFReadEncodedStrip(TIFF *tif, uint32 strip, void *buf, tmsize_t size)
Definition: tif_read.c:527
unsigned short uint16
Definition: types.h:30
const char * TIFFFileName(TIFF *tif)
Definition: tif_open.c:513

Referenced by gtStripContig(), and gtStripSeparate().

◆ _TIFFReadEncodedTileAndAllocBuffer()

tmsize_t _TIFFReadEncodedTileAndAllocBuffer ( TIFF tif,
uint32  tile,
void **  buf,
tmsize_t  bufsizetoalloc,
tmsize_t  size_to_read 
)

Definition at line 1048 of file tif_read.c.

1051 {
1052  static const char module[] = "_TIFFReadEncodedTileAndAllocBuffer";
1053  TIFFDirectory *td = &tif->tif_dir;
1054  tmsize_t tilesize = tif->tif_tilesize;
1055 
1056  if( *buf != NULL )
1057  {
1058  return TIFFReadEncodedTile(tif, tile, *buf, size_to_read);
1059  }
1060 
1061  if (!TIFFCheckRead(tif, 1))
1062  return ((tmsize_t)(-1));
1063  if (tile >= td->td_nstrips) {
1065  "%lu: Tile out of range, max %lu",
1066  (unsigned long) tile, (unsigned long) td->td_nstrips);
1067  return ((tmsize_t)(-1));
1068  }
1069 
1070  if (!TIFFFillTile(tif,tile))
1071  return((tmsize_t)(-1));
1072 
1073  *buf = _TIFFmalloc(bufsizetoalloc);
1074  if (*buf == NULL) {
1076  "No space for tile buffer");
1077  return((tmsize_t)(-1));
1078  }
1079  _TIFFmemset(*buf, 0, bufsizetoalloc);
1080 
1081  if (size_to_read == (tmsize_t)(-1))
1082  size_to_read = tilesize;
1083  else if (size_to_read > tilesize)
1084  size_to_read = tilesize;
1085  if( (*tif->tif_decodetile)(tif,
1086  (uint8*) *buf, size_to_read, (uint16)(tile/td->td_stripsperimage))) {
1087  (*tif->tif_postdecode)(tif, (uint8*) *buf, size_to_read);
1088  return (size_to_read);
1089  } else
1090  return ((tmsize_t)(-1));
1091 }
void _TIFFmemset(void *p, int v, tmsize_t c)
Definition: tif_unix.c:338
int TIFFFillTile(TIFF *tif, uint32 tile)
Definition: tif_read.c:1204
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
tmsize_t TIFFReadEncodedTile(TIFF *tif, uint32 tile, void *buf, tmsize_t size)
Definition: tif_read.c:978
thandle_t tif_clientdata
Definition: tiffiop.h:207
tmsize_t tif_tilesize
Definition: tiffiop.h:170
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 td_stripsperimage
Definition: tif_dir.h:99
smooth NULL
Definition: ftsmooth.c:416
void * _TIFFmalloc(tmsize_t s)
Definition: tif_unix.c:309
uint32 td_nstrips
Definition: tif_dir.h:100
TIFFPostMethod tif_postdecode
Definition: tiffiop.h:214
unsigned char uint8
Definition: types.h:28
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
TIFFCodeMethod tif_decodetile
Definition: tiffiop.h:184
unsigned short uint16
Definition: types.h:30
TIFFDirectory tif_dir
Definition: tiffiop.h:151
const char * TIFFFileName(TIFF *tif)
Definition: tif_open.c:513
static int TIFFCheckRead(TIFF *, int)
Definition: tif_read.c:1500

Referenced by _TIFFReadTileAndAllocBuffer().

◆ _TIFFReadTileAndAllocBuffer()

tmsize_t _TIFFReadTileAndAllocBuffer ( TIFF tif,
void **  buf,
tmsize_t  bufsizetoalloc,
uint32  x,
uint32  y,
uint32  z,
uint16  s 
)

Definition at line 1029 of file tif_read.c.

1032 {
1033  if (!TIFFCheckRead(tif, 1) || !TIFFCheckTile(tif, x, y, z, s))
1034  return ((tmsize_t)(-1));
1036  TIFFComputeTile(tif, x, y, z, s),
1037  buf, bufsizetoalloc,
1038  (tmsize_t)(-1)));
1039 }
int TIFFCheckTile(TIFF *tif, uint32 x, uint32 y, uint32 z, uint16 s)
Definition: tif_tile.c:73
uint32 TIFFComputeTile(TIFF *tif, uint32 x, uint32 y, uint32 z, uint16 s)
Definition: tif_tile.c:36
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
GLdouble GLdouble z
Definition: glext.h:5874
GLdouble s
Definition: gl.h:2039
tmsize_t _TIFFReadEncodedTileAndAllocBuffer(TIFF *tif, uint32 tile, void **buf, tmsize_t bufsizetoalloc, tmsize_t size_to_read)
Definition: tif_read.c:1048
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
static int TIFFCheckRead(TIFF *, int)
Definition: tif_read.c:1500

Referenced by gtTileContig(), and gtTileSeparate().

◆ _TIFFSwab16BitData()

void _TIFFSwab16BitData ( TIFF tif,
uint8 buf,
tmsize_t  cc 
)

Definition at line 1609 of file tif_read.c.

1610 {
1611  (void) tif;
1612  assert((cc & 1) == 0);
1614 }
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
void TIFFSwabArrayOfShort(register uint16 *wp, tmsize_t n)
Definition: tif_swab.c:71
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define assert(x)
Definition: debug.h:53
uint32_t cc
Definition: isohybrid.c:75
unsigned short uint16
Definition: types.h:30

Referenced by _TIFFVSetField().

◆ _TIFFSwab24BitData()

void _TIFFSwab24BitData ( TIFF tif,
uint8 buf,
tmsize_t  cc 
)

Definition at line 1617 of file tif_read.c.

1618 {
1619  (void) tif;
1620  assert((cc % 3) == 0);
1622 }
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define assert(x)
Definition: debug.h:53
unsigned char uint8
Definition: types.h:28
uint32_t cc
Definition: isohybrid.c:75
void TIFFSwabArrayOfTriples(register uint8 *tp, tmsize_t n)
Definition: tif_swab.c:87

Referenced by _TIFFVSetField().

◆ _TIFFSwab32BitData()

void _TIFFSwab32BitData ( TIFF tif,
uint8 buf,
tmsize_t  cc 
)

Definition at line 1625 of file tif_read.c.

1626 {
1627  (void) tif;
1628  assert((cc & 3) == 0);
1630 }
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
unsigned int uint32
Definition: types.h:32
#define assert(x)
Definition: debug.h:53
void TIFFSwabArrayOfLong(register uint32 *lp, tmsize_t n)
Definition: tif_swab.c:103
uint32_t cc
Definition: isohybrid.c:75

Referenced by _TIFFVSetField().

◆ _TIFFSwab64BitData()

void _TIFFSwab64BitData ( TIFF tif,
uint8 buf,
tmsize_t  cc 
)

Definition at line 1633 of file tif_read.c.

1634 {
1635  (void) tif;
1636  assert((cc & 7) == 0);
1637  TIFFSwabArrayOfDouble((double*) buf, cc/8);
1638 }
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define assert(x)
Definition: debug.h:53
uint32_t cc
Definition: isohybrid.c:75
void TIFFSwabArrayOfDouble(double *dp, tmsize_t n)
Definition: tif_swab.c:182

Referenced by _TIFFVSetField().

◆ NoSantizeSubUInt64()

static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW uint64 NoSantizeSubUInt64 ( uint64  a,
uint64  b 
)
static

Definition at line 756 of file tif_read.c.

757 {
758  return a - b;
759 }
#define b
Definition: ke_i.h:79
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204

Referenced by TIFFFillStrip().

◆ TIFFCheckRead()

static int TIFFCheckRead ( TIFF tif,
int  tiles 
)
static

Definition at line 1500 of file tif_read.c.

1501 {
1502  if (tif->tif_mode == O_WRONLY) {
1503  TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "File not open for reading");
1504  return (0);
1505  }
1506  if (tiles ^ isTiled(tif)) {
1507  TIFFErrorExt(tif->tif_clientdata, tif->tif_name, tiles ?
1508  "Can not read tiles from a striped image" :
1509  "Can not read scanlines from a tiled image");
1510  return (0);
1511  }
1512  return (1);
1513 }
thandle_t tif_clientdata
Definition: tiffiop.h:207
char * tif_name
Definition: tiffiop.h:116
#define O_WRONLY
Definition: acwin.h:111
int tif_mode
Definition: tiffiop.h:118
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
#define isTiled(tif)
Definition: tiffiop.h:229

Referenced by _TIFFReadEncodedTileAndAllocBuffer(), _TIFFReadTileAndAllocBuffer(), TIFFReadEncodedStripGetStripSize(), TIFFReadEncodedTile(), TIFFReadRawStrip(), TIFFReadRawTile(), TIFFReadScanline(), and TIFFReadTile().

◆ TIFFFillStrip()

int TIFFFillStrip ( TIFF tif,
uint32  strip 
)

Definition at line 766 of file tif_read.c.

767 {
768  static const char module[] = "TIFFFillStrip";
769  TIFFDirectory *td = &tif->tif_dir;
770 
771  if ((tif->tif_flags&TIFF_NOREADRAW)==0)
772  {
773  uint64 bytecount = TIFFGetStrileByteCount(tif, strip);
774  if( bytecount == 0 || bytecount > (uint64)TIFF_INT64_MAX ) {
775 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
777  "Invalid strip byte count %I64u, strip %lu",
778  (unsigned __int64) bytecount,
779  (unsigned long) strip);
780 #else
782  "Invalid strip byte count %llu, strip %lu",
783  (unsigned long long) bytecount,
784  (unsigned long) strip);
785 #endif
786  return (0);
787  }
788 
789  /* To avoid excessive memory allocations: */
790  /* Byte count should normally not be larger than a number of */
791  /* times the uncompressed size plus some margin */
792  if( bytecount > 1024 * 1024 )
793  {
794  /* 10 and 4096 are just values that could be adjusted. */
795  /* Hopefully they are safe enough for all codecs */
796  tmsize_t stripsize = TIFFStripSize(tif);
797  if( stripsize != 0 &&
798  (bytecount - 4096) / 10 > (uint64)stripsize )
799  {
800  uint64 newbytecount = (uint64)stripsize * 10 + 4096;
801  if( newbytecount == 0 || newbytecount > (uint64)TIFF_INT64_MAX )
802  {
803 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
805  "Too large strip byte count %I64u, strip %lu. Limiting to %I64u",
806  (unsigned __int64) bytecount,
807  (unsigned long) strip,
808  (unsigned __int64) newbytecount);
809 #else
811  "Too large strip byte count %llu, strip %lu. Limiting to %llu",
812  (unsigned long long) bytecount,
813  (unsigned long) strip,
814  (unsigned long long) newbytecount);
815 #endif
816  bytecount = newbytecount;
817  }
818  }
819  }
820 
821  if (isMapped(tif)) {
822  /*
823  * We must check for overflow, potentially causing
824  * an OOB read. Instead of simple
825  *
826  * TIFFGetStrileOffset(tif, strip)+bytecount > tif->tif_size
827  *
828  * comparison (which can overflow) we do the following
829  * two comparisons:
830  */
831  if (bytecount > (uint64)tif->tif_size ||
832  TIFFGetStrileOffset(tif, strip) > (uint64)tif->tif_size - bytecount) {
833  /*
834  * This error message might seem strange, but
835  * it's what would happen if a read were done
836  * instead.
837  */
838 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
840 
841  "Read error on strip %lu; "
842  "got %I64u bytes, expected %I64u",
843  (unsigned long) strip,
844  (unsigned __int64) NoSantizeSubUInt64(tif->tif_size, TIFFGetStrileOffset(tif, strip)),
845  (unsigned __int64) bytecount);
846 #else
848 
849  "Read error on strip %lu; "
850  "got %llu bytes, expected %llu",
851  (unsigned long) strip,
852  (unsigned long long) NoSantizeSubUInt64(tif->tif_size, TIFFGetStrileOffset(tif, strip)),
853  (unsigned long long) bytecount);
854 #endif
855  tif->tif_curstrip = NOSTRIP;
856  return (0);
857  }
858  }
859 
860  if (isMapped(tif) &&
861  (isFillOrder(tif, td->td_fillorder)
862  || (tif->tif_flags & TIFF_NOBITREV))) {
863  /*
864  * The image is mapped into memory and we either don't
865  * need to flip bits or the compression routine is
866  * going to handle this operation itself. In this
867  * case, avoid copying the raw data and instead just
868  * reference the data from the memory mapped file
869  * image. This assumes that the decompression
870  * routines do not modify the contents of the raw data
871  * buffer (if they try to, the application will get a
872  * fault since the file is mapped read-only).
873  */
874  if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
875  _TIFFfree(tif->tif_rawdata);
876  tif->tif_rawdata = NULL;
877  tif->tif_rawdatasize = 0;
878  }
879  tif->tif_flags &= ~TIFF_MYBUFFER;
880  tif->tif_rawdatasize = (tmsize_t)bytecount;
881  tif->tif_rawdata = tif->tif_base + (tmsize_t)TIFFGetStrileOffset(tif, strip);
882  tif->tif_rawdataoff = 0;
883  tif->tif_rawdataloaded = (tmsize_t) bytecount;
884 
885  /*
886  * When we have tif_rawdata reference directly into the memory mapped file
887  * we need to be pretty careful about how we use the rawdata. It is not
888  * a general purpose working buffer as it normally otherwise is. So we
889  * keep track of this fact to avoid using it improperly.
890  */
891  tif->tif_flags |= TIFF_BUFFERMMAP;
892  } else {
893  /*
894  * Expand raw data buffer, if needed, to hold data
895  * strip coming from file (perhaps should set upper
896  * bound on the size of a buffer we'll use?).
897  */
898  tmsize_t bytecountm;
899  bytecountm=(tmsize_t)bytecount;
900  if ((uint64)bytecountm!=bytecount)
901  {
902  TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
903  return(0);
904  }
905  if (bytecountm > tif->tif_rawdatasize) {
906  tif->tif_curstrip = NOSTRIP;
907  if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
909  "Data buffer too small to hold strip %lu",
910  (unsigned long) strip);
911  return (0);
912  }
913  }
914  if (tif->tif_flags&TIFF_BUFFERMMAP) {
915  tif->tif_curstrip = NOSTRIP;
916  tif->tif_rawdata = NULL;
917  tif->tif_rawdatasize = 0;
918  tif->tif_flags &= ~TIFF_BUFFERMMAP;
919  }
920 
921  if( isMapped(tif) )
922  {
923  if (bytecountm > tif->tif_rawdatasize &&
924  !TIFFReadBufferSetup(tif, 0, bytecountm))
925  {
926  return (0);
927  }
928  if (TIFFReadRawStrip1(tif, strip, tif->tif_rawdata,
929  bytecountm, module) != bytecountm)
930  {
931  return (0);
932  }
933  }
934  else
935  {
936  if (TIFFReadRawStripOrTile2(tif, strip, 1,
937  bytecountm, module) != bytecountm)
938  {
939  return (0);
940  }
941  }
942 
943 
944  tif->tif_rawdataoff = 0;
945  tif->tif_rawdataloaded = bytecountm;
946 
947  if (!isFillOrder(tif, td->td_fillorder) &&
948  (tif->tif_flags & TIFF_NOBITREV) == 0)
949  TIFFReverseBits(tif->tif_rawdata, bytecountm);
950  }
951  }
952  return (TIFFStartStrip(tif, strip));
953 }
unsigned long long uint64
Definition: platform.h:18
#define TIFF_INT64_MAX
Definition: tif_read.c:49
#define NOSTRIP
Definition: tif_read.c:42
void TIFFWarningExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_warning.c:65
uint8 * tif_base
Definition: tiffiop.h:202
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
uint32 tif_curstrip
Definition: tiffiop.h:161
uint8 * tif_rawdata
Definition: tiffiop.h:195
thandle_t tif_clientdata
Definition: tiffiop.h:207
tmsize_t tif_rawdataoff
Definition: tiffiop.h:197
tmsize_t TIFFStripSize(TIFF *tif)
Definition: tif_strip.c:202
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 tif_flags
Definition: tiffiop.h:119
smooth NULL
Definition: ftsmooth.c:416
#define TIFF_BUFFERMMAP
Definition: tiffiop.h:142
uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6290
static tmsize_t TIFFReadRawStripOrTile2(TIFF *tif, uint32 strip_or_tile, int is_strip, tmsize_t size, const char *module)
Definition: tif_read.c:684
#define isMapped(tif)
Definition: tiffiop.h:230
static int TIFFStartStrip(TIFF *tif, uint32 strip)
Definition: tif_read.c:1422
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t tif_rawdatasize
Definition: tiffiop.h:196
uint16 td_fillorder
Definition: tif_dir.h:80
tmsize_t tif_rawdataloaded
Definition: tiffiop.h:198
#define TIFF_NOBITREV
Definition: tiffiop.h:127
int TIFFReadBufferSetup(TIFF *tif, void *bp, tmsize_t size)
Definition: tif_read.c:1378
tmsize_t tif_size
Definition: tiffiop.h:203
TIFFDirectory tif_dir
Definition: tiffiop.h:151
#define isFillOrder(tif, o)
Definition: tiffiop.h:231
static tmsize_t TIFFReadRawStrip1(TIFF *tif, uint32 strip, void *buf, tmsize_t size, const char *module)
Definition: tif_read.c:609
void TIFFReverseBits(uint8 *cp, tmsize_t n)
Definition: tif_swab.c:284
void _TIFFfree(void *p)
Definition: tif_unix.c:326
static TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW uint64 NoSantizeSubUInt64(uint64 a, uint64 b)
Definition: tif_read.c:756
uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6305
#define TIFF_MYBUFFER
Definition: tiffiop.h:128
#define __int64
Definition: basetyps.h:16

Referenced by _TIFFReadEncodedStripAndAllocBuffer(), TIFFFillStripPartial(), TIFFReadEncodedStrip(), and TIFFSeek().

◆ TIFFFillStripPartial()

static int TIFFFillStripPartial ( TIFF tif,
int  strip,
tmsize_t  read_ahead,
int  restart 
)
static

Definition at line 184 of file tif_read.c.

185 {
186  static const char module[] = "TIFFFillStripPartial";
187  register TIFFDirectory *td = &tif->tif_dir;
188  tmsize_t unused_data;
189  uint64 read_offset;
191  tmsize_t read_ahead_mod;
192  /* tmsize_t bytecountm; */
193 
194  /*
195  * Expand raw data buffer, if needed, to hold data
196  * strip coming from file (perhaps should set upper
197  * bound on the size of a buffer we'll use?).
198  */
199 
200  /* bytecountm=(tmsize_t) TIFFGetStrileByteCount(tif, strip); */
201 
202  /* Not completely sure where the * 2 comes from, but probably for */
203  /* an exponentional growth strategy of tif_rawdatasize */
204  if( read_ahead < TIFF_TMSIZE_T_MAX / 2 )
205  read_ahead_mod = read_ahead * 2;
206  else
207  read_ahead_mod = read_ahead;
208  if (read_ahead_mod > tif->tif_rawdatasize) {
209  assert( restart );
210 
211  tif->tif_curstrip = NOSTRIP;
212  if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
214  "Data buffer too small to hold part of strip %lu",
215  (unsigned long) strip);
216  return (0);
217  }
218  }
219 
220  if( restart )
221  {
222  tif->tif_rawdataloaded = 0;
223  tif->tif_rawdataoff = 0;
224  }
225 
226  /*
227  ** If we are reading more data, move any unused data to the
228  ** start of the buffer.
229  */
230  if( tif->tif_rawdataloaded > 0 )
231  unused_data = tif->tif_rawdataloaded - (tif->tif_rawcp - tif->tif_rawdata);
232  else
233  unused_data = 0;
234 
235  if( unused_data > 0 )
236  {
237  assert((tif->tif_flags&TIFF_BUFFERMMAP)==0);
238  memmove( tif->tif_rawdata, tif->tif_rawcp, unused_data );
239  }
240 
241  /*
242  ** Seek to the point in the file where more data should be read.
243  */
244  read_offset = TIFFGetStrileOffset(tif, strip)
245  + tif->tif_rawdataoff + tif->tif_rawdataloaded;
246 
247  if (!SeekOK(tif, read_offset)) {
249  "Seek error at scanline %lu, strip %lu",
250  (unsigned long) tif->tif_row, (unsigned long) strip);
251  return 0;
252  }
253 
254  /*
255  ** How much do we want to read?
256  */
257  if( read_ahead_mod > tif->tif_rawdatasize )
258  to_read = read_ahead_mod - unused_data;
259  else
260  to_read = tif->tif_rawdatasize - unused_data;
261  if( (uint64) to_read > TIFFGetStrileByteCount(tif, strip)
262  - tif->tif_rawdataoff - tif->tif_rawdataloaded )
263  {
264  to_read = (tmsize_t) TIFFGetStrileByteCount(tif, strip)
265  - tif->tif_rawdataoff - tif->tif_rawdataloaded;
266  }
267 
268  assert((tif->tif_flags&TIFF_BUFFERMMAP)==0);
269  if( !TIFFReadAndRealloc( tif, to_read, unused_data,
270  1, /* is_strip */
271  0, /* strip_or_tile */
272  module) )
273  {
274  return 0;
275  }
276 
277  tif->tif_rawdataoff = tif->tif_rawdataoff + tif->tif_rawdataloaded - unused_data ;
278  tif->tif_rawdataloaded = unused_data + to_read;
279 
280  tif->tif_rawcc = tif->tif_rawdataloaded;
281  tif->tif_rawcp = tif->tif_rawdata;
282 
283  if (!isFillOrder(tif, td->td_fillorder) &&
284  (tif->tif_flags & TIFF_NOBITREV) == 0) {
285  assert((tif->tif_flags&TIFF_BUFFERMMAP)==0);
286  TIFFReverseBits(tif->tif_rawdata + unused_data, to_read );
287  }
288 
289  /*
290  ** When starting a strip from the beginning we need to
291  ** restart the decoder.
292  */
293  if( restart )
294  {
295 
296 #ifdef JPEG_SUPPORT
297  /* A bit messy since breaks the codec abstraction. Ultimately */
298  /* there should be a function pointer for that, but it seems */
299  /* only JPEG is affected. */
300  /* For JPEG, if there are multiple scans (can generally be known */
301  /* with the read_ahead used), we need to read the whole strip */
303  (uint64)tif->tif_rawcc < TIFFGetStrileByteCount(tif, strip) )
304  {
305  if( TIFFJPEGIsFullStripRequired(tif) )
306  {
307  return TIFFFillStrip(tif, strip);
308  }
309  }
310 #endif
311 
312  return TIFFStartStrip(tif, strip);
313  }
314  else
315  {
316  return 1;
317  }
318 }
unsigned long long uint64
Definition: platform.h:18
uint8 * tif_rawcp
Definition: tiffiop.h:199
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
#define NOSTRIP
Definition: tif_read.c:42
uint32 tif_curstrip
Definition: tiffiop.h:161
#define assert(x)
Definition: debug.h:53
uint8 * tif_rawdata
Definition: tiffiop.h:195
static int TIFFReadAndRealloc(TIFF *tif, tmsize_t size, tmsize_t rawdata_offset, int is_strip, uint32 strip_or_tile, const char *module)
Definition: tif_read.c:53
thandle_t tif_clientdata
Definition: tiffiop.h:207
tmsize_t tif_rawdataoff
Definition: tiffiop.h:197
tmsize_t tif_rawcc
Definition: tiffiop.h:200
int TIFFFillStrip(TIFF *tif, uint32 strip)
Definition: tif_read.c:766
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 tif_flags
Definition: tiffiop.h:119
#define TIFF_BUFFERMMAP
Definition: tiffiop.h:142
uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6290
void restart(int argc, const char *argv[])
Definition: cmds.c:2115
ULONG to_read
Definition: btrfs.c:4219
static int TIFFStartStrip(TIFF *tif, uint32 strip)
Definition: tif_read.c:1422
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t tif_rawdatasize
Definition: tiffiop.h:196
uint16 td_fillorder
Definition: tif_dir.h:80
tmsize_t tif_rawdataloaded
Definition: tiffiop.h:198
#define COMPRESSION_JPEG
Definition: tiff.h:166
#define TIFF_NOBITREV
Definition: tiffiop.h:127
#define TIFF_TMSIZE_T_MAX
Definition: tiffiop.h:81
uint32 tif_row
Definition: tiffiop.h:159
TIFFDirectory tif_dir
Definition: tiffiop.h:151
#define isFillOrder(tif, o)
Definition: tiffiop.h:231
#define SeekOK(tif, off)
Definition: tiffiop.h:256
void TIFFReverseBits(uint8 *cp, tmsize_t n)
Definition: tif_swab.c:284
uint16 td_compression
Definition: tif_dir.h:77
uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6305
#define TIFF_MYBUFFER
Definition: tiffiop.h:128

Referenced by TIFFSeek().

◆ TIFFFillTile()

int TIFFFillTile ( TIFF tif,
uint32  tile 
)

Definition at line 1204 of file tif_read.c.

1205 {
1206  static const char module[] = "TIFFFillTile";
1207  TIFFDirectory *td = &tif->tif_dir;
1208 
1209  if ((tif->tif_flags&TIFF_NOREADRAW)==0)
1210  {
1211  uint64 bytecount = TIFFGetStrileByteCount(tif, tile);
1212  if( bytecount == 0 || bytecount > (uint64)TIFF_INT64_MAX ) {
1213 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
1215  "%I64u: Invalid tile byte count, tile %lu",
1216  (unsigned __int64) bytecount,
1217  (unsigned long) tile);
1218 #else
1220  "%llu: Invalid tile byte count, tile %lu",
1221  (unsigned long long) bytecount,
1222  (unsigned long) tile);
1223 #endif
1224  return (0);
1225  }
1226 
1227  /* To avoid excessive memory allocations: */
1228  /* Byte count should normally not be larger than a number of */
1229  /* times the uncompressed size plus some margin */
1230  if( bytecount > 1024 * 1024 )
1231  {
1232  /* 10 and 4096 are just values that could be adjusted. */
1233  /* Hopefully they are safe enough for all codecs */
1234  tmsize_t stripsize = TIFFTileSize(tif);
1235  if( stripsize != 0 &&
1236  (bytecount - 4096) / 10 > (uint64)stripsize )
1237  {
1238  uint64 newbytecount = (uint64)stripsize * 10 + 4096;
1239  if( newbytecount == 0 || newbytecount > (uint64)TIFF_INT64_MAX )
1240  {
1241 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
1243  "Too large tile byte count %I64u, tile %lu. Limiting to %I64u",
1244  (unsigned __int64) bytecount,
1245  (unsigned long) tile,
1246  (unsigned __int64) newbytecount);
1247 #else
1249  "Too large tile byte count %llu, tile %lu. Limiting to %llu",
1250  (unsigned long long) bytecount,
1251  (unsigned long) tile,
1252  (unsigned long long) newbytecount);
1253 #endif
1254  bytecount = newbytecount;
1255  }
1256  }
1257  }
1258 
1259  if (isMapped(tif)) {
1260  /*
1261  * We must check for overflow, potentially causing
1262  * an OOB read. Instead of simple
1263  *
1264  * TIFFGetStrileOffset(tif, tile)+bytecount > tif->tif_size
1265  *
1266  * comparison (which can overflow) we do the following
1267  * two comparisons:
1268  */
1269  if (bytecount > (uint64)tif->tif_size ||
1270  TIFFGetStrileOffset(tif, tile) > (uint64)tif->tif_size - bytecount) {
1271  tif->tif_curtile = NOTILE;
1272  return (0);
1273  }
1274  }
1275 
1276  if (isMapped(tif) &&
1277  (isFillOrder(tif, td->td_fillorder)
1278  || (tif->tif_flags & TIFF_NOBITREV))) {
1279  /*
1280  * The image is mapped into memory and we either don't
1281  * need to flip bits or the compression routine is
1282  * going to handle this operation itself. In this
1283  * case, avoid copying the raw data and instead just
1284  * reference the data from the memory mapped file
1285  * image. This assumes that the decompression
1286  * routines do not modify the contents of the raw data
1287  * buffer (if they try to, the application will get a
1288  * fault since the file is mapped read-only).
1289  */
1290  if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
1291  _TIFFfree(tif->tif_rawdata);
1292  tif->tif_rawdata = NULL;
1293  tif->tif_rawdatasize = 0;
1294  }
1295  tif->tif_flags &= ~TIFF_MYBUFFER;
1296 
1297  tif->tif_rawdatasize = (tmsize_t)bytecount;
1298  tif->tif_rawdata =
1299  tif->tif_base + (tmsize_t)TIFFGetStrileOffset(tif, tile);
1300  tif->tif_rawdataoff = 0;
1301  tif->tif_rawdataloaded = (tmsize_t) bytecount;
1302  tif->tif_flags |= TIFF_BUFFERMMAP;
1303  } else {
1304  /*
1305  * Expand raw data buffer, if needed, to hold data
1306  * tile coming from file (perhaps should set upper
1307  * bound on the size of a buffer we'll use?).
1308  */
1309  tmsize_t bytecountm;
1310  bytecountm=(tmsize_t)bytecount;
1311  if ((uint64)bytecountm!=bytecount)
1312  {
1313  TIFFErrorExt(tif->tif_clientdata,module,"Integer overflow");
1314  return(0);
1315  }
1316  if (bytecountm > tif->tif_rawdatasize) {
1317  tif->tif_curtile = NOTILE;
1318  if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
1320  "Data buffer too small to hold tile %lu",
1321  (unsigned long) tile);
1322  return (0);
1323  }
1324  }
1325  if (tif->tif_flags&TIFF_BUFFERMMAP) {
1326  tif->tif_curtile = NOTILE;
1327  tif->tif_rawdata = NULL;
1328  tif->tif_rawdatasize = 0;
1329  tif->tif_flags &= ~TIFF_BUFFERMMAP;
1330  }
1331 
1332  if( isMapped(tif) )
1333  {
1334  if (bytecountm > tif->tif_rawdatasize &&
1335  !TIFFReadBufferSetup(tif, 0, bytecountm))
1336  {
1337  return (0);
1338  }
1339  if (TIFFReadRawTile1(tif, tile, tif->tif_rawdata,
1340  bytecountm, module) != bytecountm)
1341  {
1342  return (0);
1343  }
1344  }
1345  else
1346  {
1347  if (TIFFReadRawStripOrTile2(tif, tile, 0,
1348  bytecountm, module) != bytecountm)
1349  {
1350  return (0);
1351  }
1352  }
1353 
1354 
1355  tif->tif_rawdataoff = 0;
1356  tif->tif_rawdataloaded = bytecountm;
1357 
1358  if (tif->tif_rawdata != NULL &&
1359  !isFillOrder(tif, td->td_fillorder) &&
1360  (tif->tif_flags & TIFF_NOBITREV) == 0)
1362  tif->tif_rawdataloaded);
1363  }
1364  }
1365  return (TIFFStartTile(tif, tile));
1366 }
unsigned long long uint64
Definition: platform.h:18
#define TIFF_INT64_MAX
Definition: tif_read.c:49
void TIFFWarningExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_warning.c:65
uint8 * tif_base
Definition: tiffiop.h:202
#define NOTILE
Definition: tif_read.c:43
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
uint8 * tif_rawdata
Definition: tiffiop.h:195
thandle_t tif_clientdata
Definition: tiffiop.h:207
tmsize_t tif_rawdataoff
Definition: tiffiop.h:197
static tmsize_t TIFFReadRawTile1(TIFF *tif, uint32 tile, void *buf, tmsize_t size, const char *module)
Definition: tif_read.c:1094
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 tif_flags
Definition: tiffiop.h:119
smooth NULL
Definition: ftsmooth.c:416
#define TIFF_BUFFERMMAP
Definition: tiffiop.h:142
uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6290
static tmsize_t TIFFReadRawStripOrTile2(TIFF *tif, uint32 strip_or_tile, int is_strip, tmsize_t size, const char *module)
Definition: tif_read.c:684
#define isMapped(tif)
Definition: tiffiop.h:230
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t tif_rawdatasize
Definition: tiffiop.h:196
uint16 td_fillorder
Definition: tif_dir.h:80
tmsize_t tif_rawdataloaded
Definition: tiffiop.h:198
uint32 tif_curtile
Definition: tiffiop.h:169
#define TIFF_NOBITREV
Definition: tiffiop.h:127
int TIFFReadBufferSetup(TIFF *tif, void *bp, tmsize_t size)
Definition: tif_read.c:1378
tmsize_t tif_size
Definition: tiffiop.h:203
TIFFDirectory tif_dir
Definition: tiffiop.h:151
#define isFillOrder(tif, o)
Definition: tiffiop.h:231
tmsize_t TIFFTileSize(TIFF *tif)
Definition: tif_tile.c:257
void TIFFReverseBits(uint8 *cp, tmsize_t n)
Definition: tif_swab.c:284
void _TIFFfree(void *p)
Definition: tif_unix.c:326
uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6305
#define TIFF_MYBUFFER
Definition: tiffiop.h:128
#define __int64
Definition: basetyps.h:16
static int TIFFStartTile(TIFF *tif, uint32 tile)
Definition: tif_read.c:1457

Referenced by _TIFFReadEncodedTileAndAllocBuffer(), and TIFFReadEncodedTile().

◆ TIFFReadAndRealloc()

static int TIFFReadAndRealloc ( TIFF tif,
tmsize_t  size,
tmsize_t  rawdata_offset,
int  is_strip,
uint32  strip_or_tile,
const char module 
)
static

Definition at line 53 of file tif_read.c.

57 {
58 #if SIZEOF_SIZE_T == 8
59  tmsize_t threshold = INITIAL_THRESHOLD;
60 #endif
61  tmsize_t already_read = 0;
62 
63 
64 #if SIZEOF_SIZE_T != 8
65  /* On 32 bit processes, if the request is large enough, check against */
66  /* file size */
67  if( size > 1000 * 1000 * 1000 )
68  {
69  uint64 filesize = TIFFGetFileSize(tif);
70  if( (uint64)size >= filesize )
71  {
73  "Chunk size requested is larger than file size.");
74  return 0;
75  }
76  }
77 #endif
78 
79  /* On 64 bit processes, read first a maximum of 1 MB, then 10 MB, etc */
80  /* so as to avoid allocating too much memory in case the file is too */
81  /* short. We could ask for the file size, but this might be */
82  /* expensive with some I/O layers (think of reading a gzipped file) */
83  /* Restrict to 64 bit processes, so as to avoid reallocs() */
84  /* on 32 bit processes where virtual memory is scarce. */
85  while( already_read < size )
86  {
87  tmsize_t bytes_read;
88  tmsize_t to_read = size - already_read;
89 #if SIZEOF_SIZE_T == 8
90  if( to_read >= threshold && threshold < MAX_THRESHOLD &&
91  already_read + to_read + rawdata_offset > tif->tif_rawdatasize )
92  {
93  to_read = threshold;
94  threshold *= THRESHOLD_MULTIPLIER;
95  }
96 #endif
97  if (already_read + to_read + rawdata_offset > tif->tif_rawdatasize) {
98  uint8* new_rawdata;
99  assert((tif->tif_flags & TIFF_MYBUFFER) != 0);
101  (uint64)already_read + to_read + rawdata_offset, 1024);
102  if (tif->tif_rawdatasize==0) {
104  "Invalid buffer size");
105  return 0;
106  }
107  new_rawdata = (uint8*) _TIFFrealloc(
108  tif->tif_rawdata, tif->tif_rawdatasize);
109  if( new_rawdata == 0 )
110  {
112  "No space for data buffer at scanline %lu",
113  (unsigned long) tif->tif_row);
114  _TIFFfree(tif->tif_rawdata);
115  tif->tif_rawdata = 0;
116  tif->tif_rawdatasize = 0;
117  return 0;
118  }
119  tif->tif_rawdata = new_rawdata;
120  }
121  if( tif->tif_rawdata == NULL )
122  {
123  /* should not happen in practice but helps CoverityScan */
124  return 0;
125  }
126 
127  bytes_read = TIFFReadFile(tif,
128  tif->tif_rawdata + rawdata_offset + already_read, to_read);
129  already_read += bytes_read;
130  if (bytes_read != to_read) {
131  memset( tif->tif_rawdata + rawdata_offset + already_read, 0,
132  tif->tif_rawdatasize - rawdata_offset - already_read );
133 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
134  if( is_strip )
135  {
137  "Read error at scanline %lu; got %I64u bytes, "
138  "expected %I64u",
139  (unsigned long) tif->tif_row,
140  (unsigned __int64) already_read,
141  (unsigned __int64) size);
142  }
143  else
144  {
146  "Read error at row %lu, col %lu, tile %lu; "
147  "got %I64u bytes, expected %I64u",
148  (unsigned long) tif->tif_row,
149  (unsigned long) tif->tif_col,
150  (unsigned long) strip_or_tile,
151  (unsigned __int64) already_read,
152  (unsigned __int64) size);
153  }
154 #else
155  if( is_strip )
156  {
158  "Read error at scanline %lu; got %llu bytes, "
159  "expected %llu",
160  (unsigned long) tif->tif_row,
161  (unsigned long long) already_read,
162  (unsigned long long) size);
163  }
164  else
165  {
167  "Read error at row %lu, col %lu, tile %lu; "
168  "got %llu bytes, expected %llu",
169  (unsigned long) tif->tif_row,
170  (unsigned long) tif->tif_col,
171  (unsigned long) strip_or_tile,
172  (unsigned long long) already_read,
173  (unsigned long long) size);
174  }
175 #endif
176  return 0;
177  }
178  }
179  return 1;
180 }
unsigned long long uint64
Definition: platform.h:18
#define THRESHOLD_MULTIPLIER
Definition: tif_read.c:46
#define assert(x)
Definition: debug.h:53
uint8 * tif_rawdata
Definition: tiffiop.h:195
thandle_t tif_clientdata
Definition: tiffiop.h:207
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 tif_flags
Definition: tiffiop.h:119
smooth NULL
Definition: ftsmooth.c:416
#define INITIAL_THRESHOLD
Definition: tif_read.c:45
GLsizeiptr size
Definition: glext.h:5919
ULONG to_read
Definition: btrfs.c:4219
unsigned char uint8
Definition: types.h:28
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t tif_rawdatasize
Definition: tiffiop.h:196
void * _TIFFrealloc(void *p, tmsize_t s)
Definition: tif_unix.c:332
#define TIFFGetFileSize(tif)
Definition: tiffiop.h:241
uint32 tif_row
Definition: tiffiop.h:159
#define TIFFroundup_64(x, y)
Definition: tiffiop.h:275
#define MAX_THRESHOLD
Definition: tif_read.c:47
void _TIFFfree(void *p)
Definition: tif_unix.c:326
uint32 tif_col
Definition: tiffiop.h:168
#define TIFFReadFile(tif, buf, size)
Definition: tiffiop.h:233
#define memset(x, y, z)
Definition: compat.h:39
#define TIFF_MYBUFFER
Definition: tiffiop.h:128
#define __int64
Definition: basetyps.h:16

Referenced by TIFFFillStripPartial(), and TIFFReadRawStripOrTile2().

◆ TIFFReadBufferSetup()

int TIFFReadBufferSetup ( TIFF tif,
void bp,
tmsize_t  size 
)

Definition at line 1378 of file tif_read.c.

1379 {
1380  static const char module[] = "TIFFReadBufferSetup";
1381 
1382  assert((tif->tif_flags&TIFF_NOREADRAW)==0);
1383  tif->tif_flags &= ~TIFF_BUFFERMMAP;
1384 
1385  if (tif->tif_rawdata) {
1386  if (tif->tif_flags & TIFF_MYBUFFER)
1387  _TIFFfree(tif->tif_rawdata);
1388  tif->tif_rawdata = NULL;
1389  tif->tif_rawdatasize = 0;
1390  }
1391  if (bp) {
1392  tif->tif_rawdatasize = size;
1393  tif->tif_rawdata = (uint8*) bp;
1394  tif->tif_flags &= ~TIFF_MYBUFFER;
1395  } else {
1397  if (tif->tif_rawdatasize==0) {
1399  "Invalid buffer size");
1400  return (0);
1401  }
1402  /* Initialize to zero to avoid uninitialized buffers in case of */
1403  /* short reads (http://bugzilla.maptools.org/show_bug.cgi?id=2651) */
1404  tif->tif_rawdata = (uint8*) _TIFFcalloc(1, tif->tif_rawdatasize);
1405  tif->tif_flags |= TIFF_MYBUFFER;
1406  }
1407  if (tif->tif_rawdata == NULL) {
1409  "No space for data buffer at scanline %lu",
1410  (unsigned long) tif->tif_row);
1411  tif->tif_rawdatasize = 0;
1412  return (0);
1413  }
1414  return (1);
1415 }
unsigned long long uint64
Definition: platform.h:18
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
#define assert(x)
Definition: debug.h:53
uint8 * tif_rawdata
Definition: tiffiop.h:195
thandle_t tif_clientdata
Definition: tiffiop.h:207
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 tif_flags
Definition: tiffiop.h:119
smooth NULL
Definition: ftsmooth.c:416
#define TIFF_BUFFERMMAP
Definition: tiffiop.h:142
GLsizeiptr size
Definition: glext.h:5919
unsigned char uint8
Definition: types.h:28
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t tif_rawdatasize
Definition: tiffiop.h:196
void * _TIFFcalloc(tmsize_t nmemb, tmsize_t siz)
Definition: tif_unix.c:317
uint32 tif_row
Definition: tiffiop.h:159
#define TIFFroundup_64(x, y)
Definition: tiffiop.h:275
void _TIFFfree(void *p)
Definition: tif_unix.c:326
#define TIFF_MYBUFFER
Definition: tiffiop.h:128

Referenced by TIFFFillStrip(), and TIFFFillTile().

◆ TIFFReadEncodedStrip()

tmsize_t TIFFReadEncodedStrip ( TIFF tif,
uint32  strip,
void buf,
tmsize_t  size 
)

Definition at line 527 of file tif_read.c.

528 {
529  static const char module[] = "TIFFReadEncodedStrip";
530  TIFFDirectory *td = &tif->tif_dir;
531  tmsize_t stripsize;
532  uint16 plane;
533 
534  stripsize=TIFFReadEncodedStripGetStripSize(tif, strip, &plane);
535  if (stripsize==((tmsize_t)(-1)))
536  return((tmsize_t)(-1));
537 
538  /* shortcut to avoid an extra memcpy() */
539  if( td->td_compression == COMPRESSION_NONE &&
540  size!=(tmsize_t)(-1) && size >= stripsize &&
541  !isMapped(tif) &&
542  ((tif->tif_flags&TIFF_NOREADRAW)==0) )
543  {
544  if (TIFFReadRawStrip1(tif, strip, buf, stripsize, module) != stripsize)
545  return ((tmsize_t)(-1));
546 
547  if (!isFillOrder(tif, td->td_fillorder) &&
548  (tif->tif_flags & TIFF_NOBITREV) == 0)
549  TIFFReverseBits(buf,stripsize);
550 
551  (*tif->tif_postdecode)(tif,buf,stripsize);
552  return (stripsize);
553  }
554 
555  if ((size!=(tmsize_t)(-1))&&(size<stripsize))
556  stripsize=size;
557  if (!TIFFFillStrip(tif,strip))
558  return((tmsize_t)(-1));
559  if ((*tif->tif_decodestrip)(tif,buf,stripsize,plane)<=0)
560  return((tmsize_t)(-1));
561  (*tif->tif_postdecode)(tif,buf,stripsize);
562  return(stripsize);
563 }
static tmsize_t TIFFReadEncodedStripGetStripSize(TIFF *tif, uint32 strip, uint16 *pplane)
Definition: tif_read.c:488
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint GLenum GLenum GLenum GLint GLuint GLenum GLenum GLfloat GLenum GLfloat GLenum GLint const GLfloat GLenum GLint const GLushort GLint GLint GLsizei GLsizei GLenum GLsizei GLsizei GLenum GLenum const GLvoid GLenum plane
Definition: glfuncs.h:270
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
int TIFFFillStrip(TIFF *tif, uint32 strip)
Definition: tif_read.c:766
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 tif_flags
Definition: tiffiop.h:119
TIFFCodeMethod tif_decodestrip
Definition: tiffiop.h:182
#define isMapped(tif)
Definition: tiffiop.h:230
GLsizeiptr size
Definition: glext.h:5919
TIFFPostMethod tif_postdecode
Definition: tiffiop.h:214
uint16 td_fillorder
Definition: tif_dir.h:80
#define COMPRESSION_NONE
Definition: tiff.h:158
#define TIFF_NOBITREV
Definition: tiffiop.h:127
unsigned short uint16
Definition: types.h:30
TIFFDirectory tif_dir
Definition: tiffiop.h:151
#define isFillOrder(tif, o)
Definition: tiffiop.h:231
static tmsize_t TIFFReadRawStrip1(TIFF *tif, uint32 strip, void *buf, tmsize_t size, const char *module)
Definition: tif_read.c:609
void TIFFReverseBits(uint8 *cp, tmsize_t n)
Definition: tif_swab.c:284
uint16 td_compression
Definition: tif_dir.h:77

Referenced by _TIFFReadEncodedStripAndAllocBuffer(), and gtStripSeparate().

◆ TIFFReadEncodedStripGetStripSize()

static tmsize_t TIFFReadEncodedStripGetStripSize ( TIFF tif,
uint32  strip,
uint16 pplane 
)
static

Definition at line 488 of file tif_read.c.

489 {
490  static const char module[] = "TIFFReadEncodedStrip";
491  TIFFDirectory *td = &tif->tif_dir;
492  uint32 rowsperstrip;
493  uint32 stripsperplane;
494  uint32 stripinplane;
495  uint32 rows;
496  tmsize_t stripsize;
497  if (!TIFFCheckRead(tif,0))
498  return((tmsize_t)(-1));
499  if (strip>=td->td_nstrips)
500  {
502  "%lu: Strip out of range, max %lu",(unsigned long)strip,
503  (unsigned long)td->td_nstrips);
504  return((tmsize_t)(-1));
505  }
506 
507  rowsperstrip=td->td_rowsperstrip;
508  if (rowsperstrip>td->td_imagelength)
509  rowsperstrip=td->td_imagelength;
510  stripsperplane= TIFFhowmany_32_maxuint_compat(td->td_imagelength, rowsperstrip);
511  stripinplane=(strip%stripsperplane);
512  if( pplane ) *pplane=(uint16)(strip/stripsperplane);
513  rows=td->td_imagelength-stripinplane*rowsperstrip;
514  if (rows>rowsperstrip)
515  rows=rowsperstrip;
516  stripsize=TIFFVStripSize(tif,rows);
517  if (stripsize==0)
518  return((tmsize_t)(-1));
519  return stripsize;
520 }
tmsize_t TIFFVStripSize(TIFF *tif, uint32 nrows)
Definition: tif_strip.c:128
unsigned int uint32
Definition: types.h:32
thandle_t tif_clientdata
Definition: tiffiop.h:207
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 td_nstrips
Definition: tif_dir.h:100
uint32 td_imagelength
Definition: tif_dir.h:72
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
#define TIFFhowmany_32_maxuint_compat(x, y)
Definition: tiffiop.h:269
uint32 td_rowsperstrip
Definition: tif_dir.h:83
unsigned short uint16
Definition: types.h:30
TIFFDirectory tif_dir
Definition: tiffiop.h:151
static int TIFFCheckRead(TIFF *, int)
Definition: tif_read.c:1500

Referenced by _TIFFReadEncodedStripAndAllocBuffer(), and TIFFReadEncodedStrip().

◆ TIFFReadEncodedTile()

tmsize_t TIFFReadEncodedTile ( TIFF tif,
uint32  tile,
void buf,
tmsize_t  size 
)

Definition at line 978 of file tif_read.c.

979 {
980  static const char module[] = "TIFFReadEncodedTile";
981  TIFFDirectory *td = &tif->tif_dir;
982  tmsize_t tilesize = tif->tif_tilesize;
983 
984  if (!TIFFCheckRead(tif, 1))
985  return ((tmsize_t)(-1));
986  if (tile >= td->td_nstrips) {
988  "%lu: Tile out of range, max %lu",
989  (unsigned long) tile, (unsigned long) td->td_nstrips);
990  return ((tmsize_t)(-1));
991  }
992 
993  /* shortcut to avoid an extra memcpy() */
994  if( td->td_compression == COMPRESSION_NONE &&
995  size!=(tmsize_t)(-1) && size >= tilesize &&
996  !isMapped(tif) &&
997  ((tif->tif_flags&TIFF_NOREADRAW)==0) )
998  {
999  if (TIFFReadRawTile1(tif, tile, buf, tilesize, module) != tilesize)
1000  return ((tmsize_t)(-1));
1001 
1002  if (!isFillOrder(tif, td->td_fillorder) &&
1003  (tif->tif_flags & TIFF_NOBITREV) == 0)
1004  TIFFReverseBits(buf,tilesize);
1005 
1006  (*tif->tif_postdecode)(tif,buf,tilesize);
1007  return (tilesize);
1008  }
1009 
1010  if (size == (tmsize_t)(-1))
1011  size = tilesize;
1012  else if (size > tilesize)
1013  size = tilesize;
1014  if (TIFFFillTile(tif, tile) && (*tif->tif_decodetile)(tif,
1015  (uint8*) buf, size, (uint16)(tile/td->td_stripsperimage))) {
1016  (*tif->tif_postdecode)(tif, (uint8*) buf, size);
1017  return (size);
1018  } else
1019  return ((tmsize_t)(-1));
1020 }
int TIFFFillTile(TIFF *tif, uint32 tile)
Definition: tif_read.c:1204
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
thandle_t tif_clientdata
Definition: tiffiop.h:207
tmsize_t tif_tilesize
Definition: tiffiop.h:170
static tmsize_t TIFFReadRawTile1(TIFF *tif, uint32 tile, void *buf, tmsize_t size, const char *module)
Definition: tif_read.c:1094
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 td_stripsperimage
Definition: tif_dir.h:99
uint32 tif_flags
Definition: tiffiop.h:119
#define isMapped(tif)
Definition: tiffiop.h:230
uint32 td_nstrips
Definition: tif_dir.h:100
GLsizeiptr size
Definition: glext.h:5919
TIFFPostMethod tif_postdecode
Definition: tiffiop.h:214
unsigned char uint8
Definition: types.h:28
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
uint16 td_fillorder
Definition: tif_dir.h:80
TIFFCodeMethod tif_decodetile
Definition: tiffiop.h:184
#define COMPRESSION_NONE
Definition: tiff.h:158
#define TIFF_NOBITREV
Definition: tiffiop.h:127
unsigned short uint16
Definition: types.h:30
TIFFDirectory tif_dir
Definition: tiffiop.h:151
#define isFillOrder(tif, o)
Definition: tiffiop.h:231
void TIFFReverseBits(uint8 *cp, tmsize_t n)
Definition: tif_swab.c:284
static int TIFFCheckRead(TIFF *, int)
Definition: tif_read.c:1500
uint16 td_compression
Definition: tif_dir.h:77

Referenced by _TIFFReadEncodedTileAndAllocBuffer(), and TIFFReadTile().

◆ TIFFReadFromUserBuffer()

int TIFFReadFromUserBuffer ( TIFF tif,
uint32  strile,
void inbuf,
tmsize_t  insize,
void outbuf,
tmsize_t  outsize 
)

Definition at line 1524 of file tif_read.c.

1527 {
1528  static const char module[] = "TIFFReadFromUserBuffer";
1529  TIFFDirectory *td = &tif->tif_dir;
1530  int ret = 1;
1531  uint32 old_tif_flags = tif->tif_flags;
1532  tmsize_t old_rawdatasize = tif->tif_rawdatasize;
1533  void* old_rawdata = tif->tif_rawdata;
1534 
1535  if (tif->tif_mode == O_WRONLY) {
1536  TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "File not open for reading");
1537  return 0;
1538  }
1539  if (tif->tif_flags&TIFF_NOREADRAW)
1540  {
1542  "Compression scheme does not support access to raw uncompressed data");
1543  return 0;
1544  }
1545 
1546  tif->tif_flags &= ~TIFF_MYBUFFER;
1547  tif->tif_flags |= TIFF_BUFFERMMAP;
1548  tif->tif_rawdatasize = insize;
1549  tif->tif_rawdata = inbuf;
1550  tif->tif_rawdataoff = 0;
1551  tif->tif_rawdataloaded = insize;
1552 
1553  if (!isFillOrder(tif, td->td_fillorder) &&
1554  (tif->tif_flags & TIFF_NOBITREV) == 0)
1555  {
1557  }
1558 
1559  if( TIFFIsTiled(tif) )
1560  {
1561  if( !TIFFStartTile(tif, strile) ||
1562  !(*tif->tif_decodetile)(tif, (uint8*) outbuf, outsize,
1563  (uint16)(strile/td->td_stripsperimage)) )
1564  {
1565  ret = 0;
1566  }
1567  }
1568  else
1569  {
1570  uint32 rowsperstrip=td->td_rowsperstrip;
1571  uint32 stripsperplane;
1572  if (rowsperstrip>td->td_imagelength)
1573  rowsperstrip=td->td_imagelength;
1574  stripsperplane= TIFFhowmany_32_maxuint_compat(td->td_imagelength, rowsperstrip);
1575  if( !TIFFStartStrip(tif, strile) ||
1576  !(*tif->tif_decodestrip)(tif, (uint8*) outbuf, outsize,
1577  (uint16)(strile/stripsperplane)) )
1578  {
1579  ret = 0;
1580  }
1581  }
1582  if( ret )
1583  {
1584  (*tif->tif_postdecode)(tif, (uint8*) outbuf, outsize);
1585  }
1586 
1587  if (!isFillOrder(tif, td->td_fillorder) &&
1588  (tif->tif_flags & TIFF_NOBITREV) == 0)
1589  {
1591  }
1592 
1593  tif->tif_flags = old_tif_flags;
1594  tif->tif_rawdatasize = old_rawdatasize;
1595  tif->tif_rawdata = old_rawdata;
1596  tif->tif_rawdataoff = 0;
1597  tif->tif_rawdataloaded = 0;
1598 
1599  return ret;
1600 }
unsigned int uint32
Definition: types.h:32
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
static int inbuf
Definition: adnsresfilter.c:73
uint8 * tif_rawdata
Definition: tiffiop.h:195
thandle_t tif_clientdata
Definition: tiffiop.h:207
tmsize_t tif_rawdataoff
Definition: tiffiop.h:197
char * tif_name
Definition: tiffiop.h:116
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
#define O_WRONLY
Definition: acwin.h:111
uint32 td_stripsperimage
Definition: tif_dir.h:99
int tif_mode
Definition: tiffiop.h:118
uint32 tif_flags
Definition: tiffiop.h:119
TIFFCodeMethod tif_decodestrip
Definition: tiffiop.h:182
#define TIFF_BUFFERMMAP
Definition: tiffiop.h:142
unsigned char size_t * outsize
Definition: jpeglib.h:980
uint32 td_imagelength
Definition: tif_dir.h:72
TIFFPostMethod tif_postdecode
Definition: tiffiop.h:214
const unsigned char size_t insize
Definition: jpeglib.h:983
static int TIFFStartStrip(TIFF *tif, uint32 strip)
Definition: tif_read.c:1422
unsigned char uint8
Definition: types.h:28
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t tif_rawdatasize
Definition: tiffiop.h:196
uint16 td_fillorder
Definition: tif_dir.h:80
tmsize_t tif_rawdataloaded
Definition: tiffiop.h:198
int ret
TIFFCodeMethod tif_decodetile
Definition: tiffiop.h:184
#define TIFF_NOBITREV
Definition: tiffiop.h:127
#define TIFFhowmany_32_maxuint_compat(x, y)
Definition: tiffiop.h:269
uint32 td_rowsperstrip
Definition: tif_dir.h:83
unsigned short uint16
Definition: types.h:30
TIFFDirectory tif_dir
Definition: tiffiop.h:151
#define isFillOrder(tif, o)
Definition: tiffiop.h:231
void TIFFReverseBits(uint8 *cp, tmsize_t n)
Definition: tif_swab.c:284
int TIFFIsTiled(TIFF *tif)
Definition: tif_open.c:594
#define TIFF_MYBUFFER
Definition: tiffiop.h:128
static int TIFFStartTile(TIFF *tif, uint32 tile)
Definition: tif_read.c:1457

◆ TIFFReadRawStrip()

tmsize_t TIFFReadRawStrip ( TIFF tif,
uint32  strip,
void buf,
tmsize_t  size 
)

Definition at line 722 of file tif_read.c.

723 {
724  static const char module[] = "TIFFReadRawStrip";
725  TIFFDirectory *td = &tif->tif_dir;
726  uint64 bytecount64;
727  tmsize_t bytecountm;
728 
729  if (!TIFFCheckRead(tif, 0))
730  return ((tmsize_t)(-1));
731  if (strip >= td->td_nstrips) {
733  "%lu: Strip out of range, max %lu",
734  (unsigned long) strip,
735  (unsigned long) td->td_nstrips);
736  return ((tmsize_t)(-1));
737  }
738  if (tif->tif_flags&TIFF_NOREADRAW)
739  {
741  "Compression scheme does not support access to raw uncompressed data");
742  return ((tmsize_t)(-1));
743  }
744  bytecount64 = TIFFGetStrileByteCount(tif, strip);
745  if (size != (tmsize_t)(-1) && (uint64)size <= bytecount64)
746  bytecountm = size;
747  else
748  bytecountm = _TIFFCastUInt64ToSSize(tif, bytecount64, module);
749  if( bytecountm == 0 ) {
750  return ((tmsize_t)(-1));
751  }
752  return (TIFFReadRawStrip1(tif, strip, buf, bytecountm, module));
753 }
unsigned long long uint64
Definition: platform.h:18
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
thandle_t tif_clientdata
Definition: tiffiop.h:207
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 tif_flags
Definition: tiffiop.h:119
uint32 td_nstrips
Definition: tif_dir.h:100
GLsizeiptr size
Definition: glext.h:5919
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
TIFFDirectory tif_dir
Definition: tiffiop.h:151
tmsize_t _TIFFCastUInt64ToSSize(TIFF *tif, uint64 val, const char *module)
Definition: tif_aux.c:83
static tmsize_t TIFFReadRawStrip1(TIFF *tif, uint32 strip, void *buf, tmsize_t size, const char *module)
Definition: tif_read.c:609
static int TIFFCheckRead(TIFF *, int)
Definition: tif_read.c:1500
uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6305

◆ TIFFReadRawStrip1()

static tmsize_t TIFFReadRawStrip1 ( TIFF tif,
uint32  strip,
void buf,
tmsize_t  size,
const char module 
)
static

Definition at line 609 of file tif_read.c.

611 {
612  assert((tif->tif_flags&TIFF_NOREADRAW)==0);
613  if (!isMapped(tif)) {
614  tmsize_t cc;
615 
616  if (!SeekOK(tif, TIFFGetStrileOffset(tif, strip))) {
618  "Seek error at scanline %lu, strip %lu",
619  (unsigned long) tif->tif_row, (unsigned long) strip);
620  return ((tmsize_t)(-1));
621  }
622  cc = TIFFReadFile(tif, buf, size);
623  if (cc != size) {
624 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
626  "Read error at scanline %lu; got %I64u bytes, expected %I64u",
627  (unsigned long) tif->tif_row,
628  (unsigned __int64) cc,
629  (unsigned __int64) size);
630 #else
632  "Read error at scanline %lu; got %llu bytes, expected %llu",
633  (unsigned long) tif->tif_row,
634  (unsigned long long) cc,
635  (unsigned long long) size);
636 #endif
637  return ((tmsize_t)(-1));
638  }
639  } else {
640  tmsize_t ma = 0;
641  tmsize_t n;
642  if ((TIFFGetStrileOffset(tif, strip) > (uint64)TIFF_TMSIZE_T_MAX)||
643  ((ma=(tmsize_t)TIFFGetStrileOffset(tif, strip))>tif->tif_size))
644  {
645  n=0;
646  }
647  else if( ma > TIFF_TMSIZE_T_MAX - size )
648  {
649  n=0;
650  }
651  else
652  {
653  tmsize_t mb=ma+size;
654  if (mb>tif->tif_size)
655  n=tif->tif_size-ma;
656  else
657  n=size;
658  }
659  if (n!=size) {
660 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
662  "Read error at scanline %lu, strip %lu; got %I64u bytes, expected %I64u",
663  (unsigned long) tif->tif_row,
664  (unsigned long) strip,
665  (unsigned __int64) n,
666  (unsigned __int64) size);
667 #else
669  "Read error at scanline %lu, strip %lu; got %llu bytes, expected %llu",
670  (unsigned long) tif->tif_row,
671  (unsigned long) strip,
672  (unsigned long long) n,
673  (unsigned long long) size);
674 #endif
675  return ((tmsize_t)(-1));
676  }
677  _TIFFmemcpy(buf, tif->tif_base + ma,
678  size);
679  }
680  return (size);
681 }
unsigned long long uint64
Definition: platform.h:18
uint8 * tif_base
Definition: tiffiop.h:202
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
GLdouble n
Definition: glext.h:7729
#define assert(x)
Definition: debug.h:53
thandle_t tif_clientdata
Definition: tiffiop.h:207
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 tif_flags
Definition: tiffiop.h:119
uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6290
#define isMapped(tif)
Definition: tiffiop.h:230
GLsizeiptr size
Definition: glext.h:5919
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t tif_size
Definition: tiffiop.h:203
#define TIFF_TMSIZE_T_MAX
Definition: tiffiop.h:81
uint32_t cc
Definition: isohybrid.c:75
uint32 tif_row
Definition: tiffiop.h:159
#define SeekOK(tif, off)
Definition: tiffiop.h:256
#define TIFFReadFile(tif, buf, size)
Definition: tiffiop.h:233
void _TIFFmemcpy(void *d, const void *s, tmsize_t c)
Definition: tif_unix.c:344
#define __int64
Definition: basetyps.h:16

Referenced by TIFFFillStrip(), TIFFReadEncodedStrip(), and TIFFReadRawStrip().

◆ TIFFReadRawStripOrTile2()

static tmsize_t TIFFReadRawStripOrTile2 ( TIFF tif,
uint32  strip_or_tile,
int  is_strip,
tmsize_t  size,
const char module 
)
static

Definition at line 684 of file tif_read.c.

686 {
687  assert( !isMapped(tif) );
688  assert((tif->tif_flags&TIFF_NOREADRAW)==0);
689 
690  if (!SeekOK(tif, TIFFGetStrileOffset(tif, strip_or_tile))) {
691  if( is_strip )
692  {
694  "Seek error at scanline %lu, strip %lu",
695  (unsigned long) tif->tif_row,
696  (unsigned long) strip_or_tile);
697  }
698  else
699  {
701  "Seek error at row %lu, col %lu, tile %lu",
702  (unsigned long) tif->tif_row,
703  (unsigned long) tif->tif_col,
704  (unsigned long) strip_or_tile);
705  }
706  return ((tmsize_t)(-1));
707  }
708 
709  if( !TIFFReadAndRealloc( tif, size, 0, is_strip,
710  strip_or_tile, module ) )
711  {
712  return ((tmsize_t)(-1));
713  }
714 
715  return (size);
716 }
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
#define assert(x)
Definition: debug.h:53
static int TIFFReadAndRealloc(TIFF *tif, tmsize_t size, tmsize_t rawdata_offset, int is_strip, uint32 strip_or_tile, const char *module)
Definition: tif_read.c:53
thandle_t tif_clientdata
Definition: tiffiop.h:207
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 tif_flags
Definition: tiffiop.h:119
uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6290
#define isMapped(tif)
Definition: tiffiop.h:230
GLsizeiptr size
Definition: glext.h:5919
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
uint32 tif_row
Definition: tiffiop.h:159
#define SeekOK(tif, off)
Definition: tiffiop.h:256
uint32 tif_col
Definition: tiffiop.h:168

Referenced by TIFFFillStrip(), and TIFFFillTile().

◆ TIFFReadRawTile()

tmsize_t TIFFReadRawTile ( TIFF tif,
uint32  tile,
void buf,
tmsize_t  size 
)

Definition at line 1167 of file tif_read.c.

1168 {
1169  static const char module[] = "TIFFReadRawTile";
1170  TIFFDirectory *td = &tif->tif_dir;
1171  uint64 bytecount64;
1172  tmsize_t bytecountm;
1173 
1174  if (!TIFFCheckRead(tif, 1))
1175  return ((tmsize_t)(-1));
1176  if (tile >= td->td_nstrips) {
1178  "%lu: Tile out of range, max %lu",
1179  (unsigned long) tile, (unsigned long) td->td_nstrips);
1180  return ((tmsize_t)(-1));
1181  }
1182  if (tif->tif_flags&TIFF_NOREADRAW)
1183  {
1185  "Compression scheme does not support access to raw uncompressed data");
1186  return ((tmsize_t)(-1));
1187  }
1188  bytecount64 = TIFFGetStrileByteCount(tif, tile);
1189  if (size != (tmsize_t)(-1) && (uint64)size <= bytecount64)
1190  bytecountm = size;
1191  else
1192  bytecountm = _TIFFCastUInt64ToSSize(tif, bytecount64, module);
1193  if( bytecountm == 0 ) {
1194  return ((tmsize_t)(-1));
1195  }
1196  return (TIFFReadRawTile1(tif, tile, buf, bytecountm, module));
1197 }
unsigned long long uint64
Definition: platform.h:18
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
thandle_t tif_clientdata
Definition: tiffiop.h:207
static tmsize_t TIFFReadRawTile1(TIFF *tif, uint32 tile, void *buf, tmsize_t size, const char *module)
Definition: tif_read.c:1094
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 tif_flags
Definition: tiffiop.h:119
uint32 td_nstrips
Definition: tif_dir.h:100
GLsizeiptr size
Definition: glext.h:5919
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
TIFFDirectory tif_dir
Definition: tiffiop.h:151
tmsize_t _TIFFCastUInt64ToSSize(TIFF *tif, uint64 val, const char *module)
Definition: tif_aux.c:83
static int TIFFCheckRead(TIFF *, int)
Definition: tif_read.c:1500
uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6305

◆ TIFFReadRawTile1()

static tmsize_t TIFFReadRawTile1 ( TIFF tif,
uint32  tile,
void buf,
tmsize_t  size,
const char module 
)
static

Definition at line 1094 of file tif_read.c.

1095 {
1096  assert((tif->tif_flags&TIFF_NOREADRAW)==0);
1097  if (!isMapped(tif)) {
1098  tmsize_t cc;
1099 
1100  if (!SeekOK(tif, TIFFGetStrileOffset(tif, tile))) {
1102  "Seek error at row %lu, col %lu, tile %lu",
1103  (unsigned long) tif->tif_row,
1104  (unsigned long) tif->tif_col,
1105  (unsigned long) tile);
1106  return ((tmsize_t)(-1));
1107  }
1108  cc = TIFFReadFile(tif, buf, size);
1109  if (cc != size) {
1110 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
1112  "Read error at row %lu, col %lu; got %I64u bytes, expected %I64u",
1113  (unsigned long) tif->tif_row,
1114  (unsigned long) tif->tif_col,
1115  (unsigned __int64) cc,
1116  (unsigned __int64) size);
1117 #else
1119  "Read error at row %lu, col %lu; got %llu bytes, expected %llu",
1120  (unsigned long) tif->tif_row,
1121  (unsigned long) tif->tif_col,
1122  (unsigned long long) cc,
1123  (unsigned long long) size);
1124 #endif
1125  return ((tmsize_t)(-1));
1126  }
1127  } else {
1128  tmsize_t ma,mb;
1129  tmsize_t n;
1130  ma=(tmsize_t)TIFFGetStrileOffset(tif, tile);
1131  mb=ma+size;
1132  if ((TIFFGetStrileOffset(tif, tile) > (uint64)TIFF_TMSIZE_T_MAX)||(ma>tif->tif_size))
1133  n=0;
1134  else if ((mb<ma)||(mb<size)||(mb>tif->tif_size))
1135  n=tif->tif_size-ma;
1136  else
1137  n=size;
1138  if (n!=size) {
1139 #if defined(__WIN32__) && (defined(_MSC_VER) || defined(__MINGW32__))
1141 "Read error at row %lu, col %lu, tile %lu; got %I64u bytes, expected %I64u",
1142  (unsigned long) tif->tif_row,
1143  (unsigned long) tif->tif_col,
1144  (unsigned long) tile,
1145  (unsigned __int64) n,
1146  (unsigned __int64) size);
1147 #else
1149 "Read error at row %lu, col %lu, tile %lu; got %llu bytes, expected %llu",
1150  (unsigned long) tif->tif_row,
1151  (unsigned long) tif->tif_col,
1152  (unsigned long) tile,
1153  (unsigned long long) n,
1154  (unsigned long long) size);
1155 #endif
1156  return ((tmsize_t)(-1));
1157  }
1158  _TIFFmemcpy(buf, tif->tif_base + ma, size);
1159  }
1160  return (size);
1161 }
unsigned long long uint64
Definition: platform.h:18
uint8 * tif_base
Definition: tiffiop.h:202
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
GLdouble n
Definition: glext.h:7729
#define assert(x)
Definition: debug.h:53
thandle_t tif_clientdata
Definition: tiffiop.h:207
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 tif_flags
Definition: tiffiop.h:119
uint64 TIFFGetStrileOffset(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6290
#define isMapped(tif)
Definition: tiffiop.h:230
GLsizeiptr size
Definition: glext.h:5919
if(!(yy_init))
Definition: macro.lex.yy.c:714
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t tif_size
Definition: tiffiop.h:203
#define TIFF_TMSIZE_T_MAX
Definition: tiffiop.h:81
uint32_t cc
Definition: isohybrid.c:75
uint32 tif_row
Definition: tiffiop.h:159
#define SeekOK(tif, off)
Definition: tiffiop.h:256
uint32 tif_col
Definition: tiffiop.h:168
#define TIFFReadFile(tif, buf, size)
Definition: tiffiop.h:233
void _TIFFmemcpy(void *d, const void *s, tmsize_t c)
Definition: tif_unix.c:344
#define __int64
Definition: basetyps.h:16

Referenced by TIFFFillTile(), TIFFReadEncodedTile(), and TIFFReadRawTile().

◆ TIFFReadScanline()

int TIFFReadScanline ( TIFF tif,
void buf,
uint32  row,
uint16  sample 
)

Definition at line 460 of file tif_read.c.

461 {
462  int e;
463 
464  if (!TIFFCheckRead(tif, 0))
465  return (-1);
466  if( (e = TIFFSeek(tif, row, sample)) != 0) {
467  /*
468  * Decompress desired row into user buffer.
469  */
470  e = (*tif->tif_decoderow)
471  (tif, (uint8*) buf, tif->tif_scanlinesize, sample);
472 
473  /* we are now poised at the beginning of the next row */
474  tif->tif_row = row + 1;
475 
476  if (e)
477  (*tif->tif_postdecode)(tif, (uint8*) buf,
478  tif->tif_scanlinesize);
479  }
480  return (e > 0 ? 1 : -1);
481 }
TIFFCodeMethod tif_decoderow
Definition: tiffiop.h:180
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
tmsize_t tif_scanlinesize
Definition: tiffiop.h:193
#define e
Definition: ke_i.h:82
TIFFPostMethod tif_postdecode
Definition: tiffiop.h:214
unsigned char uint8
Definition: types.h:28
static int TIFFSeek(TIFF *tif, uint32 row, uint16 sample)
Definition: tif_read.c:329
uint32 tif_row
Definition: tiffiop.h:159
static int TIFFCheckRead(TIFF *, int)
Definition: tif_read.c:1500
struct png_info_def *typedef unsigned char **typedef struct png_info_def *typedef struct png_info_def *typedef struct png_info_def *typedef unsigned char ** row
Definition: typeof.h:78

◆ TIFFReadTile()

tmsize_t TIFFReadTile ( TIFF tif,
void buf,
uint32  x,
uint32  y,
uint32  z,
uint16  s 
)

Definition at line 965 of file tif_read.c.

966 {
967  if (!TIFFCheckRead(tif, 1) || !TIFFCheckTile(tif, x, y, z, s))
968  return ((tmsize_t)(-1));
969  return (TIFFReadEncodedTile(tif,
970  TIFFComputeTile(tif, x, y, z, s), buf, (tmsize_t)(-1)));
971 }
int TIFFCheckTile(TIFF *tif, uint32 x, uint32 y, uint32 z, uint16 s)
Definition: tif_tile.c:73
uint32 TIFFComputeTile(TIFF *tif, uint32 x, uint32 y, uint32 z, uint16 s)
Definition: tif_tile.c:36
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
tmsize_t TIFFReadEncodedTile(TIFF *tif, uint32 tile, void *buf, tmsize_t size)
Definition: tif_read.c:978
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
GLdouble GLdouble z
Definition: glext.h:5874
GLdouble s
Definition: gl.h:2039
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
static int TIFFCheckRead(TIFF *, int)
Definition: tif_read.c:1500

Referenced by gtTileSeparate().

◆ TIFFSeek()

static int TIFFSeek ( TIFF tif,
uint32  row,
uint16  sample 
)
static

Definition at line 329 of file tif_read.c.

330 {
331  register TIFFDirectory *td = &tif->tif_dir;
332  uint32 strip;
333  int whole_strip;
334  tmsize_t read_ahead = 0;
335 
336  /*
337  ** Establish what strip we are working from.
338  */
339  if (row >= td->td_imagelength) { /* out of range */
341  "%lu: Row out of range, max %lu",
342  (unsigned long) row,
343  (unsigned long) td->td_imagelength);
344  return (0);
345  }
347  if (sample >= td->td_samplesperpixel) {
349  "%lu: Sample out of range, max %lu",
350  (unsigned long) sample, (unsigned long) td->td_samplesperpixel);
351  return (0);
352  }
353  strip = (uint32)sample*td->td_stripsperimage + row/td->td_rowsperstrip;
354  } else
355  strip = row / td->td_rowsperstrip;
356 
357  /*
358  * Do we want to treat this strip as one whole chunk or
359  * read it a few lines at a time?
360  */
361 #if defined(CHUNKY_STRIP_READ_SUPPORT)
362  whole_strip = TIFFGetStrileByteCount(tif, strip) < 10
363  || isMapped(tif);
364  if( td->td_compression == COMPRESSION_LERC ||
366  {
367  /* Ideally plugins should have a way to declare they don't support
368  * chunk strip */
369  whole_strip = 1;
370  }
371 #else
372  whole_strip = 1;
373 #endif
374 
375  if( !whole_strip )
376  {
377  /* 16 is for YCbCr mode where we may need to read 16 */
378  /* lines at a time to get a decompressed line, and 5000 */
379  /* is some constant value, for example for JPEG tables */
380  if( tif->tif_scanlinesize < TIFF_TMSIZE_T_MAX / 16 &&
381  tif->tif_scanlinesize * 16 < TIFF_TMSIZE_T_MAX - 5000 )
382  {
383  read_ahead = tif->tif_scanlinesize * 16 + 5000;
384  }
385  else
386  {
387  read_ahead = tif->tif_scanlinesize;
388  }
389  }
390 
391  /*
392  * If we haven't loaded this strip, do so now, possibly
393  * only reading the first part.
394  */
395  if (strip != tif->tif_curstrip) { /* different strip, refill */
396 
397  if( whole_strip )
398  {
399  if (!TIFFFillStrip(tif, strip))
400  return (0);
401  }
402  else
403  {
404  if( !TIFFFillStripPartial(tif,strip,read_ahead,1) )
405  return 0;
406  }
407  }
408 
409  /*
410  ** If we already have some data loaded, do we need to read some more?
411  */
412  else if( !whole_strip )
413  {
414  if( ((tif->tif_rawdata + tif->tif_rawdataloaded) - tif->tif_rawcp) < read_ahead
415  && (uint64) tif->tif_rawdataoff+tif->tif_rawdataloaded < TIFFGetStrileByteCount(tif, strip) )
416  {
417  if( !TIFFFillStripPartial(tif,strip,read_ahead,0) )
418  return 0;
419  }
420  }
421 
422  if (row < tif->tif_row) {
423  /*
424  * Moving backwards within the same strip: backup
425  * to the start and then decode forward (below).
426  *
427  * NB: If you're planning on lots of random access within a
428  * strip, it's better to just read and decode the entire
429  * strip, and then access the decoded data in a random fashion.
430  */
431 
432  if( tif->tif_rawdataoff != 0 )
433  {
434  if( !TIFFFillStripPartial(tif,strip,read_ahead,1) )
435  return 0;
436  }
437  else
438  {
439  if (!TIFFStartStrip(tif, strip))
440  return (0);
441  }
442  }
443 
444  if (row != tif->tif_row) {
445  /*
446  * Seek forward to the desired row.
447  */
448 
449  /* TODO: Will this really work with partial buffers? */
450 
451  if (!(*tif->tif_seek)(tif, row - tif->tif_row))
452  return (0);
453  tif->tif_row = row;
454  }
455 
456  return (1);
457 }
unsigned long long uint64
Definition: platform.h:18
uint8 * tif_rawcp
Definition: tiffiop.h:199
unsigned int uint32
Definition: types.h:32
uint32 tif_curstrip
Definition: tiffiop.h:161
uint8 * tif_rawdata
Definition: tiffiop.h:195
tmsize_t tif_scanlinesize
Definition: tiffiop.h:193
thandle_t tif_clientdata
Definition: tiffiop.h:207
tmsize_t tif_rawdataoff
Definition: tiffiop.h:197
char * tif_name
Definition: tiffiop.h:116
int TIFFFillStrip(TIFF *tif, uint32 strip)
Definition: tif_read.c:766
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 td_stripsperimage
Definition: tif_dir.h:99
uint16 td_planarconfig
Definition: tif_dir.h:89
#define isMapped(tif)
Definition: tiffiop.h:230
TIFFSeekMethod tif_seek
Definition: tiffiop.h:187
uint32 td_imagelength
Definition: tif_dir.h:72
#define COMPRESSION_JBIG
Definition: tiff.h:186
static int TIFFStartStrip(TIFF *tif, uint32 strip)
Definition: tif_read.c:1422
#define COMPRESSION_LERC
Definition: tiff.h:190
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t tif_rawdataloaded
Definition: tiffiop.h:198
#define PLANARCONFIG_SEPARATE
Definition: tiff.h:241
#define TIFF_TMSIZE_T_MAX
Definition: tiffiop.h:81
uint32 td_rowsperstrip
Definition: tif_dir.h:83
uint32 tif_row
Definition: tiffiop.h:159
TIFFDirectory tif_dir
Definition: tiffiop.h:151
uint16 td_samplesperpixel
Definition: tif_dir.h:82
uint16 td_compression
Definition: tif_dir.h:77
uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6305
struct png_info_def *typedef unsigned char **typedef struct png_info_def *typedef struct png_info_def *typedef struct png_info_def *typedef unsigned char ** row
Definition: typeof.h:78
static int TIFFFillStripPartial(TIFF *tif, int strip, tmsize_t read_ahead, int restart)
Definition: tif_read.c:184

Referenced by TIFFReadScanline().

◆ TIFFStartStrip()

static int TIFFStartStrip ( TIFF tif,
uint32  strip 
)
static

Definition at line 1422 of file tif_read.c.

1423 {
1424  TIFFDirectory *td = &tif->tif_dir;
1425 
1426  if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
1427  if (!(*tif->tif_setupdecode)(tif))
1428  return (0);
1429  tif->tif_flags |= TIFF_CODERSETUP;
1430  }
1431  tif->tif_curstrip = strip;
1432  tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
1433  tif->tif_flags &= ~TIFF_BUF4WRITE;
1434 
1435  if (tif->tif_flags&TIFF_NOREADRAW)
1436  {
1437  tif->tif_rawcp = NULL;
1438  tif->tif_rawcc = 0;
1439  }
1440  else
1441  {
1442  tif->tif_rawcp = tif->tif_rawdata;
1443  if( tif->tif_rawdataloaded > 0 )
1444  tif->tif_rawcc = tif->tif_rawdataloaded;
1445  else
1446  tif->tif_rawcc = (tmsize_t)TIFFGetStrileByteCount(tif, strip);
1447  }
1448  return ((*tif->tif_predecode)(tif,
1449  (uint16)(strip / td->td_stripsperimage)));
1450 }
uint8 * tif_rawcp
Definition: tiffiop.h:199
TIFFPreMethod tif_predecode
Definition: tiffiop.h:175
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
uint32 tif_curstrip
Definition: tiffiop.h:161
uint8 * tif_rawdata
Definition: tiffiop.h:195
tmsize_t tif_rawcc
Definition: tiffiop.h:200
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 td_stripsperimage
Definition: tif_dir.h:99
uint32 tif_flags
Definition: tiffiop.h:119
smooth NULL
Definition: ftsmooth.c:416
#define TIFF_BUF4WRITE
Definition: tiffiop.h:139
if(!(yy_init))
Definition: macro.lex.yy.c:714
tmsize_t tif_rawdataloaded
Definition: tiffiop.h:198
#define TIFF_CODERSETUP
Definition: tiffiop.h:124
uint32 td_rowsperstrip
Definition: tif_dir.h:83
uint32 tif_row
Definition: tiffiop.h:159
unsigned short uint16
Definition: types.h:30
TIFFDirectory tif_dir
Definition: tiffiop.h:151
uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6305
TIFFBoolMethod tif_setupdecode
Definition: tiffiop.h:174

Referenced by TIFFFillStrip(), TIFFFillStripPartial(), TIFFReadFromUserBuffer(), and TIFFSeek().

◆ TIFFStartTile()

static int TIFFStartTile ( TIFF tif,
uint32  tile 
)
static

Definition at line 1457 of file tif_read.c.

1458 {
1459  static const char module[] = "TIFFStartTile";
1460  TIFFDirectory *td = &tif->tif_dir;
1461  uint32 howmany32;
1462 
1463  if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
1464  if (!(*tif->tif_setupdecode)(tif))
1465  return (0);
1466  tif->tif_flags |= TIFF_CODERSETUP;
1467  }
1468  tif->tif_curtile = tile;
1469  howmany32=TIFFhowmany_32(td->td_imagewidth, td->td_tilewidth);
1470  if (howmany32 == 0) {
1471  TIFFErrorExt(tif->tif_clientdata,module,"Zero tiles");
1472  return 0;
1473  }
1474  tif->tif_row = (tile % howmany32) * td->td_tilelength;
1475  howmany32=TIFFhowmany_32(td->td_imagelength, td->td_tilelength);
1476  if (howmany32 == 0) {
1477  TIFFErrorExt(tif->tif_clientdata,module,"Zero tiles");
1478  return 0;
1479  }
1480  tif->tif_col = (tile % howmany32) * td->td_tilewidth;
1481  tif->tif_flags &= ~TIFF_BUF4WRITE;
1482  if (tif->tif_flags&TIFF_NOREADRAW)
1483  {
1484  tif->tif_rawcp = NULL;
1485  tif->tif_rawcc = 0;
1486  }
1487  else
1488  {
1489  tif->tif_rawcp = tif->tif_rawdata;
1490  if( tif->tif_rawdataloaded > 0 )
1491  tif->tif_rawcc = tif->tif_rawdataloaded;
1492  else
1493  tif->tif_rawcc = (tmsize_t)TIFFGetStrileByteCount(tif, tile);
1494  }
1495  return ((*tif->tif_predecode)(tif,
1496  (uint16)(tile/td->td_stripsperimage)));
1497 }
uint8 * tif_rawcp
Definition: tiffiop.h:199
TIFFPreMethod tif_predecode
Definition: tiffiop.h:175
#define TIFFhowmany_32(x, y)
Definition: tiffiop.h:264
unsigned int uint32
Definition: types.h:32
#define TIFF_NOREADRAW
Definition: tiffiop.h:136
uint8 * tif_rawdata
Definition: tiffiop.h:195
thandle_t tif_clientdata
Definition: tiffiop.h:207
tmsize_t tif_rawcc
Definition: tiffiop.h:200
uint32 td_tilelength
Definition: tif_dir.h:73
TIFF_SSIZE_T tmsize_t
Definition: tiffio.h:65
uint32 td_stripsperimage
Definition: tif_dir.h:99
uint32 tif_flags
Definition: tiffiop.h:119
smooth NULL
Definition: ftsmooth.c:416
#define TIFF_BUF4WRITE
Definition: tiffiop.h:139
if(!(yy_init))
Definition: macro.lex.yy.c:714
uint32 td_imagelength
Definition: tif_dir.h:72
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:65
tmsize_t tif_rawdataloaded
Definition: tiffiop.h:198
uint32 tif_curtile
Definition: tiffiop.h:169
uint32 td_tilewidth
Definition: tif_dir.h:73
#define TIFF_CODERSETUP
Definition: tiffiop.h:124
uint32 tif_row
Definition: tiffiop.h:159
unsigned short uint16
Definition: types.h:30
TIFFDirectory tif_dir
Definition: tiffiop.h:151
uint32 tif_col
Definition: tiffiop.h:168
uint32 td_imagewidth
Definition: tif_dir.h:72
uint64 TIFFGetStrileByteCount(TIFF *tif, uint32 strile)
Definition: tif_dirread.c:6305
TIFFBoolMethod tif_setupdecode
Definition: tiffiop.h:174

Referenced by TIFFFillTile(), and TIFFReadFromUserBuffer().