PageRenderTime 64ms CodeModel.GetById 15ms app.highlight 43ms RepoModel.GetById 1ms app.codeStats 0ms

/src/FreeImage/Source/LibTIFF/tif_read.c

https://bitbucket.org/cabalistic/ogredeps/
C | 750 lines | 517 code | 48 blank | 185 comment | 120 complexity | bb36fa0c041c9264289a4ece6a39999d MD5 | raw file
  1/* $Id: tif_read.c,v 1.37 2011/04/10 17:14:09 drolon Exp $ */
  2
  3/*
  4 * Copyright (c) 1988-1997 Sam Leffler
  5 * Copyright (c) 1991-1997 Silicon Graphics, Inc.
  6 *
  7 * Permission to use, copy, modify, distribute, and sell this software and 
  8 * its documentation for any purpose is hereby granted without fee, provided
  9 * that (i) the above copyright notices and this permission notice appear in
 10 * all copies of the software and related documentation, and (ii) the names of
 11 * Sam Leffler and Silicon Graphics may not be used in any advertising or
 12 * publicity relating to the software without the specific, prior written
 13 * permission of Sam Leffler and Silicon Graphics.
 14 * 
 15 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
 16 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
 17 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
 18 * 
 19 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
 20 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
 21 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
 22 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
 23 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
 24 * OF THIS SOFTWARE.
 25 */
 26
 27/*
 28 * TIFF Library.
 29 * Scanline-oriented Read Support
 30 */
 31#include "tiffiop.h"
 32#include <stdio.h>
 33
 34	int TIFFFillStrip(TIFF*, tstrip_t);
 35	int TIFFFillTile(TIFF*, ttile_t);
 36static	int TIFFStartStrip(TIFF*, tstrip_t);
 37static	int TIFFStartTile(TIFF*, ttile_t);
 38static	int TIFFCheckRead(TIFF*, int);
 39
 40#define	NOSTRIP	((tstrip_t) -1)			/* undefined state */
 41#define	NOTILE	((ttile_t) -1)			/* undefined state */
 42
 43/*
 44 * Seek to a random row+sample in a file.
 45 */
 46static int
 47TIFFSeek(TIFF* tif, uint32 row, tsample_t sample)
 48{
 49	register TIFFDirectory *td = &tif->tif_dir;
 50	tstrip_t strip;
 51
 52	if (row >= td->td_imagelength) {	/* out of range */
 53		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 54			     "%lu: Row out of range, max %lu",
 55			     (unsigned long) row,
 56			     (unsigned long) td->td_imagelength);
 57		return (0);
 58	}
 59	if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
 60		if (sample >= td->td_samplesperpixel) {
 61			TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
 62			    "%lu: Sample out of range, max %lu",
 63			    (unsigned long) sample, (unsigned long) td->td_samplesperpixel);
 64			return (0);
 65		}
 66		strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip;
 67	} else
 68		strip = row / td->td_rowsperstrip;
 69	if (strip != tif->tif_curstrip) {	/* different strip, refill */
 70		if (!TIFFFillStrip(tif, strip))
 71			return (0);
 72	} else if (row < tif->tif_row) {
 73		/*
 74		 * Moving backwards within the same strip: backup
 75		 * to the start and then decode forward (below).
 76		 *
 77		 * NB: If you're planning on lots of random access within a
 78		 * strip, it's better to just read and decode the entire
 79		 * strip, and then access the decoded data in a random fashion.
 80		 */
 81		if (!TIFFStartStrip(tif, strip))
 82			return (0);
 83	}
 84	if (row != tif->tif_row) {
 85		/*
 86		 * Seek forward to the desired row.
 87		 */
 88		if (!(*tif->tif_seek)(tif, row - tif->tif_row))
 89			return (0);
 90		tif->tif_row = row;
 91	}
 92	return (1);
 93}
 94
 95int
 96TIFFReadScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
 97{
 98	int e;
 99
100	if (!TIFFCheckRead(tif, 0))
101		return (-1);
102	if( (e = TIFFSeek(tif, row, sample)) != 0) {
103		/*
104		 * Decompress desired row into user buffer.
105		 */
106		e = (*tif->tif_decoderow)
107		    (tif, (tidata_t) buf, tif->tif_scanlinesize, sample);
108
109		/* we are now poised at the beginning of the next row */
110		tif->tif_row = row + 1;
111
112		if (e)
113			(*tif->tif_postdecode)(tif, (tidata_t) buf,
114			    tif->tif_scanlinesize);
115	}
116	return (e > 0 ? 1 : -1);
117}
118
119/*
120 * Read a strip of data and decompress the specified
121 * amount into the user-supplied buffer.
122 */
123tsize_t
124TIFFReadEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
125{
126	TIFFDirectory *td = &tif->tif_dir;
127	uint32 nrows;
128	tsize_t stripsize;
129        tstrip_t sep_strip, strips_per_sep;
130
131	if (!TIFFCheckRead(tif, 0))
132		return (-1);
133	if (strip >= td->td_nstrips) {
134		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
135			     "%ld: Strip out of range, max %ld",
136			     (long) strip, (long) td->td_nstrips);
137		return (-1);
138	}
139	/*
140	 * Calculate the strip size according to the number of
141	 * rows in the strip (check for truncated last strip on any
142	 * of the separations).
143	 */
144	if( td->td_rowsperstrip >= td->td_imagelength )
145		strips_per_sep = 1;
146	else
147		strips_per_sep = (td->td_imagelength+td->td_rowsperstrip-1)
148		    / td->td_rowsperstrip;
149
150	sep_strip = strip % strips_per_sep;
151
152	if (sep_strip != strips_per_sep-1 ||
153	    (nrows = td->td_imagelength % td->td_rowsperstrip) == 0)
154		nrows = td->td_rowsperstrip;
155
156	stripsize = TIFFVStripSize(tif, nrows);
157	if (size == (tsize_t) -1)
158		size = stripsize;
159	else if (size > stripsize)
160		size = stripsize;
161	if (TIFFFillStrip(tif, strip)
162	    && (*tif->tif_decodestrip)(tif, (tidata_t) buf, size,   
163	    (tsample_t)(strip / td->td_stripsperimage)) > 0 ) {
164		(*tif->tif_postdecode)(tif, (tidata_t) buf, size);
165		return (size);
166	} else
167		return ((tsize_t) -1);
168}
169
170static tsize_t
171TIFFReadRawStrip1(TIFF* tif,
172    tstrip_t strip, tdata_t buf, tsize_t size, const char* module)
173{
174	TIFFDirectory *td = &tif->tif_dir;
175
176	assert((tif->tif_flags&TIFF_NOREADRAW)==0);
177	if (!isMapped(tif)) {
178		tsize_t cc;
179
180		if (!SeekOK(tif, td->td_stripoffset[strip])) {
181			TIFFErrorExt(tif->tif_clientdata, module,
182			    "%s: Seek error at scanline %lu, strip %lu",
183			    tif->tif_name,
184			    (unsigned long) tif->tif_row, (unsigned long) strip);
185			return (-1);
186		}
187		cc = TIFFReadFile(tif, buf, size);
188		if (cc != size) {
189			TIFFErrorExt(tif->tif_clientdata, module,
190		"%s: Read error at scanline %lu; got %lu bytes, expected %lu",
191			    tif->tif_name,
192			    (unsigned long) tif->tif_row,
193			    (unsigned long) cc,
194			    (unsigned long) size);
195			return (-1);
196		}
197	} else {
198		if (td->td_stripoffset[strip] + size > tif->tif_size) {
199			TIFFErrorExt(tif->tif_clientdata, module,
200    "%s: Read error at scanline %lu, strip %lu; got %lu bytes, expected %lu",
201			    tif->tif_name,
202			    (unsigned long) tif->tif_row,
203			    (unsigned long) strip,
204			    (unsigned long) tif->tif_size - td->td_stripoffset[strip],
205			    (unsigned long) size);
206			return (-1);
207		}
208		_TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[strip],
209                            size);
210	}
211	return (size);
212}
213
214/*
215 * Read a strip of data from the file.
216 */
217tsize_t
218TIFFReadRawStrip(TIFF* tif, tstrip_t strip, tdata_t buf, tsize_t size)
219{
220	static const char module[] = "TIFFReadRawStrip";
221	TIFFDirectory *td = &tif->tif_dir;
222	/*
223	 * FIXME: butecount should have tsize_t type, but for now libtiff
224	 * defines tsize_t as a signed 32-bit integer and we are losing
225	 * ability to read arrays larger than 2^31 bytes. So we are using
226	 * uint32 instead of tsize_t here.
227	 */
228	uint32 bytecount;
229
230	if (!TIFFCheckRead(tif, 0))
231		return ((tsize_t) -1);
232	if (strip >= td->td_nstrips) {
233		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
234			     "%lu: Strip out of range, max %lu",
235			     (unsigned long) strip,
236			     (unsigned long) td->td_nstrips);
237		return ((tsize_t) -1);
238	}
239	if (tif->tif_flags&TIFF_NOREADRAW)
240	{
241		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
242	"Compression scheme does not support access to raw uncompressed data");
243		return ((tsize_t) -1);
244	}
245	bytecount = td->td_stripbytecount[strip];
246	if (bytecount <= 0) {
247		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
248		    "%lu: Invalid strip byte count, strip %lu",
249		    (unsigned long) bytecount, (unsigned long) strip);
250		return ((tsize_t) -1);
251	}
252	if (size != (tsize_t)-1 && (uint32)size < bytecount)
253		bytecount = size;
254	return (TIFFReadRawStrip1(tif, strip, buf, bytecount, module));
255}
256
257/*
258 * Read the specified strip and setup for decoding. The data buffer is
259 * expanded, as necessary, to hold the strip's data.
260 */
261int
262TIFFFillStrip(TIFF* tif, tstrip_t strip)
263{
264	static const char module[] = "TIFFFillStrip";
265	TIFFDirectory *td = &tif->tif_dir;
266
267	if ((tif->tif_flags&TIFF_NOREADRAW)==0)
268	{
269		/*
270		 * FIXME: butecount should have tsize_t type, but for now
271		 * libtiff defines tsize_t as a signed 32-bit integer and we
272		 * are losing ability to read arrays larger than 2^31 bytes.
273		 * So we are using uint32 instead of tsize_t here.
274		 */
275		uint32 bytecount = td->td_stripbytecount[strip];
276		if (bytecount <= 0) {
277			TIFFErrorExt(tif->tif_clientdata, module,
278			    "%s: Invalid strip byte count %lu, strip %lu",
279			    tif->tif_name, (unsigned long) bytecount,
280			    (unsigned long) strip);
281			return (0);
282		}
283		if (isMapped(tif) &&
284		    (isFillOrder(tif, td->td_fillorder)
285		    || (tif->tif_flags & TIFF_NOBITREV))) {
286			/*
287			 * The image is mapped into memory and we either don't
288			 * need to flip bits or the compression routine is
289			 * going to handle this operation itself.  In this
290			 * case, avoid copying the raw data and instead just
291			 * reference the data from the memory mapped file
292			 * image.  This assumes that the decompression
293			 * routines do not modify the contents of the raw data
294			 * buffer (if they try to, the application will get a
295			 * fault since the file is mapped read-only).
296			 */
297			if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
298				_TIFFfree(tif->tif_rawdata);
299			tif->tif_flags &= ~TIFF_MYBUFFER;
300			/*
301			 * We must check for overflow, potentially causing
302			 * an OOB read. Instead of simple
303			 *
304			 *  td->td_stripoffset[strip]+bytecount > tif->tif_size
305			 *
306			 * comparison (which can overflow) we do the following
307			 * two comparisons:
308			 */
309			if (bytecount > tif->tif_size ||
310			    td->td_stripoffset[strip] > tif->tif_size - bytecount) {
311				/*
312				 * This error message might seem strange, but
313				 * it's what would happen if a read were done
314				 * instead.
315				 */
316				TIFFErrorExt(tif->tif_clientdata, module,
317
318					"%s: Read error on strip %lu; "
319					"got %lu bytes, expected %lu",
320					tif->tif_name, (unsigned long) strip,
321					(unsigned long) tif->tif_size - td->td_stripoffset[strip],
322					(unsigned long) bytecount);
323				tif->tif_curstrip = NOSTRIP;
324				return (0);
325			}
326			tif->tif_rawdatasize = bytecount;
327			tif->tif_rawdata = tif->tif_base + td->td_stripoffset[strip];
328		} else {
329			/*
330			 * Expand raw data buffer, if needed, to hold data
331			 * strip coming from file (perhaps should set upper
332			 * bound on the size of a buffer we'll use?).
333			 */
334			if (bytecount > (uint32)tif->tif_rawdatasize) {
335				tif->tif_curstrip = NOSTRIP;
336				if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
337					TIFFErrorExt(tif->tif_clientdata,
338						     module,
339				"%s: Data buffer too small to hold strip %lu",
340						     tif->tif_name,
341						     (unsigned long) strip);
342					return (0);
343				}
344				if (!TIFFReadBufferSetup(tif, 0,
345				    TIFFroundup(bytecount, 1024)))
346					return (0);
347			}
348			if ((uint32)TIFFReadRawStrip1(tif, strip,
349				(unsigned char *)tif->tif_rawdata,
350				bytecount, module) != bytecount)
351				return (0);
352			if (!isFillOrder(tif, td->td_fillorder) &&
353			    (tif->tif_flags & TIFF_NOBITREV) == 0)
354				TIFFReverseBits(tif->tif_rawdata, bytecount);
355		}
356	}
357	return (TIFFStartStrip(tif, strip));
358}
359
360/*
361 * Tile-oriented Read Support
362 * Contributed by Nancy Cam (Silicon Graphics).
363 */
364
365/*
366 * Read and decompress a tile of data.  The
367 * tile is selected by the (x,y,z,s) coordinates.
368 */
369tsize_t
370TIFFReadTile(TIFF* tif,
371    tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
372{
373	if (!TIFFCheckRead(tif, 1) || !TIFFCheckTile(tif, x, y, z, s))
374		return (-1);
375	return (TIFFReadEncodedTile(tif,
376	    TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1));
377}
378
379/*
380 * Read a tile of data and decompress the specified
381 * amount into the user-supplied buffer.
382 */
383tsize_t
384TIFFReadEncodedTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
385{
386	TIFFDirectory *td = &tif->tif_dir;
387	tsize_t tilesize = tif->tif_tilesize;
388
389	if (!TIFFCheckRead(tif, 1))
390		return (-1);
391	if (tile >= td->td_nstrips) {
392		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
393			     "%ld: Tile out of range, max %ld",
394			     (long) tile, (unsigned long) td->td_nstrips);
395		return (-1);
396	}
397	if (size == (tsize_t) -1)
398		size = tilesize;
399	else if (size > tilesize)
400		size = tilesize;
401	if (TIFFFillTile(tif, tile) && (*tif->tif_decodetile)(tif,
402	    (tidata_t) buf, size, (tsample_t)(tile/td->td_stripsperimage))) {
403		(*tif->tif_postdecode)(tif, (tidata_t) buf, size);
404		return (size);
405	} else
406		return (-1);
407}
408
409static tsize_t
410TIFFReadRawTile1(TIFF* tif,
411    ttile_t tile, tdata_t buf, tsize_t size, const char* module)
412{
413	TIFFDirectory *td = &tif->tif_dir;
414
415	assert((tif->tif_flags&TIFF_NOREADRAW)==0);
416	if (!isMapped(tif)) {
417		tsize_t cc;
418
419		if (!SeekOK(tif, td->td_stripoffset[tile])) {
420			TIFFErrorExt(tif->tif_clientdata, module,
421			    "%s: Seek error at row %ld, col %ld, tile %ld",
422			    tif->tif_name,
423			    (long) tif->tif_row,
424			    (long) tif->tif_col,
425			    (long) tile);
426			return ((tsize_t) -1);
427		}
428		cc = TIFFReadFile(tif, buf, size);
429		if (cc != size) {
430			TIFFErrorExt(tif->tif_clientdata, module,
431	    "%s: Read error at row %ld, col %ld; got %lu bytes, expected %lu",
432			    tif->tif_name,
433			    (long) tif->tif_row,
434			    (long) tif->tif_col,
435			    (unsigned long) cc,
436			    (unsigned long) size);
437			return ((tsize_t) -1);
438		}
439	} else {
440		if (td->td_stripoffset[tile] + size > tif->tif_size) {
441			TIFFErrorExt(tif->tif_clientdata, module,
442    "%s: Read error at row %ld, col %ld, tile %ld; got %lu bytes, expected %lu",
443			    tif->tif_name,
444			    (long) tif->tif_row,
445			    (long) tif->tif_col,
446			    (long) tile,
447			    (unsigned long) tif->tif_size - td->td_stripoffset[tile],
448			    (unsigned long) size);
449			return ((tsize_t) -1);
450		}
451		_TIFFmemcpy(buf, tif->tif_base + td->td_stripoffset[tile], size);
452	}
453	return (size);
454}
455
456/*
457 * Read a tile of data from the file.
458 */
459tsize_t
460TIFFReadRawTile(TIFF* tif, ttile_t tile, tdata_t buf, tsize_t size)
461{
462	static const char module[] = "TIFFReadRawTile";
463	TIFFDirectory *td = &tif->tif_dir;
464	/*
465	 * FIXME: butecount should have tsize_t type, but for now libtiff
466	 * defines tsize_t as a signed 32-bit integer and we are losing
467	 * ability to read arrays larger than 2^31 bytes. So we are using
468	 * uint32 instead of tsize_t here.
469	 */
470	uint32 bytecount;
471
472	if (!TIFFCheckRead(tif, 1))
473		return ((tsize_t) -1);
474	if (tile >= td->td_nstrips) {
475		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
476			     "%lu: Tile out of range, max %lu",
477		    (unsigned long) tile, (unsigned long) td->td_nstrips);
478		return ((tsize_t) -1);
479	}
480	if (tif->tif_flags&TIFF_NOREADRAW)
481	{
482		TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
483	"Compression scheme does not support access to raw uncompressed data");
484		return ((tsize_t) -1);
485	}
486	bytecount = td->td_stripbytecount[tile];
487	if (size != (tsize_t) -1 && (uint32)size < bytecount)
488		bytecount = size;
489	return (TIFFReadRawTile1(tif, tile, buf, bytecount, module));
490}
491
492/*
493 * Read the specified tile and setup for decoding. The data buffer is
494 * expanded, as necessary, to hold the tile's data.
495 */
496int
497TIFFFillTile(TIFF* tif, ttile_t tile)
498{
499	static const char module[] = "TIFFFillTile";
500	TIFFDirectory *td = &tif->tif_dir;
501
502	if ((tif->tif_flags&TIFF_NOREADRAW)==0)
503	{
504		/*
505		 * FIXME: butecount should have tsize_t type, but for now
506		 * libtiff defines tsize_t as a signed 32-bit integer and we
507		 * are losing ability to read arrays larger than 2^31 bytes.
508		 * So we are using uint32 instead of tsize_t here.
509		 */
510		uint32 bytecount = td->td_stripbytecount[tile];
511		if (bytecount <= 0) {
512			TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
513			    "%lu: Invalid tile byte count, tile %lu",
514			    (unsigned long) bytecount, (unsigned long) tile);
515			return (0);
516		}
517		if (isMapped(tif) &&
518		    (isFillOrder(tif, td->td_fillorder)
519		     || (tif->tif_flags & TIFF_NOBITREV))) {
520			/*
521			 * The image is mapped into memory and we either don't
522			 * need to flip bits or the compression routine is
523			 * going to handle this operation itself.  In this
524			 * case, avoid copying the raw data and instead just
525			 * reference the data from the memory mapped file
526			 * image.  This assumes that the decompression
527			 * routines do not modify the contents of the raw data
528			 * buffer (if they try to, the application will get a
529			 * fault since the file is mapped read-only).
530			 */
531			if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)
532				_TIFFfree(tif->tif_rawdata);
533			tif->tif_flags &= ~TIFF_MYBUFFER;
534			/*
535			 * We must check for overflow, potentially causing
536			 * an OOB read. Instead of simple
537			 *
538			 *  td->td_stripoffset[tile]+bytecount > tif->tif_size
539			 *
540			 * comparison (which can overflow) we do the following
541			 * two comparisons:
542			 */
543			if (bytecount > tif->tif_size ||
544			    td->td_stripoffset[tile] > tif->tif_size - bytecount) {
545				tif->tif_curtile = NOTILE;
546				return (0);
547			}
548			tif->tif_rawdatasize = bytecount;
549			tif->tif_rawdata =
550				tif->tif_base + td->td_stripoffset[tile];
551		} else {
552			/*
553			 * Expand raw data buffer, if needed, to hold data
554			 * tile coming from file (perhaps should set upper
555			 * bound on the size of a buffer we'll use?).
556			 */
557			if (bytecount > (uint32)tif->tif_rawdatasize) {
558				tif->tif_curtile = NOTILE;
559				if ((tif->tif_flags & TIFF_MYBUFFER) == 0) {
560					TIFFErrorExt(tif->tif_clientdata,
561						     module,
562				"%s: Data buffer too small to hold tile %ld",
563						     tif->tif_name,
564						     (long) tile);
565					return (0);
566				}
567				if (!TIFFReadBufferSetup(tif, 0,
568				    TIFFroundup(bytecount, 1024)))
569					return (0);
570			}
571			if ((uint32)TIFFReadRawTile1(tif, tile,
572				(unsigned char *)tif->tif_rawdata,
573				bytecount, module) != bytecount)
574				return (0);
575			if (!isFillOrder(tif, td->td_fillorder) &&
576			    (tif->tif_flags & TIFF_NOBITREV) == 0)
577				TIFFReverseBits(tif->tif_rawdata, bytecount);
578		}
579	}
580	return (TIFFStartTile(tif, tile));
581}
582
583/*
584 * Setup the raw data buffer in preparation for
585 * reading a strip of raw data.  If the buffer
586 * is specified as zero, then a buffer of appropriate
587 * size is allocated by the library.  Otherwise,
588 * the client must guarantee that the buffer is
589 * large enough to hold any individual strip of
590 * raw data.
591 */
592int
593TIFFReadBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
594{
595	static const char module[] = "TIFFReadBufferSetup";
596
597	assert((tif->tif_flags&TIFF_NOREADRAW)==0);
598	if (tif->tif_rawdata) {
599		if (tif->tif_flags & TIFF_MYBUFFER)
600			_TIFFfree(tif->tif_rawdata);
601		tif->tif_rawdata = NULL;
602	}
603
604	if (bp) {
605		tif->tif_rawdatasize = size;
606		tif->tif_rawdata = (tidata_t) bp;
607		tif->tif_flags &= ~TIFF_MYBUFFER;
608	} else {
609		tif->tif_rawdatasize = TIFFroundup(size, 1024);
610		if (tif->tif_rawdatasize > 0)
611			tif->tif_rawdata = (tidata_t) _TIFFmalloc(tif->tif_rawdatasize);
612		tif->tif_flags |= TIFF_MYBUFFER;
613	}
614	if ((tif->tif_rawdata == NULL) || (tif->tif_rawdatasize == 0)) {
615		TIFFErrorExt(tif->tif_clientdata, module,
616		    "%s: No space for data buffer at scanline %ld",
617		    tif->tif_name, (long) tif->tif_row);
618		tif->tif_rawdatasize = 0;
619		return (0);
620	}
621	return (1);
622}
623
624/*
625 * Set state to appear as if a
626 * strip has just been read in.
627 */
628static int
629TIFFStartStrip(TIFF* tif, tstrip_t strip)
630{
631	TIFFDirectory *td = &tif->tif_dir;
632
633	if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
634		if (!(*tif->tif_setupdecode)(tif))
635			return (0);
636		tif->tif_flags |= TIFF_CODERSETUP;
637	}
638	tif->tif_curstrip = strip;
639	tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
640	if (tif->tif_flags&TIFF_NOREADRAW)
641	{
642		tif->tif_rawcp = NULL;
643		tif->tif_rawcc = 0;
644	}
645	else
646	{
647		tif->tif_rawcp = tif->tif_rawdata;
648		tif->tif_rawcc = td->td_stripbytecount[strip];
649	}
650	return ((*tif->tif_predecode)(tif,
651			(tsample_t)(strip / td->td_stripsperimage)));
652}
653
654/*
655 * Set state to appear as if a
656 * tile has just been read in.
657 */
658static int
659TIFFStartTile(TIFF* tif, ttile_t tile)
660{
661	TIFFDirectory *td = &tif->tif_dir;
662
663	if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
664		if (!(*tif->tif_setupdecode)(tif))
665			return (0);
666		tif->tif_flags |= TIFF_CODERSETUP;
667	}
668	tif->tif_curtile = tile;
669	tif->tif_row =
670	    (tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth)) *
671		td->td_tilelength;
672	tif->tif_col =
673	    (tile % TIFFhowmany(td->td_imagelength, td->td_tilelength)) *
674		td->td_tilewidth;
675	if (tif->tif_flags&TIFF_NOREADRAW)
676	{
677		tif->tif_rawcp = NULL;
678		tif->tif_rawcc = 0;
679	}
680	else
681	{
682		tif->tif_rawcp = tif->tif_rawdata;
683		tif->tif_rawcc = td->td_stripbytecount[tile];
684	}
685	return ((*tif->tif_predecode)(tif,
686			(tsample_t)(tile/td->td_stripsperimage)));
687}
688
689static int
690TIFFCheckRead(TIFF* tif, int tiles)
691{
692	if (tif->tif_mode == O_WRONLY) {
693		TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "File not open for reading");
694		return (0);
695	}
696	if (tiles ^ isTiled(tif)) {
697		TIFFErrorExt(tif->tif_clientdata, tif->tif_name, tiles ?
698		    "Can not read tiles from a stripped image" :
699		    "Can not read scanlines from a tiled image");
700		return (0);
701	}
702	return (1);
703}
704
705void
706_TIFFNoPostDecode(TIFF* tif, tidata_t buf, tsize_t cc)
707{
708    (void) tif; (void) buf; (void) cc;
709}
710
711void
712_TIFFSwab16BitData(TIFF* tif, tidata_t buf, tsize_t cc)
713{
714    (void) tif;
715    assert((cc & 1) == 0);
716    TIFFSwabArrayOfShort((uint16*) buf, cc/2);
717}
718
719void
720_TIFFSwab24BitData(TIFF* tif, tidata_t buf, tsize_t cc)
721{
722    (void) tif;
723    assert((cc % 3) == 0);
724    TIFFSwabArrayOfTriples((uint8*) buf, cc/3);
725}
726
727void
728_TIFFSwab32BitData(TIFF* tif, tidata_t buf, tsize_t cc)
729{
730    (void) tif;
731    assert((cc & 3) == 0);
732    TIFFSwabArrayOfLong((uint32*) buf, cc/4);
733}
734
735void
736_TIFFSwab64BitData(TIFF* tif, tidata_t buf, tsize_t cc)
737{
738    (void) tif;
739    assert((cc & 7) == 0);
740    TIFFSwabArrayOfDouble((double*) buf, cc/8);
741}
742
743/* vim: set ts=8 sts=8 sw=8 noet: */
744/*
745 * Local Variables:
746 * mode: c
747 * c-basic-offset: 8
748 * fill-column: 78
749 * End:
750 */