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