/*

 * Copyright (c) 1988-1997 Sam Leffler

 * Copyright (c) 1991-1997 Silicon Graphics, Inc.

 *

 * Permission to use, copy, modify, distribute, and sell this software and

 * its documentation for any purpose is hereby granted without fee, provided

 * that (i) the above copyright notices and this permission notice appear in

 * all copies of the software and related documentation, and (ii) the names of

 * Sam Leffler and Silicon Graphics may not be used in any advertising or

 * publicity relating to the software without the specific, prior written

 * permission of Sam Leffler and Silicon Graphics.

 *

 * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY

 * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

 *

 * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR

 * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,

 * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

 * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF

 * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

 * OF THIS SOFTWARE.

 */

/*

 * TIFF Library.

 *

 * Directory Write Support Routines.

 */

#include "tiffiop.h"

#include <float.h>    /*--: for Rational2Double */

#include <math.h>   /*--: for Rational2Double */

#ifdef HAVE_IEEEFP

#define TIFFCvtNativeToIEEEFloat(tif, n, fp)

#define TIFFCvtNativeToIEEEDouble(tif, n, dp)

#else

extern void TIFFCvtNativeToIEEEFloat(TIFF* tif, uint32_t n, float* fp);

extern void TIFFCvtNativeToIEEEDouble(TIFF* tif, uint32_t n, double* dp);

#endif

static int TIFFWriteDirectorySec(TIFF* tif, int isimage, int imagedone, uint64_t* pdiroff);

static int TIFFWriteDirectoryTagSampleformatArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, double* value);

#if 0

static int TIFFWriteDirectoryTagSampleformatPerSample(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, double value);

#endif

static int TIFFWriteDirectoryTagAscii(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, char* value);

static int TIFFWriteDirectoryTagUndefinedArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint8_t* value);

#ifdef notdef

static int TIFFWriteDirectoryTagByte(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint8_t value);

#endif

static int TIFFWriteDirectoryTagByteArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint8_t* value);

#if 0

static int TIFFWriteDirectoryTagBytePerSample(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint8_t value);

#endif

#ifdef notdef

static int TIFFWriteDirectoryTagSbyte(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, int8_t value);

#endif

static int TIFFWriteDirectoryTagSbyteArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, int8_t* value);

#if 0

static int TIFFWriteDirectoryTagSbytePerSample(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, int8_t value);

#endif

static int TIFFWriteDirectoryTagShort(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint16_t value);

static int TIFFWriteDirectoryTagShortArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint16_t* value);

static int TIFFWriteDirectoryTagShortPerSample(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint16_t value);

#ifdef notdef

static int TIFFWriteDirectoryTagSshort(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, int16_t value);

#endif

static int TIFFWriteDirectoryTagSshortArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, int16_t* value);

#if 0

static int TIFFWriteDirectoryTagSshortPerSample(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, int16_t value);

#endif

static int TIFFWriteDirectoryTagLong(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t value);

static int TIFFWriteDirectoryTagLongArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint32_t* value);

#if 0

static int TIFFWriteDirectoryTagLongPerSample(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t value);

#endif

#ifdef notdef

static int TIFFWriteDirectoryTagSlong(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, int32_t value);

#endif

static int TIFFWriteDirectoryTagSlongArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, int32_t* value);

#if 0

static int TIFFWriteDirectoryTagSlongPerSample(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, int32_t value);

#endif

#ifdef notdef

static int TIFFWriteDirectoryTagLong8(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint64_t value);

#endif

static int TIFFWriteDirectoryTagLong8Array(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint64_t* value);

#ifdef notdef

static int TIFFWriteDirectoryTagSlong8(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, int64_t value);

#endif

static int TIFFWriteDirectoryTagSlong8Array(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, int64_t* value);

static int TIFFWriteDirectoryTagRational(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, double value);

static int TIFFWriteDirectoryTagRationalArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, float* value);

static int TIFFWriteDirectoryTagSrationalArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, float* value);

#ifdef notdef

static int TIFFWriteDirectoryTagFloat(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, float value);

