| Bsoft 1.9 Bernard's software package

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

tif_read.c
Go to the documentation of this file.
1 /* $Id: tif_read.c,v 1.16.2.3 2010-06-09 14:32:47 bfriesen 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);
36 static int TIFFStartStrip(TIFF*, tstrip_t);
37 static int TIFFStartTile(TIFF*, ttile_t);
38 static 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 */
46 static int
47 TIFFSeek(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
95 int
96 TIFFReadScanline(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 */
123 tsize_t
124 TIFFReadEncodedStrip(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
170 static tsize_t
171 TIFFReadRawStrip1(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 */
217 tsize_t
218 TIFFReadRawStrip(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 */
261 int
262 TIFFFillStrip(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 */
369 tsize_t
370 TIFFReadTile(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 */
383 tsize_t
384 TIFFReadEncodedTile(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
409 static tsize_t
410 TIFFReadRawTile1(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 */
459 tsize_t
460 TIFFReadRawTile(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 */
496 int
497 TIFFFillTile(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 */
592 int
593 TIFFReadBufferSetup(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 */
628 static int
629 TIFFStartStrip(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 */
658 static int
659 TIFFStartTile(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
689 static int
690 TIFFCheckRead(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
705 void
706 _TIFFNoPostDecode(TIFF* tif, tidata_t buf, tsize_t cc)
707 {
708 (void) tif; (void) buf; (void) cc;
709 }
710
711 void
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
719 void
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
727 void
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
735 void
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 */
tsize_t
int32 tsize_t
Definition: tiffio.h:67
tsample_t
uint16 tsample_t
Definition: tiffio.h:63
tiff::tif_decoderow
TIFFCodeMethod tif_decoderow
Definition: tiffiop.h:159
tdata_t
void * tdata_t
Definition: tiffio.h:68
TIFFReverseBits
void TIFFReverseBits(register unsigned char *cp, register unsigned long n)
Definition: tif_swab.c:218
TIFFDirectory::td_imagewidth
uint32 td_imagewidth
Definition: tif_dir.h:41
TIFFCheckTile
int TIFFCheckTile(TIFF *tif, uint32 x, uint32 y, uint32 z, tsample_t s)
Definition: tif_tile.c:105
NOSTRIP
#define NOSTRIP
Definition: tif_read.c:40
TIFFReadRawStrip
tsize_t TIFFReadRawStrip(TIFF *tif, tstrip_t strip, tdata_t buf, tsize_t size)
Definition: tif_read.c:218
TIFFDirectory::td_stripsperimage
tstrile_t td_stripsperimage
Definition: tif_dir.h:67
tiff::tif_predecode
TIFFPreMethod tif_predecode
Definition: tiffiop.h:154
tiff::tif_curstrip
tstrip_t tif_curstrip
Definition: tiffiop.h:141
NOTILE
#define NOTILE
Definition: tif_read.c:41
TIFFhowmany
#define TIFFhowmany(x, y)
Definition: tiffiop.h:239
TIFF_NOREADRAW
#define TIFF_NOREADRAW
Definition: tiffiop.h:124
uint8
unsigned char uint8
Definition: tiff.h:67
TIFFFillStrip
int TIFFFillStrip(TIFF *, tstrip_t)
Definition: tif_read.c:262
TIFFReadScanline
int TIFFReadScanline(TIFF *tif, tdata_t buf, uint32 row, tsample_t sample)
Definition: tif_read.c:96
tiff::tif_rawdata
tidata_t tif_rawdata
Definition: tiffiop.h:174
_TIFFSwab32BitData
void _TIFFSwab32BitData(TIFF *tif, tidata_t buf, tsize_t cc)
Definition: tif_read.c:728
tstrip_t
tstrile_t tstrip_t
Definition: tiffio.h:65
tiff::tif_clientdata
thandle_t tif_clientdata
Definition: tiffiop.h:185
TIFFSwabArrayOfShort
void TIFFSwabArrayOfShort(uint16 *wp, register unsigned long n)
Definition: tif_swab.c:59
tiffiop.h
tiff::tif_name
char * tif_name
Definition: tiffiop.h:103
tiff
Definition: tiffiop.h:102
_TIFFmemcpy
void _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
Definition: tif_acorn.c:485
tiff::tif_size
toff_t tif_size
Definition: tiffiop.h:180
tiff::tif_rawcp
tidata_t tif_rawcp
Definition: tiffiop.h:176
tiff::tif_mode
int tif_mode
Definition: tiffiop.h:105
tiff::tif_flags
uint32 tif_flags
Definition: tiffiop.h:106
TIFFDirectory::td_tilewidth
uint32 td_tilewidth
Definition: tif_dir.h:42
tiff::tif_decodestrip
TIFFCodeMethod tif_decodestrip
Definition: tiffiop.h:161
TIFFReadRawTile
tsize_t TIFFReadRawTile(TIFF *tif, ttile_t tile, tdata_t buf, tsize_t size)
Definition: tif_read.c:460
TIFFDirectory::td_tilelength
uint32 td_tilelength
Definition: tif_dir.h:42
TIFFVStripSize
tsize_t TIFFVStripSize(TIFF *tif, uint32 nrows)
Definition: tif_strip.c:107
tiff::tif_base
tidata_t tif_base
Definition: tiffiop.h:179
tiff::tif_tilesize
tsize_t tif_tilesize
Definition: tiffiop.h:150
isMapped
#define isMapped(tif)
Definition: tiffiop.h:204
tiff::tif_seek
TIFFSeekMethod tif_seek
Definition: tiffiop.h:166
TIFFDirectory::td_stripoffset
toff_t * td_stripoffset
Definition: tif_dir.h:69
ttile_t
tstrile_t ttile_t
Definition: tiffio.h:66
TIFFDirectory::td_nstrips
tstrile_t td_nstrips
Definition: tif_dir.h:68
uint16
unsigned short uint16
Definition: tiff.h:71
TIFFDirectory::td_imagelength
uint32 td_imagelength
Definition: tif_dir.h:41
TIFFSwabArrayOfTriples
void TIFFSwabArrayOfTriples(uint8 *tp, unsigned long n)
Definition: tif_swab.c:75
tiff::tif_postdecode
TIFFPostMethod tif_postdecode
Definition: tiffiop.h:192
TIFFDirectory::td_rowsperstrip
uint32 td_rowsperstrip
Definition: tif_dir.h:52
TIFFDirectory
Definition: tif_dir.h:36
TIFFDirectory::td_planarconfig
uint16 td_planarconfig
Definition: tif_dir.h:57
TIFFErrorExt
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:63
TIFFFillTile
int TIFFFillTile(TIFF *, ttile_t)
Definition: tif_read.c:497
tiff::tif_rawdatasize
tsize_t tif_rawdatasize
Definition: tiffiop.h:175
TIFFSwabArrayOfLong
void TIFFSwabArrayOfLong(register uint32 *lp, register unsigned long n)
Definition: tif_swab.c:91
TIFFroundup
#define TIFFroundup(x, y)
Definition: tiffiop.h:243
tiff::tif_rawcc
tsize_t tif_rawcc
Definition: tiffiop.h:177
TIFFComputeTile
ttile_t TIFFComputeTile(TIFF *tif, uint32 x, uint32 y, uint32 z, tsample_t s)
Definition: tif_tile.c:68
tiff::tif_decodetile
TIFFCodeMethod tif_decodetile
Definition: tiffiop.h:163
TIFFReadEncodedTile
tsize_t TIFFReadEncodedTile(TIFF *tif, ttile_t tile, tdata_t buf, tsize_t size)
Definition: tif_read.c:384
TIFF_NOBITREV
#define TIFF_NOBITREV
Definition: tiffiop.h:114
PLANARCONFIG_SEPARATE
#define PLANARCONFIG_SEPARATE
Definition: tiff.h:244
isTiled
#define isTiled(tif)
Definition: tiffiop.h:203
_TIFFNoPostDecode
void _TIFFNoPostDecode(TIFF *tif, tidata_t buf, tsize_t cc)
Definition: tif_read.c:706
TIFFDirectory::td_samplesperpixel
uint16 td_samplesperpixel
Definition: tif_dir.h:51
TIFF_CODERSETUP
#define TIFF_CODERSETUP
Definition: tiffiop.h:111
tidata_t
tidataval_t * tidata_t
Definition: tiffiop.h:91
_TIFFSwab24BitData
void _TIFFSwab24BitData(TIFF *tif, tidata_t buf, tsize_t cc)
Definition: tif_read.c:720
TIFFSwabArrayOfDouble
void TIFFSwabArrayOfDouble(double *dp, register unsigned long n)
Definition: tif_swab.c:120
_TIFFSwab16BitData
void _TIFFSwab16BitData(TIFF *tif, tidata_t buf, tsize_t cc)
Definition: tif_read.c:712
tiff::tif_row
uint32 tif_row
Definition: tiffiop.h:139
tiff::tif_curtile
ttile_t tif_curtile
Definition: tiffiop.h:149
_TIFFSwab64BitData
void _TIFFSwab64BitData(TIFF *tif, tidata_t buf, tsize_t cc)
Definition: tif_read.c:736
TIFFReadBufferSetup
int TIFFReadBufferSetup(TIFF *tif, tdata_t bp, tsize_t size)
Definition: tif_read.c:593
tiff::tif_dir
TIFFDirectory tif_dir
Definition: tiffiop.h:133
tiff::tif_scanlinesize
tsize_t tif_scanlinesize
Definition: tiffiop.h:172
isFillOrder
#define isFillOrder(tif, o)
Definition: tiffiop.h:205
SeekOK
#define SeekOK(tif, off)
Definition: tiffiop.h:230
TIFFReadEncodedStrip
tsize_t TIFFReadEncodedStrip(TIFF *tif, tstrip_t strip, tdata_t buf, tsize_t size)
Definition: tif_read.c:124
_TIFFmalloc
void * _TIFFmalloc(tsize_t s)
Definition: tif_acorn.c:461
TIFFDirectory::td_stripbytecount
toff_t * td_stripbytecount
Definition: tif_dir.h:70
_TIFFfree
void _TIFFfree(tdata_t p)
Definition: tif_acorn.c:467
tiff::tif_col
uint32 tif_col
Definition: tiffiop.h:148
TIFFReadFile
#define TIFFReadFile(tif, buf, size)
Definition: tiffiop.h:207
TIFF_MYBUFFER
#define TIFF_MYBUFFER
Definition: tiffiop.h:115
TIFFReadTile
tsize_t TIFFReadTile(TIFF *tif, tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
Definition: tif_read.c:370
TIFFDirectory::td_fillorder
uint16 td_fillorder
Definition: tif_dir.h:49
tiff::tif_setupdecode
TIFFBoolMethod tif_setupdecode
Definition: tiffiop.h:153