dll/3rdparty/libtiff/tif_write.c

   1 /*
   2  * Copyright (c) 1988-1997 Sam Leffler
   3  * Copyright (c) 1991-1997 Silicon Graphics, Inc.
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software and
   6  * its documentation for any purpose is hereby granted without fee, provided
   7  * that (i) the above copyright notices and this permission notice appear in
   8  * all copies of the software and related documentation, and (ii) the names of
   9  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  10  * publicity relating to the software without the specific, prior written
  11  * permission of Sam Leffler and Silicon Graphics.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
  14  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  15  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  16  *
  17  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  18  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  19  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  20  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  21  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  22  * OF THIS SOFTWARE.
  23  */
  24
  25 /*
  26  * TIFF Library.
  27  *
  28  * Scanline-oriented Write Support
  29  */
  30 #include <precomp.h>
  31 //#include <stdio.h>
  32
  33 #define STRIPINCR       20              /* expansion factor on strip array */
  34
  35 #define WRITECHECKSTRIPS(tif, module)                           \
  36         (((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),0,module))
  37 #define WRITECHECKTILES(tif, module)                            \
  38         (((tif)->tif_flags&TIFF_BEENWRITING) || TIFFWriteCheck((tif),1,module))
  39 #define BUFFERCHECK(tif)                                        \
  40         ((((tif)->tif_flags & TIFF_BUFFERSETUP) && tif->tif_rawdata) || \
  41             TIFFWriteBufferSetup((tif), NULL, (tmsize_t) -1))
  42
  43 static int TIFFGrowStrips(TIFF* tif, uint32 delta, const char* module);
  44 static int TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc);
  45
  46 int
  47 TIFFWriteScanline(TIFF* tif, void* buf, uint32 row, uint16 sample)
  48 {
  49         static const char module[] = "TIFFWriteScanline";
  50         register TIFFDirectory *td;
  51         int status, imagegrew = 0;
  52         uint32 strip;
  53
  54         if (!WRITECHECKSTRIPS(tif, module))
  55                 return (-1);
  56         /*
  57          * Handle delayed allocation of data buffer.  This
  58          * permits it to be sized more intelligently (using
  59          * directory information).
  60          */
  61         if (!BUFFERCHECK(tif))
  62                 return (-1);
  63         tif->tif_flags |= TIFF_BUF4WRITE; /* not strictly sure this is right*/
  64
  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, module,
  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, module,
  85                             "%lu: Sample out of range, max %lu",
  86                             (unsigned long) sample, (unsigned long) 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_32(td->td_imagelength,td->td_rowsperstrip);
 116                 if (td->td_stripsperimage == 0) {
 117                         TIFFErrorExt(tif->tif_clientdata, module, "Zero strips per image");
 118                         return (-1);
 119                 }
 120                 tif->tif_row =
 121                     (strip % td->td_stripsperimage) * td->td_rowsperstrip;
 122                 if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
 123                         if (!(*tif->tif_setupencode)(tif))
 124                                 return (-1);
 125                         tif->tif_flags |= TIFF_CODERSETUP;
 126                 }
 127
 128                 tif->tif_rawcc = 0;
 129                 tif->tif_rawcp = tif->tif_rawdata;
 130
 131                 if( td->td_stripbytecount_p[strip] > 0 )
 132                 {
 133                         /* if we are writing over existing tiles, zero length */
 134                         td->td_stripbytecount_p[strip] = 0;
 135
 136                         /* this forces TIFFAppendToStrip() to do a seek */
 137                         tif->tif_curoff = 0;
 138                 }
 139
 140                 if (!(*tif->tif_preencode)(tif, sample))
 141                         return (-1);
 142                 tif->tif_flags |= TIFF_POSTENCODE;
 143         }
 144         /*
 145          * Ensure the write is either sequential or at the
 146          * beginning of a strip (or that we can randomly
 147          * access the data -- i.e. no encoding).
 148          */
 149         if (row != tif->tif_row) {
 150                 if (row < tif->tif_row) {
 151                         /*
 152                          * Moving backwards within the same strip:
 153                          * backup to the start and then decode
 154                          * forward (below).
 155                          */
 156                         tif->tif_row = (strip % td->td_stripsperimage) *
 157                             td->td_rowsperstrip;
 158                         tif->tif_rawcp = tif->tif_rawdata;
 159                 }
 160                 /*
 161                  * Seek forward to the desired row.
 162                  */
 163                 if (!(*tif->tif_seek)(tif, row - tif->tif_row))
 164                         return (-1);
 165                 tif->tif_row = row;
 166         }
 167
 168         /* swab if needed - note that source buffer will be altered */
 169         tif->tif_postdecode( tif, (uint8*) buf, tif->tif_scanlinesize );
 170
 171         status = (*tif->tif_encoderow)(tif, (uint8*) buf,
 172             tif->tif_scanlinesize, sample);
 173
 174         /* we are now poised at the beginning of the next row */
 175         tif->tif_row = row + 1;
 176         return (status);
 177 }
 178
 179 /* Make sure that at the first attempt of rewriting a tile/strip, we will have */
 180 /* more bytes available in the output buffer than the previous byte count, */
 181 /* so that TIFFAppendToStrip() will detect the overflow when it is called the first */
 182 /* time if the new compressed tile is bigger than the older one. (GDAL #4771) */
 183 static int _TIFFReserveLargeEnoughWriteBuffer(TIFF* tif, uint32 strip_or_tile)
 184 {
 185     TIFFDirectory *td = &tif->tif_dir;
 186     if( td->td_stripbytecount_p[strip_or_tile] > 0 )
 187     {
 188         /* The +1 is to ensure at least one extra bytes */
 189         /* The +4 is because the LZW encoder flushes 4 bytes before the limit */
 190         uint64 safe_buffer_size = (uint64)(td->td_stripbytecount_p[strip_or_tile] + 1 + 4);
 191         if( tif->tif_rawdatasize <= (tmsize_t)safe_buffer_size )
 192         {
 193             if( !(TIFFWriteBufferSetup(tif, NULL,
 194                 (tmsize_t)TIFFroundup_64(safe_buffer_size, 1024))) )
 195                 return 0;
 196         }
 197
 198         /* Force TIFFAppendToStrip() to consider placing data at end
 199             of file. */
 200         tif->tif_curoff = 0;
 201     }
 202     return 1;
 203 }
 204
 205 /*
 206  * Encode the supplied data and write it to the
 207  * specified strip.
 208  *
 209  * NB: Image length must be setup before writing.
 210  */
 211 tmsize_t
 212 TIFFWriteEncodedStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc)
 213 {
 214         static const char module[] = "TIFFWriteEncodedStrip";
 215         TIFFDirectory *td = &tif->tif_dir;
 216         uint16 sample;
 217
 218         if (!WRITECHECKSTRIPS(tif, module))
 219                 return ((tmsize_t) -1);
 220         /*
 221          * Check strip array to make sure there's space.
 222          * We don't support dynamically growing files that
 223          * have data organized in separate bitplanes because
 224          * it's too painful.  In that case we require that
 225          * the imagelength be set properly before the first
 226          * write (so that the strips array will be fully
 227          * allocated above).
 228          */
 229         if (strip >= td->td_nstrips) {
 230                 if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
 231                         TIFFErrorExt(tif->tif_clientdata, module,
 232                             "Can not grow image by strips when using separate planes");
 233                         return ((tmsize_t) -1);
 234                 }
 235                 if (!TIFFGrowStrips(tif, 1, module))
 236                         return ((tmsize_t) -1);
 237                 td->td_stripsperimage =
 238                     TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip);
 239         }
 240         /*
 241          * Handle delayed allocation of data buffer.  This
 242          * permits it to be sized according to the directory
 243          * info.
 244          */
 245         if (!BUFFERCHECK(tif))
 246                 return ((tmsize_t) -1);
 247
 248         tif->tif_flags |= TIFF_BUF4WRITE;
 249         tif->tif_curstrip = strip;
 250
 251         if( !_TIFFReserveLargeEnoughWriteBuffer(tif, strip) ) {
 252             return ((tmsize_t)(-1));
 253         }
 254
 255         tif->tif_rawcc = 0;
 256         tif->tif_rawcp = tif->tif_rawdata;
 257
 258         if (td->td_stripsperimage == 0) {
 259                 TIFFErrorExt(tif->tif_clientdata, module, "Zero strips per image");
 260                 return ((tmsize_t) -1);
 261         }
 262
 263         tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
 264         if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
 265                 if (!(*tif->tif_setupencode)(tif))
 266                         return ((tmsize_t) -1);
 267                 tif->tif_flags |= TIFF_CODERSETUP;
 268         }
 269
 270         tif->tif_flags &= ~TIFF_POSTENCODE;
 271
 272     /* shortcut to avoid an extra memcpy() */
 273     if( td->td_compression == COMPRESSION_NONE )
 274     {
 275         /* swab if needed - note that source buffer will be altered */
 276         tif->tif_postdecode( tif, (uint8*) data, cc );
 277
 278         if (!isFillOrder(tif, td->td_fillorder) &&
 279             (tif->tif_flags & TIFF_NOBITREV) == 0)
 280             TIFFReverseBits((uint8*) data, cc);
 281
 282         if (cc > 0 &&
 283             !TIFFAppendToStrip(tif, strip, (uint8*) data, cc))
 284             return ((tmsize_t) -1);
 285         return (cc);
 286     }
 287
 288         sample = (uint16)(strip / td->td_stripsperimage);
 289         if (!(*tif->tif_preencode)(tif, sample))
 290                 return ((tmsize_t) -1);
 291
 292         /* swab if needed - note that source buffer will be altered */
 293         tif->tif_postdecode( tif, (uint8*) data, cc );
 294
 295         if (!(*tif->tif_encodestrip)(tif, (uint8*) data, cc, sample))
 296                 return ((tmsize_t) -1);
 297         if (!(*tif->tif_postencode)(tif))
 298                 return ((tmsize_t) -1);
 299         if (!isFillOrder(tif, td->td_fillorder) &&
 300             (tif->tif_flags & TIFF_NOBITREV) == 0)
 301                 TIFFReverseBits(tif->tif_rawdata, tif->tif_rawcc);
 302         if (tif->tif_rawcc > 0 &&
 303             !TIFFAppendToStrip(tif, strip, tif->tif_rawdata, tif->tif_rawcc))
 304                 return ((tmsize_t) -1);
 305         tif->tif_rawcc = 0;
 306         tif->tif_rawcp = tif->tif_rawdata;
 307         return (cc);
 308 }
 309
 310 /*
 311  * Write the supplied data to the specified strip.
 312  *
 313  * NB: Image length must be setup before writing.
 314  */
 315 tmsize_t
 316 TIFFWriteRawStrip(TIFF* tif, uint32 strip, void* data, tmsize_t cc)
 317 {
 318         static const char module[] = "TIFFWriteRawStrip";
 319         TIFFDirectory *td = &tif->tif_dir;
 320
 321         if (!WRITECHECKSTRIPS(tif, module))
 322                 return ((tmsize_t) -1);
 323         /*
 324          * Check strip array to make sure there's space.
 325          * We don't support dynamically growing files that
 326          * have data organized in separate bitplanes because
 327          * it's too painful.  In that case we require that
 328          * the imagelength be set properly before the first
 329          * write (so that the strips array will be fully
 330          * allocated above).
 331          */
 332         if (strip >= td->td_nstrips) {
 333                 if (td->td_planarconfig == PLANARCONFIG_SEPARATE) {
 334                         TIFFErrorExt(tif->tif_clientdata, module,
 335                             "Can not grow image by strips when using separate planes");
 336                         return ((tmsize_t) -1);
 337                 }
 338                 /*
 339                  * Watch out for a growing image.  The value of
 340                  * strips/image will initially be 1 (since it
 341                  * can't be deduced until the imagelength is known).
 342                  */
 343                 if (strip >= td->td_stripsperimage)
 344                         td->td_stripsperimage =
 345                             TIFFhowmany_32(td->td_imagelength,td->td_rowsperstrip);
 346                 if (!TIFFGrowStrips(tif, 1, module))
 347                         return ((tmsize_t) -1);
 348         }
 349         tif->tif_curstrip = strip;
 350         if (td->td_stripsperimage == 0) {
 351                 TIFFErrorExt(tif->tif_clientdata, module,"Zero strips per image");
 352                 return ((tmsize_t) -1);
 353         }
 354         tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
 355         return (TIFFAppendToStrip(tif, strip, (uint8*) data, cc) ?
 356             cc : (tmsize_t) -1);
 357 }
 358
 359 /*
 360  * Write and compress a tile of data.  The
 361  * tile is selected by the (x,y,z,s) coordinates.
 362  */
 363 tmsize_t
 364 TIFFWriteTile(TIFF* tif, void* buf, uint32 x, uint32 y, uint32 z, uint16 s)
 365 {
 366         if (!TIFFCheckTile(tif, x, y, z, s))
 367                 return ((tmsize_t)(-1));
 368         /*
 369          * NB: A tile size of -1 is used instead of tif_tilesize knowing
 370          *     that TIFFWriteEncodedTile will clamp this to the tile size.
 371          *     This is done because the tile size may not be defined until
 372          *     after the output buffer is setup in TIFFWriteBufferSetup.
 373          */
 374         return (TIFFWriteEncodedTile(tif,
 375             TIFFComputeTile(tif, x, y, z, s), buf, (tmsize_t)(-1)));
 376 }
 377
 378 /*
 379  * Encode the supplied data and write it to the
 380  * specified tile.  There must be space for the
 381  * data.  The function clamps individual writes
 382  * to a tile to the tile size, but does not (and
 383  * can not) check that multiple writes to the same
 384  * tile do not write more than tile size data.
 385  *
 386  * NB: Image length must be setup before writing; this
 387  *     interface does not support automatically growing
 388  *     the image on each write (as TIFFWriteScanline does).
 389  */
 390 tmsize_t
 391 TIFFWriteEncodedTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc)
 392 {
 393         static const char module[] = "TIFFWriteEncodedTile";
 394         TIFFDirectory *td;
 395         uint16 sample;
 396         uint32 howmany32;
 397
 398         if (!WRITECHECKTILES(tif, module))
 399                 return ((tmsize_t)(-1));
 400         td = &tif->tif_dir;
 401         if (tile >= td->td_nstrips) {
 402                 TIFFErrorExt(tif->tif_clientdata, module, "Tile %lu out of range, max %lu",
 403                     (unsigned long) tile, (unsigned long) td->td_nstrips);
 404                 return ((tmsize_t)(-1));
 405         }
 406         /*
 407          * Handle delayed allocation of data buffer.  This
 408          * permits it to be sized more intelligently (using
 409          * directory information).
 410          */
 411         if (!BUFFERCHECK(tif))
 412                 return ((tmsize_t)(-1));
 413
 414         tif->tif_flags |= TIFF_BUF4WRITE;
 415         tif->tif_curtile = tile;
 416
 417         if( !_TIFFReserveLargeEnoughWriteBuffer(tif, tile) ) {
 418             return ((tmsize_t)(-1));
 419         }
 420
 421         tif->tif_rawcc = 0;
 422         tif->tif_rawcp = tif->tif_rawdata;
 423
 424         /*
 425          * Compute tiles per row & per column to compute
 426          * current row and column
 427          */
 428         howmany32=TIFFhowmany_32(td->td_imagelength, td->td_tilelength);
 429         if (howmany32 == 0) {
 430                  TIFFErrorExt(tif->tif_clientdata,module,"Zero tiles");
 431                 return ((tmsize_t)(-1));
 432         }
 433         tif->tif_row = (tile % howmany32) * td->td_tilelength;
 434         howmany32=TIFFhowmany_32(td->td_imagewidth, td->td_tilewidth);
 435         if (howmany32 == 0) {
 436                  TIFFErrorExt(tif->tif_clientdata,module,"Zero tiles");
 437                 return ((tmsize_t)(-1));
 438         }
 439         tif->tif_col = (tile % howmany32) * td->td_tilewidth;
 440
 441         if ((tif->tif_flags & TIFF_CODERSETUP) == 0) {
 442                 if (!(*tif->tif_setupencode)(tif))
 443                         return ((tmsize_t)(-1));
 444                 tif->tif_flags |= TIFF_CODERSETUP;
 445         }
 446         tif->tif_flags &= ~TIFF_POSTENCODE;
 447
 448         /*
 449          * Clamp write amount to the tile size.  This is mostly
 450          * done so that callers can pass in some large number
 451          * (e.g. -1) and have the tile size used instead.
 452          */
 453         if ( cc < 1 || cc > tif->tif_tilesize)
 454                 cc = tif->tif_tilesize;
 455
 456     /* shortcut to avoid an extra memcpy() */
 457     if( td->td_compression == COMPRESSION_NONE )
 458     {
 459         /* swab if needed - note that source buffer will be altered */
 460         tif->tif_postdecode( tif, (uint8*) data, cc );
 461
 462         if (!isFillOrder(tif, td->td_fillorder) &&
 463             (tif->tif_flags & TIFF_NOBITREV) == 0)
 464             TIFFReverseBits((uint8*) data, cc);
 465
 466         if (cc > 0 &&
 467             !TIFFAppendToStrip(tif, tile, (uint8*) data, cc))
 468             return ((tmsize_t) -1);
 469         return (cc);
 470     }
 471
 472     sample = (uint16)(tile/td->td_stripsperimage);
 473     if (!(*tif->tif_preencode)(tif, sample))
 474         return ((tmsize_t)(-1));
 475     /* swab if needed - note that source buffer will be altered */
 476     tif->tif_postdecode( tif, (uint8*) data, cc );
 477
 478     if (!(*tif->tif_encodetile)(tif, (uint8*) data, cc, sample))
 479             return ((tmsize_t) -1);
 480     if (!(*tif->tif_postencode)(tif))
 481             return ((tmsize_t)(-1));
 482     if (!isFillOrder(tif, td->td_fillorder) &&
 483         (tif->tif_flags & TIFF_NOBITREV) == 0)
 484             TIFFReverseBits((uint8*)tif->tif_rawdata, tif->tif_rawcc);
 485     if (tif->tif_rawcc > 0 && !TIFFAppendToStrip(tif, tile,
 486         tif->tif_rawdata, tif->tif_rawcc))
 487             return ((tmsize_t)(-1));
 488     tif->tif_rawcc = 0;
 489     tif->tif_rawcp = tif->tif_rawdata;
 490     return (cc);
 491 }
 492
 493 /*
 494  * Write the supplied data to the specified strip.
 495  * There must be space for the data; we don't check
 496  * if strips overlap!
 497  *
 498  * NB: Image length must be setup before writing; this
 499  *     interface does not support automatically growing
 500  *     the image on each write (as TIFFWriteScanline does).
 501  */
 502 tmsize_t
 503 TIFFWriteRawTile(TIFF* tif, uint32 tile, void* data, tmsize_t cc)
 504 {
 505         static const char module[] = "TIFFWriteRawTile";
 506
 507         if (!WRITECHECKTILES(tif, module))
 508                 return ((tmsize_t)(-1));
 509         if (tile >= tif->tif_dir.td_nstrips) {
 510                 TIFFErrorExt(tif->tif_clientdata, module, "Tile %lu out of range, max %lu",
 511                     (unsigned long) tile,
 512                     (unsigned long) tif->tif_dir.td_nstrips);
 513                 return ((tmsize_t)(-1));
 514         }
 515         return (TIFFAppendToStrip(tif, tile, (uint8*) data, cc) ?
 516             cc : (tmsize_t)(-1));
 517 }
 518
 519 #define isUnspecified(tif, f) \
 520     (TIFFFieldSet(tif,f) && (tif)->tif_dir.td_imagelength == 0)
 521
 522 int
 523 TIFFSetupStrips(TIFF* tif)
 524 {
 525         TIFFDirectory* td = &tif->tif_dir;
 526
 527         if (isTiled(tif))
 528                 td->td_stripsperimage =
 529                     isUnspecified(tif, FIELD_TILEDIMENSIONS) ?
 530                         td->td_samplesperpixel : TIFFNumberOfTiles(tif);
 531         else
 532                 td->td_stripsperimage =
 533                     isUnspecified(tif, FIELD_ROWSPERSTRIP) ?
 534                         td->td_samplesperpixel : TIFFNumberOfStrips(tif);
 535         td->td_nstrips = td->td_stripsperimage;
 536         if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
 537                 td->td_stripsperimage /= td->td_samplesperpixel;
 538         td->td_stripoffset_p = (uint64 *)
 539             _TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint64),
 540                              "for \"StripOffsets\" array");
 541         td->td_stripbytecount_p = (uint64 *)
 542             _TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint64),
 543                              "for \"StripByteCounts\" array");
 544         if (td->td_stripoffset_p == NULL || td->td_stripbytecount_p == NULL)
 545                 return (0);
 546         /*
 547          * Place data at the end-of-file
 548          * (by setting offsets to zero).
 549          */
 550         _TIFFmemset(td->td_stripoffset_p, 0, td->td_nstrips*sizeof (uint64));
 551         _TIFFmemset(td->td_stripbytecount_p, 0, td->td_nstrips*sizeof (uint64));
 552         TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS);
 553         TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
 554         return (1);
 555 }
 556 #undef isUnspecified
 557
 558 /*
 559  * Verify file is writable and that the directory
 560  * information is setup properly.  In doing the latter
 561  * we also "freeze" the state of the directory so
 562  * that important information is not changed.
 563  */
 564 int
 565 TIFFWriteCheck(TIFF* tif, int tiles, const char* module)
 566 {
 567         if (tif->tif_mode == O_RDONLY) {
 568                 TIFFErrorExt(tif->tif_clientdata, module, "File not open for writing");
 569                 return (0);
 570         }
 571         if (tiles ^ isTiled(tif)) {
 572                 TIFFErrorExt(tif->tif_clientdata, module, tiles ?
 573                     "Can not write tiles to a striped image" :
 574                     "Can not write scanlines to a tiled image");
 575                 return (0);
 576         }
 577
 578         _TIFFFillStriles( tif );
 579
 580         /*
 581          * On the first write verify all the required information
 582          * has been setup and initialize any data structures that
 583          * had to wait until directory information was set.
 584          * Note that a lot of our work is assumed to remain valid
 585          * because we disallow any of the important parameters
 586          * from changing after we start writing (i.e. once
 587          * TIFF_BEENWRITING is set, TIFFSetField will only allow
 588          * the image's length to be changed).
 589          */
 590         if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) {
 591                 TIFFErrorExt(tif->tif_clientdata, module,
 592                     "Must set \"ImageWidth\" before writing data");
 593                 return (0);
 594         }
 595         if (tif->tif_dir.td_samplesperpixel == 1) {
 596                 /*
 597                  * Planarconfiguration is irrelevant in case of single band
 598                  * images and need not be included. We will set it anyway,
 599                  * because this field is used in other parts of library even
 600                  * in the single band case.
 601                  */
 602                 if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG))
 603                     tif->tif_dir.td_planarconfig = PLANARCONFIG_CONTIG;
 604         } else {
 605                 if (!TIFFFieldSet(tif, FIELD_PLANARCONFIG)) {
 606                         TIFFErrorExt(tif->tif_clientdata, module,
 607                             "Must set \"PlanarConfiguration\" before writing data");
 608                         return (0);
 609                 }
 610         }
 611         if (tif->tif_dir.td_stripoffset_p == NULL && !TIFFSetupStrips(tif)) {
 612                 tif->tif_dir.td_nstrips = 0;
 613                 TIFFErrorExt(tif->tif_clientdata, module, "No space for %s arrays",
 614                     isTiled(tif) ? "tile" : "strip");
 615                 return (0);
 616         }
 617         if (isTiled(tif))
 618         {
 619                 tif->tif_tilesize = TIFFTileSize(tif);
 620                 if (tif->tif_tilesize == 0)
 621                         return (0);
 622         }
 623         else
 624                 tif->tif_tilesize = (tmsize_t)(-1);
 625         tif->tif_scanlinesize = TIFFScanlineSize(tif);
 626         if (tif->tif_scanlinesize == 0)
 627                 return (0);
 628         tif->tif_flags |= TIFF_BEENWRITING;
 629
 630         if( tif->tif_dir.td_stripoffset_entry.tdir_tag != 0 &&
 631             tif->tif_dir.td_stripoffset_entry.tdir_count == 0 &&
 632             tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
 633             tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0 &&
 634             tif->tif_dir.td_stripbytecount_entry.tdir_tag != 0 &&
 635             tif->tif_dir.td_stripbytecount_entry.tdir_count == 0 &&
 636             tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
 637             tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0 &&
 638             !(tif->tif_flags & TIFF_DIRTYDIRECT)  )
 639         {
 640             TIFFForceStrileArrayWriting(tif);
 641         }
 642
 643         return (1);
 644 }
 645
 646 /*
 647  * Setup the raw data buffer used for encoding.
 648  */
 649 int
 650 TIFFWriteBufferSetup(TIFF* tif, void* bp, tmsize_t size)
 651 {
 652         static const char module[] = "TIFFWriteBufferSetup";
 653
 654         if (tif->tif_rawdata) {
 655                 if (tif->tif_flags & TIFF_MYBUFFER) {
 656                         _TIFFfree(tif->tif_rawdata);
 657                         tif->tif_flags &= ~TIFF_MYBUFFER;
 658                 }
 659                 tif->tif_rawdata = NULL;
 660         }
 661         if (size == (tmsize_t)(-1)) {
 662                 size = (isTiled(tif) ?
 663                     tif->tif_tilesize : TIFFStripSize(tif));
 664                 /*
 665                  * Make raw data buffer at least 8K
 666                  */
 667                 if (size < 8*1024)
 668                         size = 8*1024;
 669                 bp = NULL;                      /* NB: force malloc */
 670         }
 671         if (bp == NULL) {
 672                 bp = _TIFFmalloc(size);
 673                 if (bp == NULL) {
 674                         TIFFErrorExt(tif->tif_clientdata, module, "No space for output buffer");
 675                         return (0);
 676                 }
 677                 tif->tif_flags |= TIFF_MYBUFFER;
 678         } else
 679                 tif->tif_flags &= ~TIFF_MYBUFFER;
 680         tif->tif_rawdata = (uint8*) bp;
 681         tif->tif_rawdatasize = size;
 682         tif->tif_rawcc = 0;
 683         tif->tif_rawcp = tif->tif_rawdata;
 684         tif->tif_flags |= TIFF_BUFFERSETUP;
 685         return (1);
 686 }
 687
 688 /*
 689  * Grow the strip data structures by delta strips.
 690  */
 691 static int
 692 TIFFGrowStrips(TIFF* tif, uint32 delta, const char* module)
 693 {
 694         TIFFDirectory *td = &tif->tif_dir;
 695         uint64* new_stripoffset;
 696         uint64* new_stripbytecount;
 697
 698         assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
 699         new_stripoffset = (uint64*)_TIFFrealloc(td->td_stripoffset_p,
 700                 (td->td_nstrips + delta) * sizeof (uint64));
 701         new_stripbytecount = (uint64*)_TIFFrealloc(td->td_stripbytecount_p,
 702                 (td->td_nstrips + delta) * sizeof (uint64));
 703         if (new_stripoffset == NULL || new_stripbytecount == NULL) {
 704                 if (new_stripoffset)
 705                         _TIFFfree(new_stripoffset);
 706                 if (new_stripbytecount)
 707                         _TIFFfree(new_stripbytecount);
 708                 td->td_nstrips = 0;
 709                 TIFFErrorExt(tif->tif_clientdata, module, "No space to expand strip arrays");
 710                 return (0);
 711         }
 712         td->td_stripoffset_p = new_stripoffset;
 713         td->td_stripbytecount_p = new_stripbytecount;
 714         _TIFFmemset(td->td_stripoffset_p + td->td_nstrips,
 715                     0, delta*sizeof (uint64));
 716         _TIFFmemset(td->td_stripbytecount_p + td->td_nstrips,
 717                     0, delta*sizeof (uint64));
 718         td->td_nstrips += delta;
 719         tif->tif_flags |= TIFF_DIRTYDIRECT;
 720
 721         return (1);
 722 }
 723
 724 /*
 725  * Append the data to the specified strip.
 726  */
 727 static int
 728 TIFFAppendToStrip(TIFF* tif, uint32 strip, uint8* data, tmsize_t cc)
 729 {
 730         static const char module[] = "TIFFAppendToStrip";
 731         TIFFDirectory *td = &tif->tif_dir;
 732         uint64 m;
 733         int64 old_byte_count = -1;
 734
 735         if (td->td_stripoffset_p[strip] == 0 || tif->tif_curoff == 0) {
 736             assert(td->td_nstrips > 0);
 737
 738             if( td->td_stripbytecount_p[strip] != 0
 739                 && td->td_stripoffset_p[strip] != 0
 740                 && td->td_stripbytecount_p[strip] >= (uint64) cc )
 741             {
 742                 /*
 743                  * There is already tile data on disk, and the new tile
 744                  * data we have will fit in the same space.  The only
 745                  * aspect of this that is risky is that there could be
 746                  * more data to append to this strip before we are done
 747                  * depending on how we are getting called.
 748                  */
 749                 if (!SeekOK(tif, td->td_stripoffset_p[strip])) {
 750                     TIFFErrorExt(tif->tif_clientdata, module,
 751                                  "Seek error at scanline %lu",
 752                                  (unsigned long)tif->tif_row);
 753                     return (0);
 754                 }
 755             }
 756             else
 757             {
 758                 /*
 759                  * Seek to end of file, and set that as our location to
 760                  * write this strip.
 761                  */
 762                 td->td_stripoffset_p[strip] = TIFFSeekFile(tif, 0, SEEK_END);
 763                 tif->tif_flags |= TIFF_DIRTYSTRIP;
 764             }
 765
 766             tif->tif_curoff = td->td_stripoffset_p[strip];
 767
 768             /*
 769              * We are starting a fresh strip/tile, so set the size to zero.
 770              */
 771             old_byte_count = td->td_stripbytecount_p[strip];
 772             td->td_stripbytecount_p[strip] = 0;
 773         }
 774
 775         m = tif->tif_curoff+cc;
 776         if (!(tif->tif_flags&TIFF_BIGTIFF))
 777                 m = (uint32)m;
 778         if ((m<tif->tif_curoff)||(m<(uint64)cc))
 779         {
 780                 TIFFErrorExt(tif->tif_clientdata, module, "Maximum TIFF file size exceeded");
 781                 return (0);
 782         }
 783         if (!WriteOK(tif, data, cc)) {
 784                 TIFFErrorExt(tif->tif_clientdata, module, "Write error at scanline %lu",
 785                     (unsigned long) tif->tif_row);
 786                     return (0);
 787         }
 788         tif->tif_curoff = m;
 789         td->td_stripbytecount_p[strip] += cc;
 790
 791         if( (int64) td->td_stripbytecount_p[strip] != old_byte_count )
 792             tif->tif_flags |= TIFF_DIRTYSTRIP;
 793
 794         return (1);
 795 }
 796
 797 /*
 798  * Internal version of TIFFFlushData that can be
 799  * called by ``encodestrip routines'' w/o concern
 800  * for infinite recursion.
 801  */
 802 int
 803 TIFFFlushData1(TIFF* tif)
 804 {
 805         if (tif->tif_rawcc > 0 && tif->tif_flags & TIFF_BUF4WRITE ) {
 806                 if (!isFillOrder(tif, tif->tif_dir.td_fillorder) &&
 807                     (tif->tif_flags & TIFF_NOBITREV) == 0)
 808                         TIFFReverseBits((uint8*)tif->tif_rawdata,
 809                             tif->tif_rawcc);
 810                 if (!TIFFAppendToStrip(tif,
 811                     isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip,
 812                     tif->tif_rawdata, tif->tif_rawcc))
 813         {
 814             /* We update those variables even in case of error since there's */
 815             /* code that doesn't really check the return code of this */
 816             /* function */
 817             tif->tif_rawcc = 0;
 818             tif->tif_rawcp = tif->tif_rawdata;
 819                         return (0);
 820         }
 821                 tif->tif_rawcc = 0;
 822                 tif->tif_rawcp = tif->tif_rawdata;
 823         }
 824         return (1);
 825 }
 826
 827 /*
 828  * Set the current write offset.  This should only be
 829  * used to set the offset to a known previous location
 830  * (very carefully), or to 0 so that the next write gets
 831  * appended to the end of the file.
 832  */
 833 void
 834 TIFFSetWriteOffset(TIFF* tif, toff_t off)
 835 {
 836         tif->tif_curoff = off;
 837 }
 838
 839 /* vim: set ts=8 sts=8 sw=8 noet: */
 840 /*
 841  * Local Variables:
 842  * mode: c
 843  * c-basic-offset: 8
 844  * fill-column: 78
 845  * End:
 846  */