#endif

static int TIFFWriteDirectoryTagFloatArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, float* value);

#if 0

static int TIFFWriteDirectoryTagFloatPerSample(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, float value);

#endif

#ifdef notdef

static int TIFFWriteDirectoryTagDouble(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, double value);

#endif

static int TIFFWriteDirectoryTagDoubleArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, double* value);

#if 0

static int TIFFWriteDirectoryTagDoublePerSample(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, double value);

#endif

static int TIFFWriteDirectoryTagIfdArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint32_t* value);

#ifdef notdef

static int TIFFWriteDirectoryTagIfd8Array(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint64_t* value);

#endif

static int TIFFWriteDirectoryTagShortLong(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t value);

static int TIFFWriteDirectoryTagLongLong8Array(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint64_t* value);

static int TIFFWriteDirectoryTagIfdIfd8Array(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint64_t* value);

#ifdef notdef

static int TIFFWriteDirectoryTagShortLongLong8Array(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint64_t* value);

#endif

static int TIFFWriteDirectoryTagColormap(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir);

static int TIFFWriteDirectoryTagTransferfunction(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir);

static int TIFFWriteDirectoryTagSubifd(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir);

static int TIFFWriteDirectoryTagCheckedAscii(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, char* value);

static int TIFFWriteDirectoryTagCheckedUndefinedArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint8_t* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedByte(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint8_t value);

#endif

static int TIFFWriteDirectoryTagCheckedByteArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint8_t* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedSbyte(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, int8_t value);

#endif

static int TIFFWriteDirectoryTagCheckedSbyteArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, int8_t* value);

static int TIFFWriteDirectoryTagCheckedShort(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint16_t value);

static int TIFFWriteDirectoryTagCheckedShortArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint16_t* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedSshort(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, int16_t value);

#endif

static int TIFFWriteDirectoryTagCheckedSshortArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, int16_t* value);

static int TIFFWriteDirectoryTagCheckedLong(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t value);

static int TIFFWriteDirectoryTagCheckedLongArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint32_t* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedSlong(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, int32_t value);

#endif

static int TIFFWriteDirectoryTagCheckedSlongArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, int32_t* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedLong8(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint64_t value);

#endif

static int TIFFWriteDirectoryTagCheckedLong8Array(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint64_t* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedSlong8(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, int64_t value);

#endif

static int TIFFWriteDirectoryTagCheckedSlong8Array(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, int64_t* value);

static int TIFFWriteDirectoryTagCheckedRational(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, double value);

static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, float* value);

static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, float* value);

/*--: Rational2Double: New functions to support true double-precision for custom rational tag types. */

static int TIFFWriteDirectoryTagRationalDoubleArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, double* value);

static int TIFFWriteDirectoryTagSrationalDoubleArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, double* value);

static int TIFFWriteDirectoryTagCheckedRationalDoubleArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, double* value);

static int TIFFWriteDirectoryTagCheckedSrationalDoubleArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, double* value);

static void DoubleToRational(double value, uint32_t *num, uint32_t *denom);

static void DoubleToSrational(double value, int32_t *num, int32_t *denom);

#if 0

static void DoubleToRational_direct(double value, unsigned long *num, unsigned long *denom);

static void DoubleToSrational_direct(double value, long *num, long *denom);

#endif

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedFloat(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, float value);

#endif

static int TIFFWriteDirectoryTagCheckedFloatArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, float* value);

#ifdef notdef

static int TIFFWriteDirectoryTagCheckedDouble(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, double value);

#endif

static int TIFFWriteDirectoryTagCheckedDoubleArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, double* value);

static int TIFFWriteDirectoryTagCheckedIfdArray(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint32_t* value);

static int TIFFWriteDirectoryTagCheckedIfd8Array(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint32_t count, uint64_t* value);

static int TIFFWriteDirectoryTagData(TIFF* tif, uint32_t* ndir, TIFFDirEntry* dir, uint16_t tag, uint16_t datatype, uint32_t count, uint32_t datalength, void* data);

