← Back to branch summary

~ubuntu-branches/ubuntu/raring/wxwidgets2.8/raring

« back to all changes in this revision

Viewing changes to src/tiff/tif_read.c

  • Committer: Package Import Robot
  • Author(s): Stéphane Graber
  • Date: 2012-01-07 13:59:25 UTC
  • mfrom: (1.1.9) (5.1.10 sid)
  • Revision ID: package-import@ubuntu.com-20120107135925-2601miy9ullcon9j
Tags: 2.8.12.1-6ubuntu1
https://launchpad.net/bugs/632984
* Resync from Debian, changes that were kept:
  - debian/rules: re-enable mediactrl. This allows libwx_gtk2u_media-2.8 to be
    built, as this is required by some applications (LP: #632984)
  - debian/control: Build-dep on libxt-dev for mediactrl.
  - Patches
    + fix-bashism-in-example
* Add conflict on python-wxgtk2.8 (<< 2.8.12.1-6ubuntu1~) to python-wxversion
  to guarantee upgrade ordering when moving from pycentral to dh_python2.

Show diffs side-by-side

added added

removed removed

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