| Bsoft 1.9 Bernard's software package

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

tif_write.c
Go to the documentation of this file.
1 /* $Id: tif_write.c,v 1.22.2.5 2010-06-08 18:50:43 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 *
30 * Scanline-oriented Write Support
31 */
32 #include "tiffiop.h"
33 #include <stdio.h>
34
35 #define STRIPINCR 20 /* expansion factor on strip array */
36
37 #define WRITECHECKSTRIPS(tif, module) \
38 (((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),0,module))
39 #define WRITECHECKTILES(tif, module) \
40 (((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),1,module))
41 #define BUFFERCHECK(tif) \
42 ((((tif)->tif_flags & TIFF_BUFFERSETUP) && tif->tif_rawdata) || \
43 TIFFWriteBufferSetup((tif), NULL, (tsize_t) -1))
44
45 static int TIFFGrowStrips(TIFF*, int, const char*);
46 static int TIFFAppendToStrip(TIFF*, tstrip_t, tidata_t, tsize_t);
47
48 int
49 TIFFWriteScanline(TIFF* tif, tdata_t buf, uint32 row, tsample_t sample)
50 {
51 static const char module[] = "TIFFWriteScanline";
52 register TIFFDirectory *td;
53 int status, imagegrew = 0;
54 tstrip_t strip;
55
56 if (!WRITECHECKSTRIPS(tif, module))
57 return (-1);
58 /*
59 * Handle delayed allocation of data buffer. This
60 * permits it to be sized more intelligently (using
61 * directory information).
62 */
63 if (!BUFFERCHECK(tif))
64 return (-1);
65 td = &tif->tif_dir;
66 /*
67 * Extend image length if needed
68 * (but only for PlanarConfig=1).
69 */
70 if (row >= td->td_imagelength) { /* extend image */
71 if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
72 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
73 "Can not change \"ImageLength\" when using separate planes");
74 return (-1);
75 }
76 td->td_imagelength = row+1;
77 imagegrew = 1;
78 }
79 /*
80 * Calculate strip and check for crossings.
81 */
82 if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
83 if (sample >= td->td_samplesperpixel) {
84 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
85 "%d: Sample out of range, max %d",
86 sample, td->td_samplesperpixel);
87 return (-1);
88 }
89 strip = sample*td->td_stripsperimage + row/td->td_rowsperstrip;
90 } else
91 strip = row / td->td_rowsperstrip;
92 /*
93 * Check strip array to make sure there's space. We don't support
94 * dynamically growing files that have data organized in separate
95 * bitplanes because it's too painful. In that case we require that
96 * the imagelength be set properly before the first write (so that the
97 * strips array will be fully allocated above).
98 */
99 if (strip >= td->td_nstrips && !TIFFGrowStrips(tif, 1, module))
100 return (-1);
101 if (strip != tif->tif_curstrip) {
102 /*
103 * Changing strips -- flush any data present.
104 */
105 if (!TIFFFlushData(tif))
106 return (-1);
107 tif->tif_curstrip = strip;
108 /*
109 * Watch out for a growing image. The value of strips/image
110 * will initially be 1 (since it can't be deduced until the
111 * imagelength is known).
112 */
113 if (strip >= td->td_stripsperimage && imagegrew)
114 td->td_stripsperimage =
115 TIFFhowmany(td->td_imagelength,td->td_rowsperstrip);
116 tif->tif_row =
117 (strip % td->td_stripsperimage) * td->td_rowsperstrip;
118 if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
119 if (!(*tif->tif_setupencode)(tif))
120 return (-1);
121 tif->tif_flags |= TIFF_CODERSETUP;
122 }
123
124 tif->tif_rawcc = 0;
125 tif->tif_rawcp = tif->tif_rawdata;
126
127 if( td->td_stripbytecount[strip] > 0 )
128 {
129 /* if we are writing over existing tiles, zero length */
130 td->td_stripbytecount[strip] = 0;
131
132 /* this forces TIFFAppendToStrip() to do a seek */
133 tif->tif_curoff = 0;
134 }
135
136 if (!(*tif->tif_preencode)(tif, sample))
137 return (-1);
138 tif->tif_flags |= TIFF_POSTENCODE;
139 }
140 /*
141 * Ensure the write is either sequential or at the
142 * beginning of a strip (or that we can randomly
143 * access the data -- i.e. no encoding).
144 */
145 if (row != tif->tif_row) {
146 if (row < tif->tif_row) {
147 /*
148 * Moving backwards within the same strip:
149 * backup to the start and then decode
150 * forward (below).
151 */
152 tif->tif_row = (strip % td->td_stripsperimage) *
153 td->td_rowsperstrip;
154 tif->tif_rawcp = tif->tif_rawdata;
155 }
156 /*
157 * Seek forward to the desired row.
158 */
159 if (!(*tif->tif_seek)(tif, row - tif->tif_row))
160 return (-1);
161 tif->tif_row = row;
162 }
163
164 /* swab if needed - note that source buffer will be altered */
165 tif->tif_postdecode( tif, (tidata_t) buf, tif->tif_scanlinesize );
166
167 status = (*tif->tif_encoderow)(tif, (tidata_t) buf,
168 tif->tif_scanlinesize, sample);
169
170 /* we are now poised at the beginning of the next row */
171 tif->tif_row = row + 1;
172 return (status);
173 }
174
175 /*
176 * Encode the supplied data and write it to the
177 * specified strip.
178 *
179 * NB: Image length must be setup before writing.
180 */
181 tsize_t
182 TIFFWriteEncodedStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
183 {
184 static const char module[] = "TIFFWriteEncodedStrip";
185 TIFFDirectory *td = &tif->tif_dir;
186 tsample_t sample;
187
188 if (!WRITECHECKSTRIPS(tif, module))
189 return ((tsize_t) -1);
190 /*
191 * Check strip array to make sure there's space.
192 * We don't support dynamically growing files that
193 * have data organized in separate bitplanes because
194 * it's too painful. In that case we require that
195 * the imagelength be set properly before the first
196 * write (so that the strips array will be fully
197 * allocated above).
198 */
199 if (strip >= td->td_nstrips) {
200 if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
201 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
202 "Can not grow image by strips when using separate planes");
203 return ((tsize_t) -1);
204 }
205 if (!TIFFGrowStrips(tif, 1, module))
206 return ((tsize_t) -1);
207 td->td_stripsperimage =
208 TIFFhowmany(td->td_imagelength, td->td_rowsperstrip);
209 }
210 /*
211 * Handle delayed allocation of data buffer. This
212 * permits it to be sized according to the directory
213 * info.
214 */
215 if (!BUFFERCHECK(tif))
216 return ((tsize_t) -1);
217 tif->tif_curstrip = strip;
218 tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
219 if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
220 if (!(*tif->tif_setupencode)(tif))
221 return ((tsize_t) -1);
222 tif->tif_flags |= TIFF_CODERSETUP;
223 }
224
225 tif->tif_rawcc = 0;
226 tif->tif_rawcp = tif->tif_rawdata;
227
228 if( td->td_stripbytecount[strip] > 0 )
229 {
230 /* Force TIFFAppendToStrip() to consider placing data at end
231 of file. */
232 tif->tif_curoff = 0;
233 }
234
235 tif->tif_flags &= ~TIFF_POSTENCODE;
236 sample = (tsample_t)(strip / td->td_stripsperimage);
237 if (!(*tif->tif_preencode)(tif, sample))
238 return ((tsize_t) -1);
239
240 /* swab if needed - note that source buffer will be altered */
241 tif->tif_postdecode( tif, (tidata_t) data, cc );
242
243 if (!(*tif->tif_encodestrip)(tif, (tidata_t) data, cc, sample))
244 return ((tsize_t) 0);
245 if (!(*tif->tif_postencode)(tif))
246 return ((tsize_t) -1);
247 if (!isFillOrder(tif, td->td_fillorder) &&
248 (tif->tif_flags & TIFF_NOBITREV) == 0)
249 TIFFReverseBits(tif->tif_rawdata, tif->tif_rawcc);
250 if (tif->tif_rawcc > 0 &&
251 !TIFFAppendToStrip(tif, strip, tif->tif_rawdata, tif->tif_rawcc))
252 return ((tsize_t) -1);
253 tif->tif_rawcc = 0;
254 tif->tif_rawcp = tif->tif_rawdata;
255 return (cc);
256 }
257
258 /*
259 * Write the supplied data to the specified strip.
260 *
261 * NB: Image length must be setup before writing.
262 */
263 tsize_t
264 TIFFWriteRawStrip(TIFF* tif, tstrip_t strip, tdata_t data, tsize_t cc)
265 {
266 static const char module[] = "TIFFWriteRawStrip";
267 TIFFDirectory *td = &tif->tif_dir;
268
269 if (!WRITECHECKSTRIPS(tif, module))
270 return ((tsize_t) -1);
271 /*
272 * Check strip array to make sure there's space.
273 * We don't support dynamically growing files that
274 * have data organized in separate bitplanes because
275 * it's too painful. In that case we require that
276 * the imagelength be set properly before the first
277 * write (so that the strips array will be fully
278 * allocated above).
279 */
280 if (strip >= td->td_nstrips) {
281 if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
282 TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
283 "Can not grow image by strips when using separate planes");
284 return ((tsize_t) -1);
285 }
286 /*
287 * Watch out for a growing image. The value of
288 * strips/image will initially be 1 (since it
289 * can't be deduced until the imagelength is known).
290 */
291 if (strip >= td->td_stripsperimage)
292 td->td_stripsperimage =
293 TIFFhowmany(td->td_imagelength,td->td_rowsperstrip);
294 if (!TIFFGrowStrips(tif, 1, module))
295 return ((tsize_t) -1);
296 }
297 tif->tif_curstrip = strip;
298 tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
299 return (TIFFAppendToStrip(tif, strip, (tidata_t) data, cc) ?
300 cc : (tsize_t) -1);
301 }
302
303 /*
304 * Write and compress a tile of data. The
305 * tile is selected by the (x,y,z,s) coordinates.
306 */
307 tsize_t
308 TIFFWriteTile(TIFF* tif,
309 tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
310 {
311 if (!TIFFCheckTile(tif, x, y, z, s))
312 return (-1);
313 /*
314 * NB: A tile size of -1 is used instead of tif_tilesize knowing
315 * that TIFFWriteEncodedTile will clamp this to the tile size.
316 * This is done because the tile size may not be defined until
317 * after the output buffer is setup in TIFFWriteBufferSetup.
318 */
319 return (TIFFWriteEncodedTile(tif,
320 TIFFComputeTile(tif, x, y, z, s), buf, (tsize_t) -1));
321 }
322
323 /*
324 * Encode the supplied data and write it to the
325 * specified tile. There must be space for the
326 * data. The function clamps individual writes
327 * to a tile to the tile size, but does not (and
328 * can not) check that multiple writes to the same
329 * tile do not write more than tile size data.
330 *
331 * NB: Image length must be setup before writing; this
332 * interface does not support automatically growing
333 * the image on each write (as TIFFWriteScanline does).
334 */
335 tsize_t
336 TIFFWriteEncodedTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc)
337 {
338 static const char module[] = "TIFFWriteEncodedTile";
339 TIFFDirectory *td;
340 tsample_t sample;
341
342 if (!WRITECHECKTILES(tif, module))
343 return ((tsize_t) -1);
344 td = &tif->tif_dir;
345 if (tile >= td->td_nstrips) {
346 TIFFErrorExt(tif->tif_clientdata, module, "%s: Tile %lu out of range, max %lu",
347 tif->tif_name, (unsigned long) tile, (unsigned long) td->td_nstrips);
348 return ((tsize_t) -1);
349 }
350 /*
351 * Handle delayed allocation of data buffer. This
352 * permits it to be sized more intelligently (using
353 * directory information).
354 */
355 if (!BUFFERCHECK(tif))
356 return ((tsize_t) -1);
357 tif->tif_curtile = tile;
358
359 tif->tif_rawcc = 0;
360 tif->tif_rawcp = tif->tif_rawdata;
361
362 if( td->td_stripbytecount[tile] > 0 )
363 {
364 /* Force TIFFAppendToStrip() to consider placing data at end
365 of file. */
366 tif->tif_curoff = 0;
367 }
368
369 /*
370 * Compute tiles per row & per column to compute
371 * current row and column
372 */
373 tif->tif_row = (tile % TIFFhowmany(td->td_imagelength, td->td_tilelength))
374 * td->td_tilelength;
375 tif->tif_col = (tile % TIFFhowmany(td->td_imagewidth, td->td_tilewidth))
376 * td->td_tilewidth;
377
378 if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
379 if (!(*tif->tif_setupencode)(tif))
380 return ((tsize_t) -1);
381 tif->tif_flags |= TIFF_CODERSETUP;
382 }
383 tif->tif_flags &= ~TIFF_POSTENCODE;
384 sample = (tsample_t)(tile/td->td_stripsperimage);
385 if (!(*tif->tif_preencode)(tif, sample))
386 return ((tsize_t) -1);
387 /*
388 * Clamp write amount to the tile size. This is mostly
389 * done so that callers can pass in some large number
390 * (e.g. -1) and have the tile size used instead.
391 */
392 if ( cc < 1 || cc > tif->tif_tilesize)
393 cc = tif->tif_tilesize;
394
395 /* swab if needed - note that source buffer will be altered */
396 tif->tif_postdecode( tif, (tidata_t) data, cc );
397
398 if (!(*tif->tif_encodetile)(tif, (tidata_t) data, cc, sample))
399 return ((tsize_t) 0);
400 if (!(*tif->tif_postencode)(tif))
401 return ((tsize_t) -1);
402 if (!isFillOrder(tif, td->td_fillorder) &&
403 (tif->tif_flags & TIFF_NOBITREV) == 0)
404 TIFFReverseBits((unsigned char *)tif->tif_rawdata, tif->tif_rawcc);
405 if (tif->tif_rawcc > 0 && !TIFFAppendToStrip(tif, tile,
406 tif->tif_rawdata, tif->tif_rawcc))
407 return ((tsize_t) -1);
408 tif->tif_rawcc = 0;
409 tif->tif_rawcp = tif->tif_rawdata;
410 return (cc);
411 }
412
413 /*
414 * Write the supplied data to the specified strip.
415 * There must be space for the data; we don't check
416 * if strips overlap!
417 *
418 * NB: Image length must be setup before writing; this
419 * interface does not support automatically growing
420 * the image on each write (as TIFFWriteScanline does).
421 */
422 tsize_t
423 TIFFWriteRawTile(TIFF* tif, ttile_t tile, tdata_t data, tsize_t cc)
424 {
425 static const char module[] = "TIFFWriteRawTile";
426
427 if (!WRITECHECKTILES(tif, module))
428 return ((tsize_t) -1);
429 if (tile >= tif->tif_dir.td_nstrips) {
430 TIFFErrorExt(tif->tif_clientdata, module, "%s: Tile %lu out of range, max %lu",
431 tif->tif_name, (unsigned long) tile,
432 (unsigned long) tif->tif_dir.td_nstrips);
433 return ((tsize_t) -1);
434 }
435 return (TIFFAppendToStrip(tif, tile, (tidata_t) data, cc) ?
436 cc : (tsize_t) -1);
437 }
438
439 #define isUnspecified(tif, f) \
440 (TIFFFieldSet(tif,f) && (tif)->tif_dir.td_imagelength == 0)
441
442 int
443 TIFFSetupStrips(TIFF* tif)
444 {
445 TIFFDirectory* td = &tif->tif_dir;
446
447 if (isTiled(tif))
448 td->td_stripsperimage =
449 isUnspecified(tif, FIELD_TILEDIMENSIONS) ?
450 td->td_samplesperpixel : TIFFNumberOfTiles(tif);
451 else
452 td->td_stripsperimage =
453 isUnspecified(tif, FIELD_ROWSPERSTRIP) ?
454 td->td_samplesperpixel : TIFFNumberOfStrips(tif);
455 td->td_nstrips = td->td_stripsperimage;
456 if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
457 td->td_stripsperimage /= td->td_samplesperpixel;
458 td->td_stripoffset = (uint32 *)
459 _TIFFmalloc(td->td_nstrips * sizeof (uint32));
460 td->td_stripbytecount = (uint32 *)
461 _TIFFmalloc(td->td_nstrips * sizeof (uint32));
462 if (td->td_stripoffset == NULL || td->td_stripbytecount == NULL)
463 return (0);
464 /*
465 * Place data at the end-of-file
466 * (by setting offsets to zero).
467 */
468 _TIFFmemset(td->td_stripoffset, 0, td->td_nstrips*sizeof (uint32));
469 _TIFFmemset(td->td_stripbytecount, 0, td->td_nstrips*sizeof (uint32));
470 TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS);
471 TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
472 return (1);
473 }
474 #undef isUnspecified
475
476 /*
477 * Verify file is writable and that the directory
478 * information is setup properly. In doing the latter
479 * we also "freeze" the state of the directory so
480 * that important information is not changed.
481 */
482 int
483 TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
484 {
485 if (tif->tif_mode == O_RDONLY) {
486 TIFFErrorExt(tif->tif_clientdata, module, "%s: File not open for writing",
487 tif->tif_name);
488 return (0);
489 }
490 if (tiles ^ isTiled(tif)) {
491 TIFFErrorExt(tif->tif_clientdata, tif->tif_name, tiles ?
492 "Can not write tiles to a stripped image" :
493 "Can not write scanlines to a tiled image");
494 return (0);
495 }
496
497 /*
498 * On the first write verify all the required information
499 * has been setup and initialize any data structures that
500 * had to wait until directory information was set.
501 * Note that a lot of our work is assumed to remain valid
502 * because we disallow any of the important parameters
503 * from changing after we start writing (i.e. once
504 * TIFF_BEENWRITING is set, TIFFSetField will only allow
505 * the image's length to be changed).
506 */
507 if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) {
508 TIFFErrorExt(tif->tif_clientdata, module,
509 "%s: Must set \"ImageWidth\" before writing data",
510 tif->tif_name);
511 return (0);
512 }
513 if (tif->tif_dir.td_samplesperpixel == 1) {
514 /*
515 * Planarconfiguration is irrelevant in case of single band
516 * images and need not be included. We will set it anyway,
517 * because this field is used in other parts of library even
518 * in the single band case.
519 */
520 if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG))
521 tif->tif_dir.td_planarconfig = PLANARCONFIG_CONTIG;
522 } else {
523 if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) {
524 TIFFErrorExt(tif->tif_clientdata, module,
525 "%s: Must set \"PlanarConfiguration\" before writing data",
526 tif->tif_name);
527 return (0);
528 }
529 }
530 if (tif->tif_dir.td_stripoffset == NULL && !TIFFSetupStrips(tif)) {
531 tif->tif_dir.td_nstrips = 0;
532 TIFFErrorExt(tif->tif_clientdata, module, "%s: No space for %s arrays",
533 tif->tif_name, isTiled(tif) ? "tile" : "strip");
534 return (0);
535 }
536 tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tsize_t) -1;
537 tif->tif_scanlinesize = TIFFScanlineSize(tif);
538 tif->tif_flags |= TIFF_BEENWRITING;
539 return (1);
540 }
541
542 /*
543 * Setup the raw data buffer used for encoding.
544 */
545 int
546 TIFFWriteBufferSetup(TIFF* tif, tdata_t bp, tsize_t size)
547 {
548 static const char module[] = "TIFFWriteBufferSetup";
549
550 if (tif->tif_rawdata) {
551 if (tif->tif_flags & TIFF_MYBUFFER) {
552 _TIFFfree(tif->tif_rawdata);
553 tif->tif_flags &= ~TIFF_MYBUFFER;
554 }
555 tif->tif_rawdata = NULL;
556 }
557 if (size == (tsize_t) -1) {
558 size = (isTiled(tif) ?
559 tif->tif_tilesize : TIFFStripSize(tif));
560 /*
561 * Make raw data buffer at least 8K
562 */
563 if (size < 8*1024)
564 size = 8*1024;
565 bp = NULL; /* NB: force malloc */
566 }
567 if (bp == NULL) {
568 bp = _TIFFmalloc(size);
569 if (bp == NULL) {
570 TIFFErrorExt(tif->tif_clientdata, module, "%s: No space for output buffer",
571 tif->tif_name);
572 return (0);
573 }
574 tif->tif_flags |= TIFF_MYBUFFER;
575 } else
576 tif->tif_flags &= ~TIFF_MYBUFFER;
577 tif->tif_rawdata = (tidata_t) bp;
578 tif->tif_rawdatasize = size;
579 tif->tif_rawcc = 0;
580 tif->tif_rawcp = tif->tif_rawdata;
581 tif->tif_flags |= TIFF_BUFFERSETUP;
582 return (1);
583 }
584
585 /*
586 * Grow the strip data structures by delta strips.
587 */
588 static int
589 TIFFGrowStrips(TIFF* tif, int delta, const char* module)
590 {
591 TIFFDirectory *td = &tif->tif_dir;
592 uint32 *new_stripoffset, *new_stripbytecount;
593
594 assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
595 new_stripoffset = (uint32*)_TIFFrealloc(td->td_stripoffset,
596 (td->td_nstrips + delta) * sizeof (uint32));
597 new_stripbytecount = (uint32*)_TIFFrealloc(td->td_stripbytecount,
598 (td->td_nstrips + delta) * sizeof (uint32));
599 if (new_stripoffset == NULL || new_stripbytecount == NULL) {
600 if (new_stripoffset)
601 _TIFFfree(new_stripoffset);
602 if (new_stripbytecount)
603 _TIFFfree(new_stripbytecount);
604 td->td_nstrips = 0;
605 TIFFErrorExt(tif->tif_clientdata, module, "%s: No space to expand strip arrays",
606 tif->tif_name);
607 return (0);
608 }
609 td->td_stripoffset = new_stripoffset;
610 td->td_stripbytecount = new_stripbytecount;
611 _TIFFmemset(td->td_stripoffset + td->td_nstrips,
612 0, delta*sizeof (uint32));
613 _TIFFmemset(td->td_stripbytecount + td->td_nstrips,
614 0, delta*sizeof (uint32));
615 td->td_nstrips += delta;
616 return (1);
617 }
618
619 /*
620 * Append the data to the specified strip.
621 */
622 static int
623 TIFFAppendToStrip(TIFF* tif, tstrip_t strip, tidata_t data, tsize_t cc)
624 {
625 static const char module[] = "TIFFAppendToStrip";
626 TIFFDirectory *td = &tif->tif_dir;
627
628 if (td->td_stripoffset[strip] == 0 || tif->tif_curoff == 0) {
629 assert(td->td_nstrips > 0);
630
631 if( td->td_stripbytecount[strip] != 0
632 && td->td_stripoffset[strip] != 0
633 && td->td_stripbytecount[strip] >= cc )
634 {
635 /*
636 * There is already tile data on disk, and the new tile
637 * data we have to will fit in the same space. The only
638 * aspect of this that is risky is that there could be
639 * more data to append to this strip before we are done
640 * depending on how we are getting called.
641 */
642 if (!SeekOK(tif, td->td_stripoffset[strip])) {
643 TIFFErrorExt(tif->tif_clientdata, module,
644 "Seek error at scanline %lu",
645 (unsigned long)tif->tif_row);
646 return (0);
647 }
648 }
649 else
650 {
651 /*
652 * Seek to end of file, and set that as our location to
653 * write this strip.
654 */
655 td->td_stripoffset[strip] = TIFFSeekFile(tif, 0, SEEK_END);
656 }
657
658 tif->tif_curoff = td->td_stripoffset[strip];
659
660 /*
661 * We are starting a fresh strip/tile, so set the size to zero.
662 */
663 td->td_stripbytecount[strip] = 0;
664 }
665
666 if (!WriteOK(tif, data, cc)) {
667 TIFFErrorExt(tif->tif_clientdata, module, "Write error at scanline %lu",
668 (unsigned long) tif->tif_row);
669 return (0);
670 }
671 tif->tif_curoff = tif->tif_curoff+cc;
672 td->td_stripbytecount[strip] += cc;
673 return (1);
674 }
675
676 /*
677 * Internal version of TIFFFlushData that can be
678 * called by ``encodestrip routines'' w/o concern
679 * for infinite recursion.
680 */
681 int
682 TIFFFlushData1(TIFF* tif)
683 {
684 if (tif->tif_rawcc > 0) {
685 if (!isFillOrder(tif, tif->tif_dir.td_fillorder) &&
686 (tif->tif_flags & TIFF_NOBITREV) == 0)
687 TIFFReverseBits((unsigned char *)tif->tif_rawdata,
688 tif->tif_rawcc);
689 if (!TIFFAppendToStrip(tif,
690 isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip,
691 tif->tif_rawdata, tif->tif_rawcc))
692 return (0);
693 tif->tif_rawcc = 0;
694 tif->tif_rawcp = tif->tif_rawdata;
695 }
696 return (1);
697 }
698
699 /*
700 * Set the current write offset. This should only be
701 * used to set the offset to a known previous location
702 * (very carefully), or to 0 so that the next write gets
703 * appended to the end of the file.
704 */
705 void
706 TIFFSetWriteOffset(TIFF* tif, toff_t off)
707 {
708 tif->tif_curoff = off;
709 }
710
711 /* vim: set ts=8 sts=8 sw=8 noet: */
712 /*
713 * Local Variables:
714 * mode: c
715 * c-basic-offset: 8
716 * fill-column: 78
717 * End:
718 */
tsize_t
int32 tsize_t
Definition: tiffio.h:67
tsample_t
uint16 tsample_t
Definition: tiffio.h:63
TIFF_BEENWRITING
#define TIFF_BEENWRITING
Definition: tiffiop.h:112
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
TIFFDirectory::td_stripsperimage
tstrile_t td_stripsperimage
Definition: tif_dir.h:67
TIFFWriteEncodedTile
tsize_t TIFFWriteEncodedTile(TIFF *tif, ttile_t tile, tdata_t data, tsize_t cc)
Definition: tif_write.c:336
tiff::tif_curstrip
tstrip_t tif_curstrip
Definition: tiffiop.h:141
TIFFSetupStrips
int TIFFSetupStrips(TIFF *tif)
Definition: tif_write.c:443
FIELD_STRIPOFFSETS
#define FIELD_STRIPOFFSETS
Definition: tif_dir.h:126
tiff::tif_encodestrip
TIFFCodeMethod tif_encodestrip
Definition: tiffiop.h:162
WriteOK
#define WriteOK(tif, buf, size)
Definition: tiffiop.h:234
FIELD_IMAGEDIMENSIONS
#define FIELD_IMAGEDIMENSIONS
Definition: tif_dir.h:105
TIFFhowmany
#define TIFFhowmany(x, y)
Definition: tiffiop.h:239
TIFFSeekFile
#define TIFFSeekFile(tif, off, whence)
Definition: tiffiop.h:211
TIFFWriteRawStrip
tsize_t TIFFWriteRawStrip(TIFF *tif, tstrip_t strip, tdata_t data, tsize_t cc)
Definition: tif_write.c:264
tiff::tif_encoderow
TIFFCodeMethod tif_encoderow
Definition: tiffiop.h:160
SEEK_END
#define SEEK_END
Definition: zconf.h:390
TIFFScanlineSize
tsize_t TIFFScanlineSize(TIFF *tif)
Definition: tif_strip.c:227
WRITECHECKSTRIPS
#define WRITECHECKSTRIPS(tif, module)
Definition: tif_write.c:37
tiff::tif_rawdata
tidata_t tif_rawdata
Definition: tiffiop.h:174
tiff::tif_curoff
toff_t tif_curoff
Definition: tiffiop.h:142
tstrip_t
tstrile_t tstrip_t
Definition: tiffio.h:65
tiff::tif_clientdata
thandle_t tif_clientdata
Definition: tiffiop.h:185
tiffiop.h
TIFFWriteBufferSetup
int TIFFWriteBufferSetup(TIFF *tif, tdata_t bp, tsize_t size)
Definition: tif_write.c:546
tiff::tif_name
char * tif_name
Definition: tiffiop.h:103
tiff
Definition: tiffiop.h:102
TIFFWriteEncodedStrip
tsize_t TIFFWriteEncodedStrip(TIFF *tif, tstrip_t strip, tdata_t data, tsize_t cc)
Definition: tif_write.c:182
TIFFSetFieldBit
#define TIFFSetFieldBit(tif, field)
Definition: tif_dir.h:173
FIELD_STRIPBYTECOUNTS
#define FIELD_STRIPBYTECOUNTS
Definition: tif_dir.h:125
TIFFFlushData
int TIFFFlushData(TIFF *tif)
Definition: tif_flush.c:56
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
FIELD_PLANARCONFIG
#define FIELD_PLANARCONFIG
Definition: tif_dir.h:122
TIFFDirectory::td_tilelength
uint32 td_tilelength
Definition: tif_dir.h:42
tiff::tif_tilesize
tsize_t tif_tilesize
Definition: tiffiop.h:150
tiff::tif_encodetile
TIFFCodeMethod tif_encodetile
Definition: tiffiop.h:164
TIFF_POSTENCODE
#define TIFF_POSTENCODE
Definition: tiffiop.h:118
tiff::tif_seek
TIFFSeekMethod tif_seek
Definition: tiffiop.h:166
tiff::tif_preencode
TIFFPreMethod tif_preencode
Definition: tiffiop.h:157
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
tiff::tif_postencode
TIFFBoolMethod tif_postencode
Definition: tiffiop.h:158
TIFFDirectory::td_imagelength
uint32 td_imagelength
Definition: tif_dir.h:41
TIFFNumberOfTiles
ttile_t TIFFNumberOfTiles(TIFF *tif)
Definition: tif_tile.c:145
tiff::tif_postdecode
TIFFPostMethod tif_postdecode
Definition: tiffiop.h:192
TIFFDirectory::td_rowsperstrip
uint32 td_rowsperstrip
Definition: tif_dir.h:52
_TIFFrealloc
void * _TIFFrealloc(tdata_t p, tsize_t s)
Definition: tif_acorn.c:473
TIFFDirectory
Definition: tif_dir.h:36
TIFFWriteScanline
int TIFFWriteScanline(TIFF *tif, tdata_t buf, uint32 row, tsample_t sample)
Definition: tif_write.c:49
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
tiff::tif_rawdatasize
tsize_t tif_rawdatasize
Definition: tiffiop.h:175
TIFFFieldSet
#define TIFFFieldSet(tif, field)
Definition: tif_dir.h:172
tiff::tif_rawcc
tsize_t tif_rawcc
Definition: tiffiop.h:177
FIELD_ROWSPERSTRIP
#define FIELD_ROWSPERSTRIP
Definition: tif_dir.h:119
TIFFComputeTile
ttile_t TIFFComputeTile(TIFF *tif, uint32 x, uint32 y, uint32 z, tsample_t s)
Definition: tif_tile.c:68
TIFF_NOBITREV
#define TIFF_NOBITREV
Definition: tiffiop.h:114
PLANARCONFIG_SEPARATE
#define PLANARCONFIG_SEPARATE
Definition: tiff.h:244
_TIFFmemset
void _TIFFmemset(tdata_t p, int v, tsize_t c)
Definition: tif_acorn.c:479
TIFFNumberOfStrips
tstrip_t TIFFNumberOfStrips(TIFF *tif)
Definition: tif_strip.c:90
isTiled
#define isTiled(tif)
Definition: tiffiop.h:203
TIFF_BUFFERSETUP
#define TIFF_BUFFERSETUP
Definition: tiffiop.h:110
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
TIFFWriteCheck
int TIFFWriteCheck(TIFF *tif, int tiles, const char *module)
Definition: tif_write.c:483
TIFFSetWriteOffset
void TIFFSetWriteOffset(TIFF *tif, toff_t off)
Definition: tif_write.c:706
tiff::tif_row
uint32 tif_row
Definition: tiffiop.h:139
TIFFTileSize
tsize_t TIFFTileSize(TIFF *tif)
Definition: tif_tile.c:241
tiff::tif_curtile
ttile_t tif_curtile
Definition: tiffiop.h:149
toff_t
uint32 toff_t
Definition: tiffio.h:69
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
FIELD_TILEDIMENSIONS
#define FIELD_TILEDIMENSIONS
Definition: tif_dir.h:106
SeekOK
#define SeekOK(tif, off)
Definition: tiffiop.h:230
_TIFFmalloc
void * _TIFFmalloc(tsize_t s)
Definition: tif_acorn.c:461
data
JSAMPIMAGE data
Definition: jpeglib.h:945
TIFFWriteRawTile
tsize_t TIFFWriteRawTile(TIFF *tif, ttile_t tile, tdata_t data, tsize_t cc)
Definition: tif_write.c:423
TIFFStripSize
tsize_t TIFFStripSize(TIFF *tif)
Definition: tif_strip.c:182
TIFFDirectory::td_stripbytecount
toff_t * td_stripbytecount
Definition: tif_dir.h:70
_TIFFfree
void _TIFFfree(tdata_t p)
Definition: tif_acorn.c:467
BUFFERCHECK
#define BUFFERCHECK(tif)
Definition: tif_write.c:41
tiff::tif_col
uint32 tif_col
Definition: tiffiop.h:148
isUnspecified
#define isUnspecified(tif, f)
Definition: tif_write.c:439
tiff::tif_setupencode
TIFFBoolMethod tif_setupencode
Definition: tiffiop.h:155
TIFFFlushData1
int TIFFFlushData1(TIFF *tif)
Definition: tif_write.c:682
TIFF_MYBUFFER
#define TIFF_MYBUFFER
Definition: tiffiop.h:115
WRITECHECKTILES
#define WRITECHECKTILES(tif, module)
Definition: tif_write.c:39
PLANARCONFIG_CONTIG
#define PLANARCONFIG_CONTIG
Definition: tiff.h:243
TIFFWriteTile
tsize_t TIFFWriteTile(TIFF *tif, tdata_t buf, uint32 x, uint32 y, uint32 z, tsample_t s)
Definition: tif_write.c:308
TIFFDirectory::td_fillorder
uint16 td_fillorder
Definition: tif_dir.h:49