src/tiff/tif_dirwrite.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  *
  30  * Directory Write Support Routines.
  31  */
  32 #include "tiffiop.h"
  33
  34 #if HAVE_IEEEFP
  35 #define TIFFCvtNativeToIEEEFloat(tif, n, fp)
  36 #define TIFFCvtNativeToIEEEDouble(tif, n, dp)
  37 #else
  38 extern  void TIFFCvtNativeToIEEEFloat(TIFF*, uint32, float*);
  39 extern  void TIFFCvtNativeToIEEEDouble(TIFF*, uint32, double*);
  40 #endif
  41
  42 static  int TIFFWriteNormalTag(TIFF*, TIFFDirEntry*, const TIFFFieldInfo*);
  43 static  void TIFFSetupShortLong(TIFF*, ttag_t, TIFFDirEntry*, uint32);
  44 static  int TIFFSetupShortPair(TIFF*, ttag_t, TIFFDirEntry*);
  45 static  int TIFFWritePerSampleShorts(TIFF*, ttag_t, TIFFDirEntry*);
  46 static  int TIFFWritePerSampleAnys(TIFF*, TIFFDataType, ttag_t, TIFFDirEntry*);
  47 static  int TIFFWriteShortTable(TIFF*, ttag_t, TIFFDirEntry*, uint32, uint16**);
  48 static  int TIFFWriteShortArray(TIFF*,
  49             TIFFDataType, ttag_t, TIFFDirEntry*, uint32, uint16*);
  50 static  int TIFFWriteLongArray(TIFF *,
  51             TIFFDataType, ttag_t, TIFFDirEntry*, uint32, uint32*);
  52 static  int TIFFWriteRationalArray(TIFF *,
  53             TIFFDataType, ttag_t, TIFFDirEntry*, uint32, float*);
  54 static  int TIFFWriteFloatArray(TIFF *,
  55             TIFFDataType, ttag_t, TIFFDirEntry*, uint32, float*);
  56 static  int TIFFWriteDoubleArray(TIFF *,
  57             TIFFDataType, ttag_t, TIFFDirEntry*, uint32, double*);
  58 static  int TIFFWriteByteArray(TIFF*, TIFFDirEntry*, char*);
  59 static  int TIFFWriteAnyArray(TIFF*,
  60             TIFFDataType, ttag_t, TIFFDirEntry*, uint32, double*);
  61 #ifdef COLORIMETRY_SUPPORT
  62 static  int TIFFWriteTransferFunction(TIFF*, TIFFDirEntry*);
  63 #endif
  64 #ifdef CMYK_SUPPORT
  65 static  int TIFFWriteInkNames(TIFF*, TIFFDirEntry*);
  66 #endif
  67 static  int TIFFWriteData(TIFF*, TIFFDirEntry*, char*);
  68 static  int TIFFLinkDirectory(TIFF*);
  69
  70 #define WriteRationalPair(type, tag1, v1, tag2, v2) {           \
  71         if (!TIFFWriteRational(tif, type, tag1, dir, v1))       \
  72                 goto bad;                                       \
  73         if (!TIFFWriteRational(tif, type, tag2, dir+1, v2))     \
  74                 goto bad;                                       \
  75         dir++;                                                  \
  76 }
  77 #define TIFFWriteRational(tif, type, tag, dir, v) \
  78         TIFFWriteRationalArray((tif), (type), (tag), (dir), 1, &(v))
  79 #ifndef TIFFWriteRational
  80 static  int TIFFWriteRational(TIFF*,
  81             TIFFDataType, ttag_t, TIFFDirEntry*, float);
  82 #endif
  83
  84 /*
  85  * Write the contents of the current directory
  86  * to the specified file.  This routine doesn't
  87  * handle overwriting a directory with auxiliary
  88  * storage that's been changed.
  89  */
  90 int
  91 TIFFWriteDirectory(TIFF* tif)
  92 {
  93         uint16 dircount;
  94         uint32 diroff;
  95         ttag_t tag;
  96         uint32 nfields;
  97         tsize_t dirsize;
  98         char* data;
  99         TIFFDirEntry* dir;
 100         TIFFDirectory* td;
 101         u_long b, fields[FIELD_SETLONGS];
 102         int fi, nfi;
 103
 104         if (tif->tif_mode == O_RDONLY)
 105                 return (1);
 106         /*
 107          * Clear write state so that subsequent images with
 108          * different characteristics get the right buffers
 109          * setup for them.
 110          */
 111         if (tif->tif_flags & TIFF_POSTENCODE) {
 112                 tif->tif_flags &= ~TIFF_POSTENCODE;
 113                 if (!(*tif->tif_postencode)(tif)) {
 114                         TIFFError(tif->tif_name,
 115                             "Error post-encoding before directory write");
 116                         return (0);
 117                 }
 118         }
 119         (*tif->tif_close)(tif);                 /* shutdown encoder */
 120         /*
 121          * Flush any data that might have been written
 122          * by the compression close+cleanup routines.
 123          */
 124         if (tif->tif_rawcc > 0 && !TIFFFlushData1(tif)) {
 125                 TIFFError(tif->tif_name,
 126                     "Error flushing data before directory write");
 127                 return (0);
 128         }
 129         if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
 130                 _TIFFfree(tif->tif_rawdata);
 131                 tif->tif_rawdata = NULL;
 132                 tif->tif_rawcc = 0;
 133         }
 134         tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP);
 135
 136         td = &tif->tif_dir;
 137         /*
 138          * Size the directory so that we can calculate
 139          * offsets for the data items that aren't kept
 140          * in-place in each field.
 141          */
 142         nfields = 0;
 143         for (b = 0; b <= FIELD_LAST; b++)
 144                 if (TIFFFieldSet(tif, b))
 145                         nfields += (b < FIELD_SUBFILETYPE ? 2 : 1);
 146         dirsize = nfields * sizeof (TIFFDirEntry);
 147         data = (char*) _TIFFmalloc(dirsize);
 148         if (data == NULL) {
 149                 TIFFError(tif->tif_name,
 150                     "Cannot write directory, out of space");
 151                 return (0);
 152         }
 153         /*
 154          * Directory hasn't been placed yet, put
 155          * it at the end of the file and link it
 156          * into the existing directory structure.
 157          */
 158         if (tif->tif_diroff == 0 && !TIFFLinkDirectory(tif))
 159                 goto bad;
 160         tif->tif_dataoff = (toff_t)(
 161             tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t));
 162         if (tif->tif_dataoff & 1)
 163                 tif->tif_dataoff++;
 164         (void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);
 165         tif->tif_curdir++;
 166         dir = (TIFFDirEntry*) data;
 167         /*
 168          * Setup external form of directory
 169          * entries and write data items.
 170          */
 171         _TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields));
 172         /*
 173          * Write out ExtraSamples tag only if
 174          * extra samples are present in the data.
 175          */
 176         if (FieldSet(fields, FIELD_EXTRASAMPLES) && !td->td_extrasamples) {
 177                 ResetFieldBit(fields, FIELD_EXTRASAMPLES);
 178                 nfields--;
 179                 dirsize -= sizeof (TIFFDirEntry);
 180         }                                                               /*XXX*/
 181         for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) {
 182                 const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi];
 183                 if (!FieldSet(fields, fip->field_bit))
 184                         continue;
 185                 switch (fip->field_bit) {
 186                 case FIELD_STRIPOFFSETS:
 187                         /*
 188                          * We use one field bit for both strip and tile
 189                          * offsets, and so must be careful in selecting
 190                          * the appropriate field descriptor (so that tags
 191                          * are written in sorted order).
 192                          */
 193                         tag = isTiled(tif) ?
 194                             TIFFTAG_TILEOFFSETS : TIFFTAG_STRIPOFFSETS;
 195                         if (tag != fip->field_tag)
 196                                 continue;
 197                         if (!TIFFWriteLongArray(tif, TIFF_LONG, tag, dir,
 198                             (uint32) td->td_nstrips, td->td_stripoffset))
 199                                 goto bad;
 200                         break;
 201                 case FIELD_STRIPBYTECOUNTS:
 202                         /*
 203                          * We use one field bit for both strip and tile
 204                          * byte counts, and so must be careful in selecting
 205                          * the appropriate field descriptor (so that tags
 206                          * are written in sorted order).
 207                          */
 208                         tag = isTiled(tif) ?
 209                             TIFFTAG_TILEBYTECOUNTS : TIFFTAG_STRIPBYTECOUNTS;
 210                         if (tag != fip->field_tag)
 211                                 continue;
 212                         if (!TIFFWriteLongArray(tif, TIFF_LONG, tag, dir,
 213                             (uint32) td->td_nstrips, td->td_stripbytecount))
 214                                 goto bad;
 215                         break;
 216                 case FIELD_ROWSPERSTRIP:
 217                         TIFFSetupShortLong(tif, TIFFTAG_ROWSPERSTRIP,
 218                             dir, td->td_rowsperstrip);
 219                         break;
 220                 case FIELD_COLORMAP:
 221                         if (!TIFFWriteShortTable(tif, TIFFTAG_COLORMAP, dir,
 222                             3, td->td_colormap))
 223                                 goto bad;
 224                         break;
 225                 case FIELD_IMAGEDIMENSIONS:
 226                         TIFFSetupShortLong(tif, TIFFTAG_IMAGEWIDTH,
 227                             dir++, td->td_imagewidth);
 228                         TIFFSetupShortLong(tif, TIFFTAG_IMAGELENGTH,
 229                             dir, td->td_imagelength);
 230                         break;
 231                 case FIELD_TILEDIMENSIONS:
 232                         TIFFSetupShortLong(tif, TIFFTAG_TILEWIDTH,
 233                             dir++, td->td_tilewidth);
 234                         TIFFSetupShortLong(tif, TIFFTAG_TILELENGTH,
 235                             dir, td->td_tilelength);
 236                         break;
 237                 case FIELD_POSITION:
 238                         WriteRationalPair(TIFF_RATIONAL,
 239                             TIFFTAG_XPOSITION, td->td_xposition,
 240                             TIFFTAG_YPOSITION, td->td_yposition);
 241                         break;
 242                 case FIELD_RESOLUTION:
 243                         WriteRationalPair(TIFF_RATIONAL,
 244                             TIFFTAG_XRESOLUTION, td->td_xresolution,
 245                             TIFFTAG_YRESOLUTION, td->td_yresolution);
 246                         break;
 247                 case FIELD_BITSPERSAMPLE:
 248                 case FIELD_MINSAMPLEVALUE:
 249                 case FIELD_MAXSAMPLEVALUE:
 250                 case FIELD_SAMPLEFORMAT:
 251                         if (!TIFFWritePerSampleShorts(tif, fip->field_tag, dir))
 252                                 goto bad;
 253                         break;
 254                 case FIELD_SMINSAMPLEVALUE:
 255                 case FIELD_SMAXSAMPLEVALUE:
 256                         if (!TIFFWritePerSampleAnys(tif,
 257                             _TIFFSampleToTagType(tif), fip->field_tag, dir))
 258                                 goto bad;
 259                         break;
 260                 case FIELD_PAGENUMBER:
 261                 case FIELD_HALFTONEHINTS:
 262 #ifdef YCBCR_SUPPORT
 263                 case FIELD_YCBCRSUBSAMPLING:
 264 #endif
 265 #ifdef CMYK_SUPPORT
 266                 case FIELD_DOTRANGE:
 267 #endif
 268                         if (!TIFFSetupShortPair(tif, fip->field_tag, dir))
 269                                 goto bad;
 270                         break;
 271 #ifdef CMYK_SUPPORT
 272                 case FIELD_INKNAMES:
 273                         if (!TIFFWriteInkNames(tif, dir))
 274                                 goto bad;
 275                         break;
 276 #endif
 277 #ifdef COLORIMETRY_SUPPORT
 278                 case FIELD_TRANSFERFUNCTION:
 279                         if (!TIFFWriteTransferFunction(tif, dir))
 280                                 goto bad;
 281                         break;
 282 #endif
 283 #if SUBIFD_SUPPORT
 284                 case FIELD_SUBIFD:
 285                         if (!TIFFWriteNormalTag(tif, dir, fip))
 286                                 goto bad;
 287                         /*
 288                          * Total hack: if this directory includes a SubIFD
 289                          * tag then force the next <n> directories to be
 290                          * written as ``sub directories'' of this one.  This
 291                          * is used to write things like thumbnails and
 292                          * image masks that one wants to keep out of the
 293                          * normal directory linkage access mechanism.
 294                          */
 295                         if (dir->tdir_count > 0) {
 296                                 tif->tif_flags |= TIFF_INSUBIFD;
 297                                 tif->tif_nsubifd = dir->tdir_count;
 298                                 if (dir->tdir_count > 1)
 299                                         tif->tif_subifdoff = dir->tdir_offset;
 300                                 else
 301                                         tif->tif_subifdoff = (uint32)(
 302                                               tif->tif_diroff
 303                                             + sizeof (uint16)
 304                                             + ((char*)&dir->tdir_offset-data));
 305                         }
 306                         break;
 307 #endif
 308                 default:
 309                         if (!TIFFWriteNormalTag(tif, dir, fip))
 310                                 goto bad;
 311                         break;
 312                 }
 313                 dir++;
 314                 ResetFieldBit(fields, fip->field_bit);
 315         }
 316         /*
 317          * Write directory.
 318          */
 319         dircount = (uint16) nfields;
 320         diroff = (uint32) tif->tif_nextdiroff;
 321         if (tif->tif_flags & TIFF_SWAB) {
 322                 /*
 323                  * The file's byte order is opposite to the
 324                  * native machine architecture.  We overwrite
 325                  * the directory information with impunity
 326                  * because it'll be released below after we
 327                  * write it to the file.  Note that all the
 328                  * other tag construction routines assume that
 329                  * we do this byte-swapping; i.e. they only
 330                  * byte-swap indirect data.
 331                  */
 332                 for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) {
 333                         TIFFSwabArrayOfShort(&dir->tdir_tag, 2);
 334                         TIFFSwabArrayOfLong(&dir->tdir_count, 2);
 335                 }
 336                 dircount = (uint16) nfields;
 337                 TIFFSwabShort(&dircount);
 338                 TIFFSwabLong(&diroff);
 339         }
 340         (void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET);
 341         if (!WriteOK(tif, &dircount, sizeof (dircount))) {
 342                 TIFFError(tif->tif_name, "Error writing directory count");
 343                 goto bad;
 344         }
 345         if (!WriteOK(tif, data, dirsize)) {
 346                 TIFFError(tif->tif_name, "Error writing directory contents");
 347                 goto bad;
 348         }
 349         if (!WriteOK(tif, &diroff, sizeof (diroff))) {
 350                 TIFFError(tif->tif_name, "Error writing directory link");
 351                 goto bad;
 352         }
 353         TIFFFreeDirectory(tif);
 354         _TIFFfree(data);
 355         tif->tif_flags &= ~TIFF_DIRTYDIRECT;
 356         (*tif->tif_cleanup)(tif);
 357
 358         /*
 359          * Reset directory-related state for subsequent
 360          * directories.
 361          */
 362         TIFFDefaultDirectory(tif);
 363         tif->tif_diroff = 0;
 364         tif->tif_curoff = 0;
 365         tif->tif_row = (uint32) -1;
 366         tif->tif_curstrip = (tstrip_t) -1;
 367         return (1);
 368 bad:
 369         _TIFFfree(data);
 370         return (0);
 371 }
 372 #undef WriteRationalPair
 373
 374 /*
 375  * Process tags that are not special cased.
 376  */
 377 static int
 378 TIFFWriteNormalTag(TIFF* tif, TIFFDirEntry* dir, const TIFFFieldInfo* fip)
 379 {
 380         u_short wc = (u_short) fip->field_writecount;
 381         uint32 wc2;
 382
 383         dir->tdir_tag = fip->field_tag;
 384         dir->tdir_type = (u_short) fip->field_type;
 385         dir->tdir_count = wc;
 386 #define WRITEF(x,y)     x(tif, fip->field_type, fip->field_tag, dir, wc, y)
 387         switch (fip->field_type) {
 388         case TIFF_SHORT:
 389         case TIFF_SSHORT:
 390                 if (wc > 1) {
 391                         uint16* wp;
 392                         if (wc == (u_short) TIFF_VARIABLE)
 393                                 TIFFGetField(tif, fip->field_tag, &wc, &wp);
 394                         else
 395                                 TIFFGetField(tif, fip->field_tag, &wp);
 396                         if (!WRITEF(TIFFWriteShortArray, wp))
 397                                 return (0);
 398                 } else {
 399                         uint16 sv;
 400                         TIFFGetField(tif, fip->field_tag, &sv);
 401                         dir->tdir_offset =
 402                             TIFFInsertData(tif, dir->tdir_type, sv);
 403                 }
 404                 break;
 405         case TIFF_LONG:
 406         case TIFF_SLONG:
 407                 if (wc > 1) {
 408                         uint32* lp;
 409                         if (wc == (u_short) TIFF_VARIABLE)
 410                                 TIFFGetField(tif, fip->field_tag, &wc, &lp);
 411                         else
 412                                 TIFFGetField(tif, fip->field_tag, &lp);
 413                         if (!WRITEF(TIFFWriteLongArray, lp))
 414                                 return (0);
 415                 } else {
 416                         /* XXX handle LONG->SHORT conversion */
 417                         TIFFGetField(tif, fip->field_tag, &dir->tdir_offset);
 418                 }
 419                 break;
 420         case TIFF_RATIONAL:
 421         case TIFF_SRATIONAL:
 422                 if (wc > 1) {
 423                         float* fp;
 424                         if (wc == (u_short) TIFF_VARIABLE)
 425                                 TIFFGetField(tif, fip->field_tag, &wc, &fp);
 426                         else
 427                                 TIFFGetField(tif, fip->field_tag, &fp);
 428                         if (!WRITEF(TIFFWriteRationalArray, fp))
 429                                 return (0);
 430                 } else {
 431                         float fv;
 432                         TIFFGetField(tif, fip->field_tag, &fv);
 433                         if (!WRITEF(TIFFWriteRationalArray, &fv))
 434                                 return (0);
 435                 }
 436                 break;
 437         case TIFF_FLOAT:
 438                 if (wc > 1) {
 439                         float* fp;
 440                         if (wc == (u_short) TIFF_VARIABLE)
 441                                 TIFFGetField(tif, fip->field_tag, &wc, &fp);
 442                         else
 443                                 TIFFGetField(tif, fip->field_tag, &fp);
 444                         if (!WRITEF(TIFFWriteFloatArray, fp))
 445                                 return (0);
 446                 } else {
 447                         float fv;
 448                         TIFFGetField(tif, fip->field_tag, &fv);
 449                         if (!WRITEF(TIFFWriteFloatArray, &fv))
 450                                 return (0);
 451                 }
 452                 break;
 453         case TIFF_DOUBLE:
 454                 if (wc > 1) {
 455                         double* dp;
 456                         if (wc == (u_short) TIFF_VARIABLE)
 457                                 TIFFGetField(tif, fip->field_tag, &wc, &dp);
 458                         else
 459                                 TIFFGetField(tif, fip->field_tag, &dp);
 460                         if (!WRITEF(TIFFWriteDoubleArray, dp))
 461                                 return (0);
 462                 } else {
 463                         double dv;
 464                         TIFFGetField(tif, fip->field_tag, &dv);
 465                         if (!WRITEF(TIFFWriteDoubleArray, &dv))
 466                                 return (0);
 467                 }
 468                 break;
 469         case TIFF_ASCII:
 470                 { char* cp;
 471                   TIFFGetField(tif, fip->field_tag, &cp);
 472                   dir->tdir_count = (uint32) (strlen(cp) + 1);
 473                   if (!TIFFWriteByteArray(tif, dir, cp))
 474                         return (0);
 475                 }
 476                 break;
 477
 478         /* added based on patch request from MARTIN.MCBRIDE.MM@agfa.co.uk,
 479            correctness not verified (FW, 99/08) */
 480         case TIFF_BYTE:
 481         case TIFF_SBYTE:
 482                 if (wc > 1) {
 483                     char* cp;
 484                     if (wc == (u_short) TIFF_VARIABLE) {
 485                         TIFFGetField(tif, fip->field_tag, &wc, &cp);
 486                         dir->tdir_count = wc;
 487                     } else
 488                         TIFFGetField(tif, fip->field_tag, &cp);
 489                     if (!TIFFWriteByteArray(tif, dir, cp))
 490                         return (0);
 491                 } else {
 492                     char cv;
 493                     TIFFGetField(tif, fip->field_tag, &cv);
 494                     if (!TIFFWriteByteArray(tif, dir, &cv))
 495                         return (0);
 496                 }
 497                 break;
 498
 499         case TIFF_UNDEFINED:
 500                 { char* cp;
 501                   if (wc == (u_short) TIFF_VARIABLE) {
 502                         TIFFGetField(tif, fip->field_tag, &wc, &cp);
 503                         dir->tdir_count = wc;
 504                   } else if (wc == (u_short) TIFF_VARIABLE2) {
 505                         TIFFGetField(tif, fip->field_tag, &wc2, &cp);
 506                         dir->tdir_count = wc2;
 507                   } else
 508                         TIFFGetField(tif, fip->field_tag, &cp);
 509                   if (!TIFFWriteByteArray(tif, dir, cp))
 510                         return (0);
 511                 }
 512                 break;
 513
 514         case TIFF_NOTYPE:
 515                 break;
 516         }
 517         return (1);
 518 }
 519 #undef WRITEF
 520
 521 /*
 522  * Setup a directory entry with either a SHORT
 523  * or LONG type according to the value.
 524  */
 525 static void
 526 TIFFSetupShortLong(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint32 v)
 527 {
 528         dir->tdir_tag = tag;
 529         dir->tdir_count = 1;
 530         if (v > 0xffffL) {
 531                 dir->tdir_type = (short) TIFF_LONG;
 532                 dir->tdir_offset = v;
 533         } else {
 534                 dir->tdir_type = (short) TIFF_SHORT;
 535                 dir->tdir_offset = TIFFInsertData(tif, (int) TIFF_SHORT, v);
 536         }
 537 }
 538 #undef MakeShortDirent
 539
 540 #ifndef TIFFWriteRational
 541 /*
 542  * Setup a RATIONAL directory entry and
 543  * write the associated indirect value.
 544  */
 545 static int
 546 TIFFWriteRational(TIFF* tif,
 547     TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, float v)
 548 {
 549         return (TIFFWriteRationalArray(tif, type, tag, dir, 1, &v));
 550 }
 551 #endif
 552
 553 #define NITEMS(x)       (sizeof (x) / sizeof (x[0]))
 554 /*
 555  * Setup a directory entry that references a
 556  * samples/pixel array of SHORT values and
 557  * (potentially) write the associated indirect
 558  * values.
 559  */
 560 static int
 561 TIFFWritePerSampleShorts(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
 562 {
 563         uint16 buf[10], v;
 564         uint16* w = buf;
 565         int i, status, samples = tif->tif_dir.td_samplesperpixel;
 566
 567         if (samples > NITEMS(buf))
 568                 w = (uint16*) _TIFFmalloc(samples * sizeof (uint16));
 569         TIFFGetField(tif, tag, &v);
 570         for (i = 0; i < samples; i++)
 571                 w[i] = v;
 572         status = TIFFWriteShortArray(tif, TIFF_SHORT, tag, dir, samples, w);
 573         if (w != buf)
 574                 _TIFFfree((char*) w);
 575         return (status);
 576 }
 577
 578 /*
 579  * Setup a directory entry that references a samples/pixel array of ``type''
 580  * values and (potentially) write the associated indirect values.  The source
 581  * data from TIFFGetField() for the specified tag must be returned as double.
 582  */
 583 static int
 584 TIFFWritePerSampleAnys(TIFF* tif,
 585     TIFFDataType type, ttag_t tag, TIFFDirEntry* dir)
 586 {
 587         double buf[10], v;
 588         double* w = buf;
 589         int i, status;
 590         int samples = (int) tif->tif_dir.td_samplesperpixel;
 591
 592         if (samples > NITEMS(buf))
 593                 w = (double*) _TIFFmalloc(samples * sizeof (double));
 594         TIFFGetField(tif, tag, &v);
 595         for (i = 0; i < samples; i++)
 596                 w[i] = v;
 597         status = TIFFWriteAnyArray(tif, type, tag, dir, samples, w);
 598         if (w != buf)
 599                 _TIFFfree(w);
 600         return (status);
 601 }
 602 #undef NITEMS
 603
 604 /*
 605  * Setup a pair of shorts that are returned by
 606  * value, rather than as a reference to an array.
 607  */
 608 static int
 609 TIFFSetupShortPair(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
 610 {
 611         uint16 v[2];
 612
 613         TIFFGetField(tif, tag, &v[0], &v[1]);
 614         return (TIFFWriteShortArray(tif, TIFF_SHORT, tag, dir, 2, v));
 615 }
 616
 617 /*
 618  * Setup a directory entry for an NxM table of shorts,
 619  * where M is known to be 2**bitspersample, and write
 620  * the associated indirect data.
 621  */
 622 static int
 623 TIFFWriteShortTable(TIFF* tif,
 624     ttag_t tag, TIFFDirEntry* dir, uint32 n, uint16** table)
 625 {
 626         uint32 i, off;
 627
 628         dir->tdir_tag = tag;
 629         dir->tdir_type = (short) TIFF_SHORT;
 630         /* XXX -- yech, fool TIFFWriteData */
 631         dir->tdir_count = (uint32) (1L<<tif->tif_dir.td_bitspersample);
 632         off = tif->tif_dataoff;
 633         for (i = 0; i < n; i++)
 634                 if (!TIFFWriteData(tif, dir, (char *)table[i]))
 635                         return (0);
 636         dir->tdir_count *= n;
 637         dir->tdir_offset = off;
 638         return (1);
 639 }
 640
 641 /*
 642  * Write/copy data associated with an ASCII or opaque tag value.
 643  */
 644 static int
 645 TIFFWriteByteArray(TIFF* tif, TIFFDirEntry* dir, char* cp)
 646 {
 647         if (dir->tdir_count > 4) {
 648                 if (!TIFFWriteData(tif, dir, cp))
 649                         return (0);
 650         } else
 651                 _TIFFmemcpy(&dir->tdir_offset, cp, dir->tdir_count);
 652         return (1);
 653 }
 654
 655 /*
 656  * Setup a directory entry of an array of SHORT
 657  * or SSHORT and write the associated indirect values.
 658  */
 659 static int
 660 TIFFWriteShortArray(TIFF* tif,
 661     TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, uint16* v)
 662 {
 663         dir->tdir_tag = tag;
 664         dir->tdir_type = (short) type;
 665         dir->tdir_count = n;
 666         if (n <= 2) {
 667                 if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
 668                         dir->tdir_offset = (uint32) ((long) v[0] << 16);
 669                         if (n == 2)
 670                                 dir->tdir_offset |= v[1] & 0xffff;
 671                 } else {
 672                         dir->tdir_offset = v[0] & 0xffff;
 673                         if (n == 2)
 674                                 dir->tdir_offset |= (long) v[1] << 16;
 675                 }
 676                 return (1);
 677         } else
 678                 return (TIFFWriteData(tif, dir, (char*) v));
 679 }
 680
 681 /*
 682  * Setup a directory entry of an array of LONG
 683  * or SLONG and write the associated indirect values.
 684  */
 685 static int
 686 TIFFWriteLongArray(TIFF* tif,
 687     TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, uint32* v)
 688 {
 689         dir->tdir_tag = tag;
 690         dir->tdir_type = (short) type;
 691         dir->tdir_count = n;
 692         if (n == 1) {
 693                 dir->tdir_offset = v[0];
 694                 return (1);
 695         } else
 696                 return (TIFFWriteData(tif, dir, (char*) v));
 697 }
 698
 699 /*
 700  * Setup a directory entry of an array of RATIONAL
 701  * or SRATIONAL and write the associated indirect values.
 702  */
 703 static int
 704 TIFFWriteRationalArray(TIFF* tif,
 705     TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, float* v)
 706 {
 707         uint32 i;
 708         uint32* t;
 709         int status;
 710
 711         dir->tdir_tag = tag;
 712         dir->tdir_type = (short) type;
 713         dir->tdir_count = n;
 714         t = (uint32*) _TIFFmalloc(2*n * sizeof (uint32));
 715         for (i = 0; i < n; i++) {
 716                 float fv = v[i];
 717                 int sign = 1;
 718                 uint32 den;
 719
 720                 if (fv < 0) {
 721                         if (type == TIFF_RATIONAL) {
 722                                 TIFFWarning(tif->tif_name,
 723         "\"%s\": Information lost writing value (%g) as (unsigned) RATIONAL",
 724                                 _TIFFFieldWithTag(tif,tag)->field_name, fv);
 725                                 fv = 0;
 726                         } else
 727                                 fv = -fv, sign = -1;
 728                 }
 729                 den = 1L;
 730                 if (fv > 0) {
 731                         while (fv < 1L<<(31-3) && den < 1L<<(31-3))
 732                                 fv *= 1<<3, den *= 1L<<3;
 733                 }
 734                 t[2*i+0] = sign * (fv + 0.5);
 735                 t[2*i+1] = den;
 736         }
 737         status = TIFFWriteData(tif, dir, (char *)t);
 738         _TIFFfree((char*) t);
 739         return (status);
 740 }
 741
 742 static int
 743 TIFFWriteFloatArray(TIFF* tif,
 744     TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, float* v)
 745 {
 746         dir->tdir_tag = tag;
 747         dir->tdir_type = (short) type;
 748         dir->tdir_count = n;
 749         TIFFCvtNativeToIEEEFloat(tif, n, v);
 750         if (n == 1) {
 751                 dir->tdir_offset = *(uint32*) &v[0];
 752                 return (1);
 753         } else
 754                 return (TIFFWriteData(tif, dir, (char*) v));
 755 }
 756
 757 static int
 758 TIFFWriteDoubleArray(TIFF* tif,
 759     TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, double* v)
 760 {
 761         dir->tdir_tag = tag;
 762         dir->tdir_type = (short) type;
 763         dir->tdir_count = n;
 764         TIFFCvtNativeToIEEEDouble(tif, n, v);
 765         return (TIFFWriteData(tif, dir, (char*) v));
 766 }
 767
 768 /*
 769  * Write an array of ``type'' values for a specified tag (i.e. this is a tag
 770  * which is allowed to have different types, e.g. SMaxSampleType).
 771  * Internally the data values are represented as double since a double can
 772  * hold any of the TIFF tag types (yes, this should really be an abstract
 773  * type tany_t for portability).  The data is converted into the specified
 774  * type in a temporary buffer and then handed off to the appropriate array
 775  * writer.
 776  */
 777 static int
 778 TIFFWriteAnyArray(TIFF* tif,
 779     TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, double* v)
 780 {
 781         char buf[10 * sizeof(double)];
 782         char* w = buf;
 783         int i, status = 0;
 784
 785         if (n * tiffDataWidth[type] > sizeof buf)
 786                 w = (char*) _TIFFmalloc(n * tiffDataWidth[type]);
 787         switch (type) {
 788         case TIFF_BYTE:
 789                 { uint8* bp = (uint8*) w;
 790                   for (i = 0; i < n; i++)
 791                         bp[i] = (uint8) v[i];
 792                   dir->tdir_tag = tag;
 793                   dir->tdir_type = (short) type;
 794                   dir->tdir_count = n;
 795                   if (!TIFFWriteByteArray(tif, dir, (char*) bp))
 796                         goto out;
 797                 }
 798                 break;
 799         case TIFF_SBYTE:
 800                 { int8* bp = (int8*) w;
 801                   for (i = 0; i < n; i++)
 802                         bp[i] = (int8) v[i];
 803                   dir->tdir_tag = tag;
 804                   dir->tdir_type = (short) type;
 805                   dir->tdir_count = n;
 806                   if (!TIFFWriteByteArray(tif, dir, (char*) bp))
 807                         goto out;
 808                 }
 809                 break;
 810         case TIFF_SHORT:
 811                 { uint16* bp = (uint16*) w;
 812                   for (i = 0; i < n; i++)
 813                         bp[i] = (uint16) v[i];
 814                   if (!TIFFWriteShortArray(tif, type, tag, dir, n, (uint16*)bp))
 815                                 goto out;
 816                 }
 817                 break;
 818         case TIFF_SSHORT:
 819                 { int16* bp = (int16*) w;
 820                   for (i = 0; i < n; i++)
 821                         bp[i] = (int16) v[i];
 822                   if (!TIFFWriteShortArray(tif, type, tag, dir, n, (uint16*)bp))
 823                         goto out;
 824                 }
 825                 break;
 826         case TIFF_LONG:
 827                 { uint32* bp = (uint32*) w;
 828                   for (i = 0; i < n; i++)
 829                         bp[i] = (uint32) v[i];
 830                   if (!TIFFWriteLongArray(tif, type, tag, dir, n, bp))
 831                         goto out;
 832                 }
 833                 break;
 834         case TIFF_SLONG:
 835                 { int32* bp = (int32*) w;
 836                   for (i = 0; i < n; i++)
 837                         bp[i] = (int32) v[i];
 838                   if (!TIFFWriteLongArray(tif, type, tag, dir, n, (uint32*) bp))
 839                         goto out;
 840                 }
 841                 break;
 842         case TIFF_FLOAT:
 843                 { float* bp = (float*) w;
 844                   for (i = 0; i < n; i++)
 845                         bp[i] = (float) v[i];
 846                   if (!TIFFWriteFloatArray(tif, type, tag, dir, n, bp))
 847                         goto out;
 848                 }
 849                 break;
 850         case TIFF_DOUBLE:
 851                 return (TIFFWriteDoubleArray(tif, type, tag, dir, n, v));
 852         default:
 853                 /* TIFF_NOTYPE */
 854                 /* TIFF_ASCII */
 855                 /* TIFF_UNDEFINED */
 856                 /* TIFF_RATIONAL */
 857                 /* TIFF_SRATIONAL */
 858                 goto out;
 859         }
 860         status = 1;
 861  out:
 862         if (w != buf)
 863                 _TIFFfree(w);
 864         return (status);
 865 }
 866
 867 #ifdef COLORIMETRY_SUPPORT
 868 static int
 869 TIFFWriteTransferFunction(TIFF* tif, TIFFDirEntry* dir)
 870 {
 871         TIFFDirectory* td = &tif->tif_dir;
 872         tsize_t n = (1L<<td->td_bitspersample) * sizeof (uint16);
 873         uint16** tf = td->td_transferfunction;
 874         int ncols;
 875
 876         /*
 877          * Check if the table can be written as a single column,
 878          * or if it must be written as 3 columns.  Note that we
 879          * write a 3-column tag if there are 2 samples/pixel and
 880          * a single column of data won't suffice--hmm.
 881          */
 882         switch (td->td_samplesperpixel - td->td_extrasamples) {
 883         default:        if (_TIFFmemcmp(tf[0], tf[2], n)) { ncols = 3; break; }
 884         case 2:         if (_TIFFmemcmp(tf[0], tf[1], n)) { ncols = 3; break; }
 885         case 1: case 0: ncols = 1;
 886         }
 887         return (TIFFWriteShortTable(tif,
 888             TIFFTAG_TRANSFERFUNCTION, dir, ncols, tf));
 889 }
 890 #endif
 891
 892 #ifdef CMYK_SUPPORT
 893 static int
 894 TIFFWriteInkNames(TIFF* tif, TIFFDirEntry* dir)
 895 {
 896         TIFFDirectory* td = &tif->tif_dir;
 897
 898         dir->tdir_tag = TIFFTAG_INKNAMES;
 899         dir->tdir_type = (short) TIFF_ASCII;
 900         dir->tdir_count = td->td_inknameslen;
 901         return (TIFFWriteByteArray(tif, dir, td->td_inknames));
 902 }
 903 #endif
 904
 905 /*
 906  * Write a contiguous directory item.
 907  */
 908 static int
 909 TIFFWriteData(TIFF* tif, TIFFDirEntry* dir, char* cp)
 910 {
 911         tsize_t cc;
 912
 913         if (tif->tif_flags & TIFF_SWAB) {
 914                 switch (dir->tdir_type) {
 915                 case TIFF_SHORT:
 916                 case TIFF_SSHORT:
 917                         TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count);
 918                         break;
 919                 case TIFF_LONG:
 920                 case TIFF_SLONG:
 921                 case TIFF_FLOAT:
 922                         TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count);
 923                         break;
 924                 case TIFF_RATIONAL:
 925                 case TIFF_SRATIONAL:
 926                         TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count);
 927                         break;
 928                 case TIFF_DOUBLE:
 929                         TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count);
 930                         break;
 931                 }
 932         }
 933         dir->tdir_offset = tif->tif_dataoff;
 934         cc = dir->tdir_count * tiffDataWidth[dir->tdir_type];
 935         if (SeekOK(tif, dir->tdir_offset) &&
 936             WriteOK(tif, cp, cc)) {
 937                 tif->tif_dataoff += (cc + 1) & ~1;
 938                 return (1);
 939         }
 940         TIFFError(tif->tif_name, "Error writing data for field \"%s\"",
 941             _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
 942         return (0);
 943 }
 944
 945 /*
 946  * Link the current directory into the
 947  * directory chain for the file.
 948  */
 949 static int
 950 TIFFLinkDirectory(TIFF* tif)
 951 {
 952         static const char module[] = "TIFFLinkDirectory";
 953         uint32 nextdir;
 954         uint32 diroff;
 955
 956         tif->tif_diroff = (TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1;
 957         diroff = (uint32) tif->tif_diroff;
 958         if (tif->tif_flags & TIFF_SWAB)
 959                 TIFFSwabLong(&diroff);
 960 #if SUBIFD_SUPPORT
 961         if (tif->tif_flags & TIFF_INSUBIFD) {
 962                 (void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET);
 963                 if (!WriteOK(tif, &diroff, sizeof (diroff))) {
 964                         TIFFError(module,
 965                             "%s: Error writing SubIFD directory link",
 966                             tif->tif_name);
 967                         return (0);
 968                 }
 969                 /*
 970                  * Advance to the next SubIFD or, if this is
 971                  * the last one configured, revert back to the
 972                  * normal directory linkage.
 973                  */
 974                 if (--tif->tif_nsubifd)
 975                         tif->tif_subifdoff += sizeof (diroff);
 976                 else
 977                         tif->tif_flags &= ~TIFF_INSUBIFD;
 978                 return (1);
 979         }
 980 #endif
 981         if (tif->tif_header.tiff_diroff == 0) {
 982                 /*
 983                  * First directory, overwrite offset in header.
 984                  */
 985                 tif->tif_header.tiff_diroff = (uint32) tif->tif_diroff;
 986 #define HDROFF(f)       ((toff_t) &(((TIFFHeader*) 0)->f))
 987                 (void) TIFFSeekFile(tif, HDROFF(tiff_diroff), SEEK_SET);
 988                 if (!WriteOK(tif, &diroff, sizeof (diroff))) {
 989                         TIFFError(tif->tif_name, "Error writing TIFF header");
 990                         return (0);
 991                 }
 992                 return (1);
 993         }
 994         /*
 995          * Not the first directory, search to the last and append.
 996          */
 997         nextdir = tif->tif_header.tiff_diroff;
 998         do {
 999                 uint16 dircount;
1000
1001                 if (!SeekOK(tif, nextdir) ||
1002                     !ReadOK(tif, &dircount, sizeof (dircount))) {
1003                         TIFFError(module, "Error fetching directory count");
1004                         return (0);
1005                 }
1006                 if (tif->tif_flags & TIFF_SWAB)
1007                         TIFFSwabShort(&dircount);
1008                 (void) TIFFSeekFile(tif,
1009                     dircount * sizeof (TIFFDirEntry), SEEK_CUR);
1010                 if (!ReadOK(tif, &nextdir, sizeof (nextdir))) {
1011                         TIFFError(module, "Error fetching directory link");
1012                         return (0);
1013                 }
1014                 if (tif->tif_flags & TIFF_SWAB)
1015                         TIFFSwabLong(&nextdir);
1016         } while (nextdir != 0);
1017         (void) TIFFSeekFile(tif, -(toff_t) sizeof (nextdir), SEEK_CUR);
1018         if (!WriteOK(tif, &diroff, sizeof (diroff))) {
1019                 TIFFError(module, "Error writing directory link");
1020                 return (0);
1021         }
1022         return (1);
1023 }