static int TIFFLinkDirectory(TIFF*);

/*

 * Write the contents of the current directory

 * to the specified file.  This routine doesn't

 * handle overwriting a directory with auxiliary

 * storage that's been changed.

 */

int

TIFFWriteDirectory(TIFF* tif)

{

  return TIFFWriteDirectorySec(tif,TRUE,TRUE,NULL);

}

/*

 * This is an advanced writing function that must be used in a particular

 * sequence, and generally together with TIFFForceStrileArrayWriting(),

 * to make its intended effect. Its aim is to modify the location

 * where the [Strip/Tile][Offsets/ByteCounts] arrays are located in the file.

 * More precisely, when TIFFWriteCheck() will be called, the tag entries for

 * those arrays will be written with type = count = offset = 0 as a temporary

 * value.

 *

 * Its effect is only valid for the current directory, and before

 * TIFFWriteDirectory() is first called, and  will be reset when

 * changing directory.

 *

 * The typical sequence of calls is:

 * TIFFOpen()

 * [ TIFFCreateDirectory(tif) ]

 * Set fields with calls to TIFFSetField(tif, ...)

 * TIFFDeferStrileArrayWriting(tif)

 * TIFFWriteCheck(tif, ...)

 * TIFFWriteDirectory(tif)

 * ... potentially create other directories and come back to the above directory

 * TIFFForceStrileArrayWriting(tif): emit the arrays at the end of file

 *

 * Returns 1 in case of success, 0 otherwise.

 */

int TIFFDeferStrileArrayWriting(TIFF* tif)

{

    static const char module[] = "TIFFDeferStrileArrayWriting";

    if (tif->tif_mode == O_RDONLY)

    {

        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

                     "File opened in read-only mode");

        return 0;

    }

    if( tif->tif_diroff != 0 )

    {

        TIFFErrorExt(tif->tif_clientdata, module,

                     "Directory has already been written");

        return 0;

    }

    tif->tif_dir.td_deferstrilearraywriting = TRUE;

    return 1;

}

/*

 * Similar to TIFFWriteDirectory(), writes the directory out

 * but leaves all data structures in memory so that it can be

 * written again.  This will make a partially written TIFF file

 * readable before it is successfully completed/closed.

 */

int

TIFFCheckpointDirectory(TIFF* tif)

{

  int rc;

  /* Setup the strips arrays, if they haven't already been. */

  if (tif->tif_dir.td_stripoffset_p == NULL)

      (void) TIFFSetupStrips(tif);

  rc = TIFFWriteDirectorySec(tif,TRUE,FALSE,NULL);

  (void) TIFFSetWriteOffset(tif, TIFFSeekFile(tif, 0, SEEK_END));

  return rc;

}

int

TIFFWriteCustomDirectory(TIFF* tif, uint64_t* pdiroff)

{

  return TIFFWriteDirectorySec(tif,FALSE,FALSE,pdiroff);

}

/*

 * Similar to TIFFWriteDirectory(), but if the directory has already

 * been written once, it is relocated to the end of the file, in case it

 * has changed in size.  Note that this will result in the loss of the

 * previously used directory space. 

 */ 

int

TIFFRewriteDirectory( TIFF *tif )

{

  static const char module[] = "TIFFRewriteDirectory";

  /* We don't need to do anything special if it hasn't been written. */

  if( tif->tif_diroff == 0 )

    return TIFFWriteDirectory( tif );

  /*

   * Find and zero the pointer to this directory, so that TIFFLinkDirectory

   * will cause it to be added after this directories current pre-link.

   */

  if (!(tif->tif_flags&TIFF_BIGTIFF))

  {

    if (tif->tif_header.classic.tiff_diroff == tif->tif_diroff)

    {

      tif->tif_header.classic.tiff_diroff = 0;

      tif->tif_diroff = 0;

      TIFFSeekFile(tif,4,SEEK_SET);

      if (!WriteOK(tif, &(tif->tif_header.classic.tiff_diroff),4))

      {

        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

            "Error updating TIFF header");

        return (0);

      }

    }

    else

    {

      uint32_t nextdir;

      nextdir = tif->tif_header.classic.tiff_diroff;

      while(1) {

        uint16_t dircount;

        uint32_t nextnextdir;

        if (!SeekOK(tif, nextdir) ||

            !ReadOK(tif, &dircount, 2)) {

          TIFFErrorExt(tif->tif_clientdata, module,

               "Error fetching directory count");

          return (0);

        }

        if (tif->tif_flags & TIFF_SWAB)

          TIFFSwabShort(&dircount);

        (void) TIFFSeekFile(tif,

            nextdir+2+dircount*12, SEEK_SET);

        if (!ReadOK(tif, &nextnextdir, 4)) {

          TIFFErrorExt(tif->tif_clientdata, module,

               "Error fetching directory link");

          return (0);

        }

        if (tif->tif_flags & TIFF_SWAB)

          TIFFSwabLong(&nextnextdir);

        if (nextnextdir==tif->tif_diroff)

        {

          uint32_t m;

          m=0;

          (void) TIFFSeekFile(tif,

              nextdir+2+dircount*12, SEEK_SET);

          if (!WriteOK(tif, &m, 4)) {

            TIFFErrorExt(tif->tif_clientdata, module,

                 "Error writing directory link");

            return (0);

          }

          tif->tif_diroff=0;

          break;

        }

        nextdir=nextnextdir;

      }

    }

  }

  else

  {

    if (tif->tif_header.big.tiff_diroff == tif->tif_diroff)

    {

      tif->tif_header.big.tiff_diroff = 0;

      tif->tif_diroff = 0;

      TIFFSeekFile(tif,8,SEEK_SET);

      if (!WriteOK(tif, &(tif->tif_header.big.tiff_diroff),8))

      {

        TIFFErrorExt(tif->tif_clientdata, tif->tif_name,

            "Error updating TIFF header");

        return (0);

      }

    }

    else

    {

      uint64_t nextdir;

      nextdir = tif->tif_header.big.tiff_diroff;

      while(1) {

        uint64_t dircount64;

        uint16_t dircount;

        uint64_t nextnextdir;

        if (!SeekOK(tif, nextdir) ||

            !ReadOK(tif, &dircount64, 8)) {

          TIFFErrorExt(tif->tif_clientdata, module,

               "Error fetching directory count");

          return (0);

        }

        if (tif->tif_flags & TIFF_SWAB)

          TIFFSwabLong8(&dircount64);

        if (dircount64>0xFFFF)

        {

          TIFFErrorExt(tif->tif_clientdata, module,

               "Sanity check on tag count failed, likely corrupt TIFF");

          return (0);

        }

        dircount=(uint16_t)dircount64;

        (void) TIFFSeekFile(tif,

            nextdir+8+dircount*20, SEEK_SET);

        if (!ReadOK(tif, &nextnextdir, 8)) {

          TIFFErrorExt(tif->tif_clientdata, module,

               "Error fetching directory link");

          return (0);

        }

        if (tif->tif_flags & TIFF_SWAB)

          TIFFSwabLong8(&nextnextdir);

        if (nextnextdir==tif->tif_diroff)

        {

          uint64_t m;

          m=0;

          (void) TIFFSeekFile(tif,

              nextdir+8+dircount*20, SEEK_SET);

          if (!WriteOK(tif, &m, 8)) {

            TIFFErrorExt(tif->tif_clientdata, module,

                 "Error writing directory link");

            return (0);

          }

          tif->tif_diroff=0;

          break;

        }

        nextdir=nextnextdir;

      }

    }

  }

  /*

   * Now use TIFFWriteDirectory() normally.

   */

  return TIFFWriteDirectory( tif );

}

static int

TIFFWriteDirectorySec(TIFF* tif, int isimage, int imagedone, uint64_t* pdiroff)

{

  static const char module[] = "TIFFWriteDirectorySec";

  uint32_t ndir;

  TIFFDirEntry* dir;

  uint32_t dirsize;

  void* dirmem;

  uint32_t m;

  if (tif->tif_mode == O_RDONLY)

    return (1);

        _TIFFFillStriles( tif );

  /*

   * Clear write state so that subsequent images with

   * different characteristics get the right buffers

   * setup for them.

   */

  if (imagedone)

  {

    if (tif->tif_flags & TIFF_POSTENCODE)

    {

      tif->tif_flags &= ~TIFF_POSTENCODE;

      if (!(*tif->tif_postencode)(tif))

      {

        TIFFErrorExt(tif->tif_clientdata,module,

            "Error post-encoding before directory write");

        return (0);

      }

    }

    (*tif->tif_close)(tif);       /* shutdown encoder */

    /*

     * Flush any data that might have been written

     * by the compression close+cleanup routines.  But

                 * be careful not to write stuff if we didn't add data

                 * in the previous steps as the "rawcc" data may well be

                 * a previously read tile/strip in mixed read/write mode.

     */

    if (tif->tif_rawcc > 0 

        && (tif->tif_flags & TIFF_BEENWRITING) != 0 )

    {

        if( !TIFFFlushData1(tif) )

                    {

      TIFFErrorExt(tif->tif_clientdata, module,

          "Error flushing data before directory write");

      return (0);

                    }

    }

    if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata)

    {

      _TIFFfree(tif->tif_rawdata);

      tif->tif_rawdata = NULL;

      tif->tif_rawcc = 0;

      tif->tif_rawdatasize = 0;

                        tif->tif_rawdataoff = 0;

                        tif->tif_rawdataloaded = 0;

    }

    tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP);

  }

  dir=NULL;

  dirmem=NULL;

  dirsize=0;

  while (1)

  {

    ndir=0;

    if (isimage)

    {

      if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS))

      {

        if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGEWIDTH,tif->tif_dir.td_imagewidth))

          goto bad;

        if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_IMAGELENGTH,tif->tif_dir.td_imagelength))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS))

      {

        if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILEWIDTH,tif->tif_dir.td_tilewidth))

          goto bad;

        if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_TILELENGTH,tif->tif_dir.td_tilelength))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_RESOLUTION))

      {

        if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XRESOLUTION,tif->tif_dir.td_xresolution))

          goto bad;

        if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YRESOLUTION,tif->tif_dir.td_yresolution))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_POSITION))

      {

        if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_XPOSITION,tif->tif_dir.td_xposition))

          goto bad;

        if (!TIFFWriteDirectoryTagRational(tif,&ndir,dir,TIFFTAG_YPOSITION,tif->tif_dir.td_yposition))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_SUBFILETYPE))

      {

        if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_SUBFILETYPE,tif->tif_dir.td_subfiletype))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))

      {

        if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_BITSPERSAMPLE,tif->tif_dir.td_bitspersample))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_COMPRESSION))

      {

        if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_COMPRESSION,tif->tif_dir.td_compression))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC))

      {

        if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PHOTOMETRIC,tif->tif_dir.td_photometric))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_THRESHHOLDING))

      {

        if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_THRESHHOLDING,tif->tif_dir.td_threshholding))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_FILLORDER))

      {

        if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_FILLORDER,tif->tif_dir.td_fillorder))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_ORIENTATION))

      {

        if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_ORIENTATION,tif->tif_dir.td_orientation))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))

      {

        if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_SAMPLESPERPIXEL,tif->tif_dir.td_samplesperpixel))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP))

      {

        if (!TIFFWriteDirectoryTagShortLong(tif,&ndir,dir,TIFFTAG_ROWSPERSTRIP,tif->tif_dir.td_rowsperstrip))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE))

      {

        if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MINSAMPLEVALUE,tif->tif_dir.td_minsamplevalue))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE))

      {

        if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_MAXSAMPLEVALUE,tif->tif_dir.td_maxsamplevalue))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_PLANARCONFIG))

      {

        if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_PLANARCONFIG,tif->tif_dir.td_planarconfig))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT))

      {

        if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_RESOLUTIONUNIT,tif->tif_dir.td_resolutionunit))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_PAGENUMBER))

      {

        if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_PAGENUMBER,2,&tif->tif_dir.td_pagenumber[0]))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_STRIPBYTECOUNTS))

      {

        if (!isTiled(tif))

        {

          if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount_p))

            goto bad;

        }

        else

        {

          if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEBYTECOUNTS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripbytecount_p))

            goto bad;

        }

      }

      if (TIFFFieldSet(tif,FIELD_STRIPOFFSETS))

      {

        if (!isTiled(tif))

        {

                    /* td_stripoffset_p might be NULL in an odd OJPEG case. See

                     *  tif_dirread.c around line 3634.

                     * XXX: OJPEG hack.

                     * If a) compression is OJPEG, b) it's not a tiled TIFF,

                     * and c) the number of strips is 1,

                     * then we tolerate the absence of stripoffsets tag,

                     * because, presumably, all required data is in the

                     * JpegInterchangeFormat stream.

                     * We can get here when using tiffset on such a file.

                     * See http://bugzilla.maptools.org/show_bug.cgi?id=2500

                    */

                    if (tif->tif_dir.td_stripoffset_p != NULL &&

                        !TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_STRIPOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset_p))

                        goto bad;

        }

        else

        {

          if (!TIFFWriteDirectoryTagLongLong8Array(tif,&ndir,dir,TIFFTAG_TILEOFFSETS,tif->tif_dir.td_nstrips,tif->tif_dir.td_stripoffset_p))

            goto bad;

        }

      }

      if (TIFFFieldSet(tif,FIELD_COLORMAP))

      {

        if (!TIFFWriteDirectoryTagColormap(tif,&ndir,dir))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES))

      {

        if (tif->tif_dir.td_extrasamples)

        {

          uint16_t na;

          uint16_t* nb;

          TIFFGetFieldDefaulted(tif,TIFFTAG_EXTRASAMPLES,&na,&nb);

          if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_EXTRASAMPLES,na,nb))

            goto bad;

        }

      }

      if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT))

      {

        if (!TIFFWriteDirectoryTagShortPerSample(tif,&ndir,dir,TIFFTAG_SAMPLEFORMAT,tif->tif_dir.td_sampleformat))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE))

      {

        if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMINSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_sminsamplevalue))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE))

      {

        if (!TIFFWriteDirectoryTagSampleformatArray(tif,&ndir,dir,TIFFTAG_SMAXSAMPLEVALUE,tif->tif_dir.td_samplesperpixel,tif->tif_dir.td_smaxsamplevalue))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH))

      {

        if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_IMAGEDEPTH,tif->tif_dir.td_imagedepth))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_TILEDEPTH))

      {

        if (!TIFFWriteDirectoryTagLong(tif,&ndir,dir,TIFFTAG_TILEDEPTH,tif->tif_dir.td_tiledepth))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS))

      {

        if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_HALFTONEHINTS,2,&tif->tif_dir.td_halftonehints[0]))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING))

      {

        if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,TIFFTAG_YCBCRSUBSAMPLING,2,&tif->tif_dir.td_ycbcrsubsampling[0]))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING))

      {

        if (!TIFFWriteDirectoryTagShort(tif,&ndir,dir,TIFFTAG_YCBCRPOSITIONING,tif->tif_dir.td_ycbcrpositioning))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_REFBLACKWHITE))

      {

        if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,TIFFTAG_REFERENCEBLACKWHITE,6,tif->tif_dir.td_refblackwhite))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION))

      {

        if (!TIFFWriteDirectoryTagTransferfunction(tif,&ndir,dir))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_INKNAMES))

      {

        if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,TIFFTAG_INKNAMES,tif->tif_dir.td_inknameslen,tif->tif_dir.td_inknames))

          goto bad;

      }

      if (TIFFFieldSet(tif,FIELD_SUBIFD))

      {

        if (!TIFFWriteDirectoryTagSubifd(tif,&ndir,dir))

          goto bad;

      }

      {

        uint32_t n;

        for (n=0; n<tif->tif_nfields; n++) {

          const TIFFField* o;

          o = tif->tif_fields[n];

          if ((o->field_bit>=FIELD_CODEC)&&(TIFFFieldSet(tif,o->field_bit)))

          {

            switch (o->get_field_type)

            {

              case TIFF_SETGET_ASCII:

                {

                  uint32_t pa;

                  char* pb;

                  assert(o->field_type==TIFF_ASCII);

                  assert(o->field_readcount==TIFF_VARIABLE);

                  assert(o->field_passcount==0);

                  TIFFGetField(tif,o->field_tag,&pb);

                  pa=(uint32_t)(strlen(pb));

                  if (!TIFFWriteDirectoryTagAscii(tif, &ndir, dir, (uint16_t)o->field_tag, pa, pb))

                    goto bad;

                }

                break;

              case TIFF_SETGET_UINT16:

                {

                  uint16_t p;

                  assert(o->field_type==TIFF_SHORT);

                  assert(o->field_readcount==1);

                  assert(o->field_passcount==0);

                  TIFFGetField(tif,o->field_tag,&p);

                  if (!TIFFWriteDirectoryTagShort(tif, &ndir, dir, (uint16_t)o->field_tag, p))

                    goto bad;

                }

                break;

              case TIFF_SETGET_UINT32:

                {

                  uint32_t p;

                  assert(o->field_type==TIFF_LONG);

                  assert(o->field_readcount==1);

                  assert(o->field_passcount==0);

                  TIFFGetField(tif,o->field_tag,&p);

                  if (!TIFFWriteDirectoryTagLong(tif, &ndir, dir, (uint16_t)o->field_tag, p))

                    goto bad;

                }

                break;

              case TIFF_SETGET_C32_UINT8:

                {

                  uint32_t pa;

                  void* pb;

                  assert(o->field_type==TIFF_UNDEFINED);

                  assert(o->field_readcount==TIFF_VARIABLE2);

                  assert(o->field_passcount==1);

                  TIFFGetField(tif,o->field_tag,&pa,&pb);

                  if (!TIFFWriteDirectoryTagUndefinedArray(tif, &ndir, dir, (uint16_t)o->field_tag, pa, pb))

                    goto bad;

                }

                break;

              default:

                TIFFErrorExt(tif->tif_clientdata,module,

                            "Cannot write tag %"PRIu32" (%s)",

                            TIFFFieldTag(o),

                                                                            o->field_name ? o->field_name : "unknown");

                goto bad;

            }

          }

        }

      }

    }

    for (m=0; m<(uint32_t)(tif->tif_dir.td_customValueCount); m++)

    {

                        uint16_t tag = (uint16_t)tif->tif_dir.td_customValues[m].info->field_tag;

                        uint32_t count = tif->tif_dir.td_customValues[m].count;

      switch (tif->tif_dir.td_customValues[m].info->field_type)

      {

        case TIFF_ASCII:

          if (!TIFFWriteDirectoryTagAscii(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_UNDEFINED:

          if (!TIFFWriteDirectoryTagUndefinedArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_BYTE:

          if (!TIFFWriteDirectoryTagByteArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_SBYTE:

          if (!TIFFWriteDirectoryTagSbyteArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_SHORT:

          if (!TIFFWriteDirectoryTagShortArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_SSHORT:

          if (!TIFFWriteDirectoryTagSshortArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_LONG:

          if (!TIFFWriteDirectoryTagLongArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_SLONG:

          if (!TIFFWriteDirectoryTagSlongArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_LONG8:

          if (!TIFFWriteDirectoryTagLong8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_SLONG8:

          if (!TIFFWriteDirectoryTagSlong8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_RATIONAL:

          {

            /*-- Rational2Double: For Rationals evaluate "set_field_type" to determine internal storage size. */

            int tv_size;

            tv_size = _TIFFSetGetFieldSize(tif->tif_dir.td_customValues[m].info->set_field_type);

            if (tv_size == 8) {

              if (!TIFFWriteDirectoryTagRationalDoubleArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

                goto bad;

            } else {

              /*-- default should be tv_size == 4 */

              if (!TIFFWriteDirectoryTagRationalArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

                goto bad;

              /*-- ToDo: After Testing, this should be removed and tv_size==4 should be set as default. */

              if (tv_size != 4) {

                TIFFErrorExt(0,"TIFFLib: _TIFFWriteDirectorySec()", "Rational2Double: .set_field_type in not 4 but %d", tv_size); 

              }

            }

          }

          break;

        case TIFF_SRATIONAL:

          {

            /*-- Rational2Double: For Rationals evaluate "set_field_type" to determine internal storage size. */

            int tv_size;

            tv_size = _TIFFSetGetFieldSize(tif->tif_dir.td_customValues[m].info->set_field_type);

            if (tv_size == 8) {

              if (!TIFFWriteDirectoryTagSrationalDoubleArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

                goto bad;

            } else {

              /*-- default should be tv_size == 4 */

              if (!TIFFWriteDirectoryTagSrationalArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

                goto bad;

              /*-- ToDo: After Testing, this should be removed and tv_size==4 should be set as default. */

              if (tv_size != 4) {

                TIFFErrorExt(0,"TIFFLib: _TIFFWriteDirectorySec()", "Rational2Double: .set_field_type in not 4 but %d", tv_size); 

              }

            }

          }

          break;

        case TIFF_FLOAT:

          if (!TIFFWriteDirectoryTagFloatArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_DOUBLE:

          if (!TIFFWriteDirectoryTagDoubleArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_IFD:

          if (!TIFFWriteDirectoryTagIfdArray(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        case TIFF_IFD8:

          if (!TIFFWriteDirectoryTagIfdIfd8Array(tif,&ndir,dir,tag,count,tif->tif_dir.td_customValues[m].value))

            goto bad;

          break;

        default:

          assert(0);   /* we should never get here */

          break;

      }

    }

    if (dir!=NULL)

      break;

    dir=_TIFFmalloc(ndir*sizeof(TIFFDirEntry));

    if (dir==NULL)

    {

      TIFFErrorExt(tif->tif_clientdata,module,"Out of memory");

      goto bad;

    }

    if (isimage)

    {

      if ((tif->tif_diroff==0)&&(!TIFFLinkDirectory(tif)))

        goto bad;

    }

    else

      tif->tif_diroff=(TIFFSeekFile(tif,0,SEEK_END)+1)&(~((toff_t)1));

    if (pdiroff!=NULL)

      *pdiroff=tif->tif_diroff;

    if (!(tif->tif_flags&TIFF_BIGTIFF))

      dirsize=2+ndir*12+4;

    else

      dirsize=8+ndir*20+8;

    tif->tif_dataoff=tif->tif_diroff+dirsize;

    if (!(tif->tif_flags&TIFF_BIGTIFF))

      tif->tif_dataoff=(uint32_t)tif->tif_dataoff;

    if ((tif->tif_dataoff<tif->tif_diroff)||(tif->tif_dataoff<(uint64_t)dirsize))

    {

      TIFFErrorExt(tif->tif_clientdata,module,"Maximum TIFF file size exceeded");

      goto bad;

    }

    if (tif->tif_dataoff&1)

      tif->tif_dataoff++;

    if (isimage)

      tif->tif_curdir++;

  }

  if (isimage)

  {

    if (TIFFFieldSet(tif,FIELD_SUBIFD)&&(tif->tif_subifdoff==0))

    {

      uint32_t na;

      TIFFDirEntry* nb;

      for (na=0, nb=dir; ; na++, nb++)

      {

        if( na == ndir )

                                {

                                    TIFFErrorExt(tif->tif_clientdata,module,

                                                 "Cannot find SubIFD tag");

                                    goto bad;

                                }

        if (nb->tdir_tag==TIFFTAG_SUBIFD)

          break;

      }

      if (!(tif->tif_flags&TIFF_BIGTIFF))

        tif->tif_subifdoff=tif->tif_diroff+2+na*12+8;

      else

        tif->tif_subifdoff=tif->tif_diroff+8+na*20+12;

    }

  }