home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / hensa / graphics / libtiff_1 / c / tif_dir < prev    next >
Text File  |  1995-10-12  |  27KB  |  982 lines
  1. /* $Header: /usr/people/sam/tiff/libtiff/RCS/tif_dir.c,v 1.151 1995/07/19 00:39:31 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 Tag Get & Set Routines.
  31.  * (and also some miscellaneous stuff)
  32.  */
  33. #include "tiffiop.h"
  34.  
  35. /*
  36.  * These are used in the backwards compatibility code...
  37.  */
  38. #define DATATYPE_VOID        0       /* !untyped data */
  39. #define DATATYPE_INT        1       /* !signed integer data */
  40. #define DATATYPE_UINT        2       /* !unsigned integer data */
  41. #define DATATYPE_IEEEFP        3       /* !IEEE floating point data */
  42.  
  43. void
  44. _TIFFsetByteArray(void** vpp, void* vp, long n)
  45. {
  46.     if (*vpp)
  47.         _TIFFfree(*vpp), *vpp = 0;
  48.     if (vp && (*vpp = (void*) _TIFFmalloc(n)))
  49.         _TIFFmemcpy(*vpp, vp, n);
  50. }
  51. void _TIFFsetString(char** cpp, char* cp)
  52.     { _TIFFsetByteArray((void**) cpp, (void*) cp, (long) (strlen(cp)+1)); }
  53. void _TIFFsetShortArray(uint16** wpp, uint16* wp, long n)
  54.     { _TIFFsetByteArray((void**) wpp, (void*) wp, n*sizeof (uint16)); }
  55. void _TIFFsetLongArray(uint32** lpp, uint32* lp, long n)
  56.     { _TIFFsetByteArray((void**) lpp, (void*) lp, n*sizeof (uint32)); }
  57. void _TIFFsetFloatArray(float** fpp, float* fp, long n)
  58.     { _TIFFsetByteArray((void**) fpp, (void*) fp, n*sizeof (float)); }
  59. void _TIFFsetDoubleArray(double** dpp, double* dp, long n)
  60.     { _TIFFsetByteArray((void**) dpp, (void*) dp, n*sizeof (double)); }
  61.  
  62. /*
  63.  * Install extra samples information.
  64.  */
  65. static int
  66. setExtraSamples(TIFFDirectory* td, va_list ap, int* v)
  67. {
  68.     uint16* va;
  69.     int i;
  70.  
  71.     *v = va_arg(ap, int);
  72.     if ((uint16) *v > td->td_samplesperpixel)
  73.         return (0);
  74.     va = va_arg(ap, uint16*);
  75.     if (*v > 0 && va == NULL)        /* typically missing param */
  76.         return (0);
  77.     for (i = 0; i < *v; i++)
  78.         if (va[i] > EXTRASAMPLE_UNASSALPHA)
  79.             return (0);
  80.     td->td_extrasamples = (uint16) *v;
  81.     _TIFFsetShortArray(&td->td_sampleinfo, va, td->td_extrasamples);
  82.     return (1);
  83. }
  84.  
  85. static int
  86. _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
  87. {
  88.     TIFFDirectory* td = &tif->tif_dir;
  89.     int status = 1;
  90.     uint32 v32;
  91.     int i, v;
  92.  
  93.     switch (tag) {
  94.     case TIFFTAG_SUBFILETYPE:
  95.         td->td_subfiletype = va_arg(ap, uint32);
  96.         break;
  97.     case TIFFTAG_IMAGEWIDTH:
  98.         td->td_imagewidth = va_arg(ap, uint32);
  99.         break;
  100.     case TIFFTAG_IMAGELENGTH:
  101.         td->td_imagelength = va_arg(ap, uint32);
  102.         break;
  103.     case TIFFTAG_BITSPERSAMPLE:
  104.         td->td_bitspersample = (uint16) va_arg(ap, int);
  105.         /*
  106.          * If the data require post-decoding processing
  107.          * to byte-swap samples, set it up here.  Note
  108.          * that since tags are required to be ordered,
  109.          * compression code can override this behaviour
  110.          * in the setup method if it wants to roll the
  111.          * post decoding work in with its normal work.
  112.          */
  113.         if (tif->tif_flags & TIFF_SWAB) {
  114.             if (td->td_bitspersample == 16)
  115.                 tif->tif_postdecode = _TIFFSwab16BitData;
  116.             else if (td->td_bitspersample == 32)
  117.                 tif->tif_postdecode = _TIFFSwab32BitData;
  118.             else if (td->td_bitspersample == 64)
  119.                 tif->tif_postdecode = _TIFFSwab64BitData;
  120.         }
  121.         break;
  122.     case TIFFTAG_COMPRESSION:
  123.         v = va_arg(ap, int) & 0xffff;
  124.         /*
  125.          * If we're changing the compression scheme,
  126.          * the notify the previous module so that it
  127.          * can cleanup any state it's setup.
  128.          */
  129.         if (TIFFFieldSet(tif, FIELD_COMPRESSION)) {
  130.             if (td->td_compression == v)
  131.                 break;
  132.             (*tif->tif_cleanup)(tif);
  133.             tif->tif_flags &= ~TIFF_CODERSETUP;
  134.         }
  135.         /*
  136.          * Setup new compression routine state.
  137.          */
  138.         if (status = TIFFSetCompressionScheme(tif, v))
  139.             td->td_compression = v;
  140.         break;
  141.     case TIFFTAG_PHOTOMETRIC:
  142.         td->td_photometric = (uint16) va_arg(ap, int);
  143.         break;
  144.     case TIFFTAG_THRESHHOLDING:
  145.         td->td_threshholding = (uint16) va_arg(ap, int);
  146.         break;
  147.     case TIFFTAG_FILLORDER:
  148.         v = va_arg(ap, int);
  149.         if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB)
  150.             goto badvalue;
  151.         td->td_fillorder = (uint16) v;
  152.         break;
  153.     case TIFFTAG_DOCUMENTNAME:
  154.         _TIFFsetString(&td->td_documentname, va_arg(ap, char*));
  155.         break;
  156.     case TIFFTAG_ARTIST:
  157.         _TIFFsetString(&td->td_artist, va_arg(ap, char*));
  158.         break;
  159.     case TIFFTAG_DATETIME:
  160.         _TIFFsetString(&td->td_datetime, va_arg(ap, char*));
  161.         break;
  162.     case TIFFTAG_HOSTCOMPUTER:
  163.         _TIFFsetString(&td->td_hostcomputer, va_arg(ap, char*));
  164.         break;
  165.     case TIFFTAG_IMAGEDESCRIPTION:
  166.         _TIFFsetString(&td->td_imagedescription, va_arg(ap, char*));
  167.         break;
  168.     case TIFFTAG_MAKE:
  169.         _TIFFsetString(&td->td_make, va_arg(ap, char*));
  170.         break;
  171.     case TIFFTAG_MODEL:
  172.         _TIFFsetString(&td->td_model, va_arg(ap, char*));
  173.         break;
  174.     case TIFFTAG_SOFTWARE:
  175.         _TIFFsetString(&td->td_software, va_arg(ap, char*));
  176.         break;
  177.     case TIFFTAG_ORIENTATION:
  178.         v = va_arg(ap, int);
  179.         if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v) {
  180.             TIFFWarning(tif->tif_name,
  181.                 "Bad value %ld for \"%s\" tag ignored",
  182.                 v, _TIFFFieldWithTag(tif, tag)->field_name);
  183.         } else
  184.             td->td_orientation = (uint16) v;
  185.         break;
  186.     case TIFFTAG_SAMPLESPERPIXEL:
  187.         /* XXX should cross check -- e.g. if pallette, then 1 */
  188.         v = va_arg(ap, int);
  189.         if (v == 0)
  190.             goto badvalue;
  191.         td->td_samplesperpixel = (uint16) v;
  192.         break;
  193.     case TIFFTAG_ROWSPERSTRIP:
  194.         v32 = va_arg(ap, uint32);
  195.         if (v32 == 0)
  196.             goto badvalue32;
  197.         td->td_rowsperstrip = v32;
  198.         if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
  199.             td->td_tilelength = v32;
  200.             td->td_tilewidth = td->td_imagewidth;
  201.         }
  202.         break;
  203.     case TIFFTAG_MINSAMPLEVALUE:
  204.         td->td_minsamplevalue = (uint16) va_arg(ap, int);
  205.         break;
  206.     case TIFFTAG_MAXSAMPLEVALUE:
  207.         td->td_maxsamplevalue = (uint16) va_arg(ap, int);
  208.         break;
  209.     case TIFFTAG_SMINSAMPLEVALUE:
  210.         td->td_sminsamplevalue = (double) va_arg(ap, dblparam_t);
  211.         break;
  212.     case TIFFTAG_SMAXSAMPLEVALUE:
  213.         td->td_smaxsamplevalue = (double) va_arg(ap, dblparam_t);
  214.         break;
  215.     case TIFFTAG_XRESOLUTION:
  216.         td->td_xresolution = (float) va_arg(ap, dblparam_t);
  217.         break;
  218.     case TIFFTAG_YRESOLUTION:
  219.         td->td_yresolution = (float) va_arg(ap, dblparam_t);
  220.         break;
  221.     case TIFFTAG_PLANARCONFIG:
  222.         v = va_arg(ap, int);
  223.         if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE)
  224.             goto badvalue;
  225.         td->td_planarconfig = (uint16) v;
  226.         break;
  227.     case TIFFTAG_PAGENAME:
  228.         _TIFFsetString(&td->td_pagename, va_arg(ap, char*));
  229.         break;
  230.     case TIFFTAG_XPOSITION:
  231.         td->td_xposition = (float) va_arg(ap, dblparam_t);
  232.         break;
  233.     case TIFFTAG_YPOSITION:
  234.         td->td_yposition = (float) va_arg(ap, dblparam_t);
  235.         break;
  236.     case TIFFTAG_RESOLUTIONUNIT:
  237.         v = va_arg(ap, int);
  238.         if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v)
  239.             goto badvalue;
  240.         td->td_resolutionunit = (uint16) v;
  241.         break;
  242.     case TIFFTAG_PAGENUMBER:
  243.         td->td_pagenumber[0] = (uint16) va_arg(ap, int);
  244.         td->td_pagenumber[1] = (uint16) va_arg(ap, int);
  245.         break;
  246.     case TIFFTAG_HALFTONEHINTS:
  247.         td->td_halftonehints[0] = (uint16) va_arg(ap, int);
  248.         td->td_halftonehints[1] = (uint16) va_arg(ap, int);
  249.         break;
  250.     case TIFFTAG_COLORMAP:
  251.         v32 = (uint32)(1L<<td->td_bitspersample);
  252.         _TIFFsetShortArray(&td->td_colormap[0], va_arg(ap, uint16*), v32);
  253.         _TIFFsetShortArray(&td->td_colormap[1], va_arg(ap, uint16*), v32);
  254.         _TIFFsetShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v32);
  255.         break;
  256.     case TIFFTAG_EXTRASAMPLES:
  257.         if (!setExtraSamples(td, ap, &v))
  258.             goto badvalue;
  259.         break;
  260.     case TIFFTAG_MATTEING:
  261.         td->td_extrasamples = (uint16) (va_arg(ap, int) != 0);
  262.         if (td->td_extrasamples) {
  263.             uint16 sv = EXTRASAMPLE_ASSOCALPHA;
  264.             _TIFFsetShortArray(&td->td_sampleinfo, &sv, 1);
  265.         }
  266.         break;
  267.     case TIFFTAG_TILEWIDTH:
  268.         v32 = va_arg(ap, uint32);
  269.         if (v32 % 16) {
  270.             if (tif->tif_mode != O_RDONLY)
  271.                 goto badvalue32;
  272.             TIFFWarning(tif->tif_name,
  273.                 "Nonstandard tile width %d, convert file", v32);
  274.         }
  275.         td->td_tilewidth = v32;
  276.         tif->tif_flags |= TIFF_ISTILED;
  277.         break;
  278.     case TIFFTAG_TILELENGTH:
  279.         v32 = va_arg(ap, uint32);
  280.         if (v32 % 16) {
  281.             if (tif->tif_mode != O_RDONLY)
  282.                 goto badvalue32;
  283.             TIFFWarning(tif->tif_name,
  284.                 "Nonstandard tile length %d, convert file", v32);
  285.         }
  286.         td->td_tilelength = v32;
  287.         tif->tif_flags |= TIFF_ISTILED;
  288.         break;
  289.     case TIFFTAG_TILEDEPTH:
  290.         v32 = va_arg(ap, uint32);
  291.         if (v32 == 0)
  292.             goto badvalue32;
  293.         td->td_tiledepth = v32;
  294.         break;
  295.     case TIFFTAG_DATATYPE:
  296.         v = va_arg(ap, int);
  297.         switch (v) {
  298.         case DATATYPE_VOID:    v = SAMPLEFORMAT_VOID;    break;
  299.         case DATATYPE_INT:    v = SAMPLEFORMAT_INT;    break;
  300.         case DATATYPE_UINT:    v = SAMPLEFORMAT_UINT;    break;
  301.         case DATATYPE_IEEEFP:    v = SAMPLEFORMAT_IEEEFP;break;
  302.         default:        goto badvalue;
  303.         }
  304.         td->td_sampleformat = (uint16) v;
  305.         break;
  306.     case TIFFTAG_SAMPLEFORMAT:
  307.         v = va_arg(ap, int);
  308.         if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_VOID < v)
  309.             goto badvalue;
  310.         td->td_sampleformat = (uint16) v;
  311.         break;
  312.     case TIFFTAG_IMAGEDEPTH:
  313.         td->td_imagedepth = va_arg(ap, uint32);
  314.         break;
  315. #if SUBIFD_SUPPORT
  316.     case TIFFTAG_SUBIFD:
  317.         if ((tif->tif_flags & TIFF_INSUBIFD) == 0) {
  318.             td->td_nsubifd = (uint16) va_arg(ap, int);
  319.             _TIFFsetLongArray(&td->td_subifd, va_arg(ap, uint32*),
  320.                 (long) td->td_nsubifd);
  321.         } else {
  322.             TIFFError(tif->tif_name, "Sorry, cannot nest SubIFDs");
  323.             status = 0;
  324.         }
  325.         break;
  326. #endif
  327. #ifdef YCBCR_SUPPORT
  328.     case TIFFTAG_YCBCRCOEFFICIENTS:
  329.         _TIFFsetFloatArray(&td->td_ycbcrcoeffs, va_arg(ap, float*), 3);
  330.         break;
  331.     case TIFFTAG_YCBCRPOSITIONING:
  332.         td->td_ycbcrpositioning = (uint16) va_arg(ap, int);
  333.         break;
  334.     case TIFFTAG_YCBCRSUBSAMPLING:
  335.         td->td_ycbcrsubsampling[0] = (uint16) va_arg(ap, int);
  336.         td->td_ycbcrsubsampling[1] = (uint16) va_arg(ap, int);
  337.         break;
  338. #endif
  339. #ifdef COLORIMETRY_SUPPORT
  340.     case TIFFTAG_WHITEPOINT:
  341.         _TIFFsetFloatArray(&td->td_whitepoint, va_arg(ap, float*), 2);
  342.         break;
  343.     case TIFFTAG_PRIMARYCHROMATICITIES:
  344.         _TIFFsetFloatArray(&td->td_primarychromas, va_arg(ap, float*), 6);
  345.         break;
  346.     case TIFFTAG_TRANSFERFUNCTION:
  347.         v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1;
  348.         for (i = 0; i < v; i++)
  349.             _TIFFsetShortArray(&td->td_transferfunction[i],
  350.                 va_arg(ap, uint16*), 1L<<td->td_bitspersample);
  351.         break;
  352.     case TIFFTAG_REFERENCEBLACKWHITE:
  353.         /* XXX should check for null range */
  354.         _TIFFsetFloatArray(&td->td_refblackwhite, va_arg(ap, float*), 6);
  355.         break;
  356. #endif
  357. #ifdef CMYK_SUPPORT
  358.     case TIFFTAG_INKSET:
  359.         td->td_inkset = (uint16) va_arg(ap, int);
  360.         break;
  361.     case TIFFTAG_DOTRANGE:
  362.         /* XXX should check for null range */
  363.         td->td_dotrange[0] = (uint16) va_arg(ap, int);
  364.         td->td_dotrange[1] = (uint16) va_arg(ap, int);
  365.         break;
  366.     case TIFFTAG_INKNAMES:
  367.         _TIFFsetString(&td->td_inknames, va_arg(ap, char*));
  368.         break;
  369.     case TIFFTAG_TARGETPRINTER:
  370.         _TIFFsetString(&td->td_targetprinter, va_arg(ap, char*));
  371.         break;
  372. #endif
  373.     default:
  374.         TIFFError(tif->tif_name,
  375.             "Internal error, tag value botch, tag \"%s\"",
  376.             _TIFFFieldWithTag(tif, tag)->field_name);
  377.         status = 0;
  378.         break;
  379.     }
  380.     if (status) {
  381.         TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit);
  382.         tif->tif_flags |= TIFF_DIRTYDIRECT;
  383.     }
  384.     va_end(ap);
  385.     return (status);
  386. badvalue:
  387.     TIFFError(tif->tif_name, "%d: Bad value for \"%s\"", v,
  388.         _TIFFFieldWithTag(tif, tag)->field_name);
  389.     va_end(ap);
  390.     return (0);
  391. badvalue32:
  392.     TIFFError(tif->tif_name, "%ld: Bad value for \"%s\"", v32,
  393.         _TIFFFieldWithTag(tif, tag)->field_name);
  394.     va_end(ap);
  395.     return (0);
  396. }
  397.  
  398. /*
  399.  * Return 1/0 according to whether or not
  400.  * it is permissible to set the tag's value.
  401.  * Note that we allow ImageLength to be changed
  402.  * so that we can append and extend to images.
  403.  * Any other tag may not be altered once writing
  404.  * has commenced, unless its value has no effect
  405.  * on the format of the data that is written.
  406.  */
  407. static int
  408. OkToChangeTag(TIFF* tif, ttag_t tag)
  409. {
  410.     if (tag != TIFFTAG_IMAGELENGTH &&
  411.         (tif->tif_flags & TIFF_BEENWRITING)) {
  412.         const TIFFFieldInfo *fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
  413.         /*
  414.          * Consult info table to see if tag can be changed
  415.          * after we've started writing.  We only allow changes
  416.          * to those tags that don't/shouldn't affect the
  417.          * compression and/or format of the data.
  418.          */
  419.         if (fip && !fip->field_oktochange) {
  420.             TIFFError("TIFFSetField",
  421.                 "%s: Cannot modify tag \"%s\" while writing",
  422.                 tif->tif_name, fip->field_name);
  423.             return (0);
  424.         }
  425.     }
  426.     return (1);
  427. }
  428.  
  429. /*
  430.  * Record the value of a field in the
  431.  * internal directory structure.  The
  432.  * field will be written to the file
  433.  * when/if the directory structure is
  434.  * updated.
  435.  */
  436. int
  437. TIFFSetField(TIFF* tif, ttag_t tag, ...)
  438. {
  439.     va_list ap;
  440.     int status;
  441.  
  442.     va_start(ap, tag);
  443.     status = TIFFVSetField(tif, tag, ap);
  444.     va_end(ap);
  445.     return (status);
  446. }
  447.  
  448. /*
  449.  * Like TIFFSetField, but taking a varargs
  450.  * parameter list.  This routine is useful
  451.  * for building higher-level interfaces on
  452.  * top of the library.
  453.  */
  454. int
  455. TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
  456. {
  457.     return OkToChangeTag(tif, tag) ?
  458.         (*tif->tif_vsetfield)(tif, tag, ap) : 0;
  459. }
  460.  
  461. static int
  462. _TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
  463. {
  464.     TIFFDirectory* td = &tif->tif_dir;
  465.  
  466.     switch (tag) {
  467.     case TIFFTAG_SUBFILETYPE:
  468.         *va_arg(ap, uint32*) = td->td_subfiletype;
  469.         break;
  470.     case TIFFTAG_IMAGEWIDTH:
  471.         *va_arg(ap, uint32*) = td->td_imagewidth;
  472.         break;
  473.     case TIFFTAG_IMAGELENGTH:
  474.         *va_arg(ap, uint32*) = td->td_imagelength;
  475.         break;
  476.     case TIFFTAG_BITSPERSAMPLE:
  477.         *va_arg(ap, uint16*) = td->td_bitspersample;
  478.         break;
  479.     case TIFFTAG_COMPRESSION:
  480.         *va_arg(ap, uint16*) = td->td_compression;
  481.         break;
  482.     case TIFFTAG_PHOTOMETRIC:
  483.         *va_arg(ap, uint16*) = td->td_photometric;
  484.         break;
  485.     case TIFFTAG_THRESHHOLDING:
  486.         *va_arg(ap, uint16*) = td->td_threshholding;
  487.         break;
  488.     case TIFFTAG_FILLORDER:
  489.         *va_arg(ap, uint16*) = td->td_fillorder;
  490.         break;
  491.     case TIFFTAG_DOCUMENTNAME:
  492.         *va_arg(ap, char**) = td->td_documentname;
  493.         break;
  494.     case TIFFTAG_ARTIST:
  495.         *va_arg(ap, char**) = td->td_artist;
  496.         break;
  497.     case TIFFTAG_DATETIME:
  498.         *va_arg(ap, char**) = td->td_datetime;
  499.         break;
  500.     case TIFFTAG_HOSTCOMPUTER:
  501.         *va_arg(ap, char**) = td->td_hostcomputer;
  502.         break;
  503.     case TIFFTAG_IMAGEDESCRIPTION:
  504.         *va_arg(ap, char**) = td->td_imagedescription;
  505.         break;
  506.     case TIFFTAG_MAKE:
  507.         *va_arg(ap, char**) = td->td_make;
  508.         break;
  509.     case TIFFTAG_MODEL:
  510.         *va_arg(ap, char**) = td->td_model;
  511.         break;
  512.     case TIFFTAG_SOFTWARE:
  513.         *va_arg(ap, char**) = td->td_software;
  514.         break;
  515.     case TIFFTAG_ORIENTATION:
  516.         *va_arg(ap, uint16*) = td->td_orientation;
  517.         break;
  518.     case TIFFTAG_SAMPLESPERPIXEL:
  519.         *va_arg(ap, uint16*) = td->td_samplesperpixel;
  520.         break;
  521.     case TIFFTAG_ROWSPERSTRIP:
  522.         *va_arg(ap, uint32*) = td->td_rowsperstrip;
  523.         break;
  524.     case TIFFTAG_MINSAMPLEVALUE:
  525.         *va_arg(ap, uint16*) = td->td_minsamplevalue;
  526.         break;
  527.     case TIFFTAG_MAXSAMPLEVALUE:
  528.         *va_arg(ap, uint16*) = td->td_maxsamplevalue;
  529.         break;
  530.     case TIFFTAG_SMINSAMPLEVALUE:
  531.         *va_arg(ap, double*) = td->td_sminsamplevalue;
  532.         break;
  533.     case TIFFTAG_SMAXSAMPLEVALUE:
  534.         *va_arg(ap, double*) = td->td_smaxsamplevalue;
  535.         break;
  536.     case TIFFTAG_XRESOLUTION:
  537.         *va_arg(ap, float*) = td->td_xresolution;
  538.         break;
  539.     case TIFFTAG_YRESOLUTION:
  540.         *va_arg(ap, float*) = td->td_yresolution;
  541.         break;
  542.     case TIFFTAG_PLANARCONFIG:
  543.         *va_arg(ap, uint16*) = td->td_planarconfig;
  544.         break;
  545.     case TIFFTAG_XPOSITION:
  546.         *va_arg(ap, float*) = td->td_xposition;
  547.         break;
  548.     case TIFFTAG_YPOSITION:
  549.         *va_arg(ap, float*) = td->td_yposition;
  550.         break;
  551.     case TIFFTAG_PAGENAME:
  552.         *va_arg(ap, char**) = td->td_pagename;
  553.         break;
  554.     case TIFFTAG_RESOLUTIONUNIT:
  555.         *va_arg(ap, uint16*) = td->td_resolutionunit;
  556.         break;
  557.     case TIFFTAG_PAGENUMBER:
  558.         *va_arg(ap, uint16*) = td->td_pagenumber[0];
  559.         *va_arg(ap, uint16*) = td->td_pagenumber[1];
  560.         break;
  561.     case TIFFTAG_HALFTONEHINTS:
  562.         *va_arg(ap, uint16*) = td->td_halftonehints[0];
  563.         *va_arg(ap, uint16*) = td->td_halftonehints[1];
  564.         break;
  565.     case TIFFTAG_COLORMAP:
  566.         *va_arg(ap, uint16**) = td->td_colormap[0];
  567.         *va_arg(ap, uint16**) = td->td_colormap[1];
  568.         *va_arg(ap, uint16**) = td->td_colormap[2];
  569.         break;
  570.     case TIFFTAG_STRIPOFFSETS:
  571.     case TIFFTAG_TILEOFFSETS:
  572.         *va_arg(ap, uint32**) = td->td_stripoffset;
  573.         break;
  574.     case TIFFTAG_STRIPBYTECOUNTS:
  575.     case TIFFTAG_TILEBYTECOUNTS:
  576.         *va_arg(ap, uint32**) = td->td_stripbytecount;
  577.         break;
  578.     case TIFFTAG_MATTEING:
  579.         *va_arg(ap, uint16*) =
  580.             (td->td_extrasamples == 1 &&
  581.              td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
  582.         break;
  583.     case TIFFTAG_EXTRASAMPLES:
  584.         *va_arg(ap, uint16*) = td->td_extrasamples;
  585.         *va_arg(ap, uint16**) = td->td_sampleinfo;
  586.         break;
  587.     case TIFFTAG_TILEWIDTH:
  588.         *va_arg(ap, uint32*) = td->td_tilewidth;
  589.         break;
  590.     case TIFFTAG_TILELENGTH:
  591.         *va_arg(ap, uint32*) = td->td_tilelength;
  592.         break;
  593.     case TIFFTAG_TILEDEPTH:
  594.         *va_arg(ap, uint32*) = td->td_tiledepth;
  595.         break;
  596.     case TIFFTAG_DATATYPE:
  597.         switch (td->td_sampleformat) {
  598.         case SAMPLEFORMAT_UINT:
  599.             *va_arg(ap, uint16*) = DATATYPE_UINT;
  600.             break;
  601.         case SAMPLEFORMAT_INT:
  602.             *va_arg(ap, uint16*) = DATATYPE_INT;
  603.             break;
  604.         case SAMPLEFORMAT_IEEEFP:
  605.             *va_arg(ap, uint16*) = DATATYPE_IEEEFP;
  606.             break;
  607.         case SAMPLEFORMAT_VOID:
  608.             *va_arg(ap, uint16*) = DATATYPE_VOID;
  609.             break;
  610.         }
  611.         break;
  612.     case TIFFTAG_SAMPLEFORMAT:
  613.         *va_arg(ap, uint16*) = td->td_sampleformat;
  614.         break;
  615.     case TIFFTAG_IMAGEDEPTH:
  616.         *va_arg(ap, uint32*) = td->td_imagedepth;
  617.         break;
  618. #if SUBIFD_SUPPORT
  619.     case TIFFTAG_SUBIFD:
  620.         *va_arg(ap, uint16*) = td->td_nsubifd;
  621.         *va_arg(ap, uint32**) = td->td_subifd;
  622.         break;
  623. #endif
  624. #ifdef YCBCR_SUPPORT
  625.     case TIFFTAG_YCBCRCOEFFICIENTS:
  626.         *va_arg(ap, float**) = td->td_ycbcrcoeffs;
  627.         break;
  628.     case TIFFTAG_YCBCRPOSITIONING:
  629.         *va_arg(ap, uint16*) = td->td_ycbcrpositioning;
  630.         break;
  631.     case TIFFTAG_YCBCRSUBSAMPLING:
  632.         *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[0];
  633.         *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[1];
  634.         break;
  635. #endif
  636. #ifdef COLORIMETRY_SUPPORT
  637.     case TIFFTAG_WHITEPOINT:
  638.         *va_arg(ap, float**) = td->td_whitepoint;
  639.         break;
  640.     case TIFFTAG_PRIMARYCHROMATICITIES:
  641.         *va_arg(ap, float**) = td->td_primarychromas;
  642.         break;
  643.     case TIFFTAG_TRANSFERFUNCTION:
  644.         *va_arg(ap, uint16**) = td->td_transferfunction[0];
  645.         if (td->td_samplesperpixel - td->td_extrasamples > 1) {
  646.             *va_arg(ap, uint16**) = td->td_transferfunction[1];
  647.             *va_arg(ap, uint16**) = td->td_transferfunction[2];
  648.         }
  649.         break;
  650.     case TIFFTAG_REFERENCEBLACKWHITE:
  651.         *va_arg(ap, float**) = td->td_refblackwhite;
  652.         break;
  653. #endif
  654. #ifdef CMYK_SUPPORT
  655.     case TIFFTAG_INKSET:
  656.         *va_arg(ap, uint16*) = td->td_inkset;
  657.         break;
  658.     case TIFFTAG_DOTRANGE:
  659.         *va_arg(ap, uint16*) = td->td_dotrange[0];
  660.         *va_arg(ap, uint16*) = td->td_dotrange[1];
  661.         break;
  662.     case TIFFTAG_INKNAMES:
  663.         *va_arg(ap, char**) = td->td_inknames;
  664.         break;
  665.     case TIFFTAG_TARGETPRINTER:
  666.         *va_arg(ap, char**) = td->td_targetprinter;
  667.         break;
  668. #endif
  669.     default:
  670.         TIFFError("_TIFFVGetField",
  671.             "Internal error, no value returned for tag \"%s\"",
  672.             _TIFFFieldWithTag(tif, tag)->field_name);
  673.         break;
  674.     }
  675.     return (1);
  676. }
  677.  
  678. /*
  679.  * Return the value of a field in the
  680.  * internal directory structure.
  681.  */
  682. int
  683. TIFFGetField(TIFF* tif, ttag_t tag, ...)
  684. {
  685.     int status;
  686.     va_list ap;
  687.  
  688.     va_start(ap, tag);
  689.     status = TIFFVGetField(tif, tag, ap);
  690.     va_end(ap);
  691.     return (status);
  692. }
  693.  
  694. /*
  695.  * Like TIFFGetField, but taking a varargs
  696.  * parameter list.  This routine is useful
  697.  * for building higher-level interfaces on
  698.  * top of the library.
  699.  */
  700. int
  701. TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
  702. {
  703.     const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
  704.     return (fip && TIFFFieldSet(tif, fip->field_bit) ?
  705.         (*tif->tif_vgetfield)(tif, tag, ap) : 0);
  706. }
  707.  
  708. #define    CleanupField(member) {        \
  709.     if (td->member) {            \
  710.     _TIFFfree(td->member);        \
  711.     td->member = 0;            \
  712.     }                    \
  713. }
  714.  
  715. /*
  716.  * Release storage associated with a directory.
  717.  */
  718. void
  719. TIFFFreeDirectory(TIFF* tif)
  720. {
  721.     register TIFFDirectory *td = &tif->tif_dir;
  722.  
  723.     CleanupField(td_colormap[0]);
  724.     CleanupField(td_colormap[1]);
  725.     CleanupField(td_colormap[2]);
  726.     CleanupField(td_documentname);
  727.     CleanupField(td_artist);
  728.     CleanupField(td_datetime);
  729.     CleanupField(td_hostcomputer);
  730.     CleanupField(td_imagedescription);
  731.     CleanupField(td_make);
  732.     CleanupField(td_model);
  733.     CleanupField(td_software);
  734.     CleanupField(td_pagename);
  735.     CleanupField(td_sampleinfo);
  736. #if SUBIFD_SUPPORT
  737.     CleanupField(td_subifd);
  738. #endif
  739. #ifdef YCBCR_SUPPORT
  740.     CleanupField(td_ycbcrcoeffs);
  741. #endif
  742. #ifdef CMYK_SUPPORT
  743.     CleanupField(td_inknames);
  744.     CleanupField(td_targetprinter);
  745. #endif
  746. #ifdef COLORIMETRY_SUPPORT
  747.     CleanupField(td_whitepoint);
  748.     CleanupField(td_primarychromas);
  749.     CleanupField(td_refblackwhite);
  750.     CleanupField(td_transferfunction[0]);
  751.     CleanupField(td_transferfunction[1]);
  752.     CleanupField(td_transferfunction[2]);
  753. #endif
  754.     CleanupField(td_stripoffset);
  755.     CleanupField(td_stripbytecount);
  756. }
  757. #undef CleanupField
  758.  
  759. /*
  760.  * Client Tag extension support (from Niles Ritter).
  761.  */
  762. static TIFFExtendProc _TIFFextender = (TIFFExtendProc) NULL;
  763.  
  764. TIFFExtendProc
  765. TIFFSetTagExtender(TIFFExtendProc extender)
  766. {
  767.     TIFFExtendProc prev = _TIFFextender;
  768.     _TIFFextender = extender;
  769.     return (prev);
  770. }
  771.  
  772. /*
  773.  * Setup a default directory structure.
  774.  */
  775. int
  776. TIFFDefaultDirectory(TIFF* tif)
  777. {
  778.     register TIFFDirectory* td = &tif->tif_dir;
  779.  
  780.     _TIFFSetupFieldInfo(tif);
  781.     _TIFFmemset(td, 0, sizeof (*td));
  782.     td->td_fillorder = FILLORDER_MSB2LSB;
  783.     td->td_bitspersample = 1;
  784.     td->td_threshholding = THRESHHOLD_BILEVEL;
  785.     td->td_orientation = ORIENTATION_TOPLEFT;
  786.     td->td_samplesperpixel = 1;
  787.     td->td_rowsperstrip = (uint32) -1;
  788.     td->td_tilewidth = (uint32) -1;
  789.     td->td_tilelength = (uint32) -1;
  790.     td->td_tiledepth = 1;
  791.     td->td_resolutionunit = RESUNIT_INCH;
  792.     td->td_sampleformat = SAMPLEFORMAT_VOID;
  793.     td->td_imagedepth = 1;
  794. #ifdef YCBCR_SUPPORT
  795.     td->td_ycbcrsubsampling[0] = 2;
  796.     td->td_ycbcrsubsampling[1] = 2;
  797.     td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
  798. #endif
  799. #ifdef CMYK_SUPPORT
  800.     td->td_inkset = INKSET_CMYK;
  801. #endif
  802.     tif->tif_postdecode = _TIFFNoPostDecode;
  803.     tif->tif_vsetfield = _TIFFVSetField;
  804.     tif->tif_vgetfield = _TIFFVGetField;
  805.     tif->tif_printdir = NULL;
  806.     /*
  807.      *  Give client code a chance to install their own
  808.      *  tag extensions & methods, prior to compression overloads.
  809.      */
  810.     if (_TIFFextender)
  811.         (*_TIFFextender)(tif);
  812.     (void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
  813.     /*
  814.      * NB: The directory is marked dirty as a result of setting
  815.      * up the default compression scheme.  However, this really
  816.      * isn't correct -- we want TIFF_DIRTYDIRECT to be set only
  817.      * if the user does something.  We could just do the setup
  818.      * by hand, but it seems better to use the normal mechanism
  819.      * (i.e. TIFFSetField).
  820.      */
  821.     tif->tif_flags &= ~TIFF_DIRTYDIRECT;
  822.     return (1);
  823. }
  824.  
  825. static int
  826. TIFFAdvanceDirectory(TIFF* tif, uint32* nextdir, toff_t* off)
  827. {
  828.     static const char module[] = "TIFFAdvanceDirectory";
  829.     uint16 dircount;
  830.  
  831.     if (!SeekOK(tif, *nextdir) ||
  832.         !ReadOK(tif, &dircount, sizeof (uint16))) {
  833.         TIFFError(module, "%s: Error fetching directory count",
  834.             tif->tif_name);
  835.         return (0);
  836.     }
  837.     if (tif->tif_flags & TIFF_SWAB)
  838.         TIFFSwabShort(&dircount);
  839.     if (off != NULL)
  840.         *off = TIFFSeekFile(tif,
  841.             dircount*sizeof (TIFFDirEntry), SEEK_CUR);
  842.     else
  843.         (void) TIFFSeekFile(tif,
  844.             dircount*sizeof (TIFFDirEntry), SEEK_CUR);
  845.     if (!ReadOK(tif, nextdir, sizeof (uint32))) {
  846.         TIFFError(module, "%s: Error fetching directory link",
  847.             tif->tif_name);
  848.         return (0);
  849.     }
  850.     if (tif->tif_flags & TIFF_SWAB)
  851.         TIFFSwabLong(nextdir);
  852.     return (1);
  853. }
  854.  
  855. /*
  856.  * Set the n-th directory as the current directory.
  857.  * NB: Directories are numbered starting at 0.
  858.  */
  859. int
  860. TIFFSetDirectory(TIFF* tif, tdir_t dirn)
  861. {
  862.     uint32 nextdir;
  863.     tdir_t n;
  864.  
  865.     nextdir = tif->tif_header.tiff_diroff;
  866.     for (n = dirn; n > 0 && nextdir != 0; n--)
  867.         if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
  868.             return (0);
  869.     tif->tif_nextdiroff = nextdir;
  870.     /*
  871.      * Set curdir to the actual directory index.  The
  872.      * -1 is because TIFFReadDirectory will increment
  873.      * tif_curdir after successfully reading the directory.
  874.      */
  875.     tif->tif_curdir = (dirn - n) - 1;
  876.     return (TIFFReadDirectory(tif));
  877. }
  878.  
  879. /*
  880.  * Set the current directory to be the directory
  881.  * located at the specified file offset.  This interface
  882.  * is used mainly to access directories linked with
  883.  * the SubIFD tag (e.g. thumbnail images).
  884.  */
  885. int
  886. TIFFSetSubDirectory(TIFF* tif, uint32 diroff)
  887. {
  888.     tif->tif_nextdiroff = diroff;
  889.     return (TIFFReadDirectory(tif));
  890. }
  891.  
  892. /*
  893.  * Return file offset of the current directory.
  894.  */
  895. uint32
  896. TIFFCurrentDirOffset(TIFF* tif)
  897. {
  898.     return (tif->tif_diroff);
  899. }
  900.  
  901. /*
  902.  * Return an indication of whether or not we are
  903.  * at the last directory in the file.
  904.  */
  905. int
  906. TIFFLastDirectory(TIFF* tif)
  907. {
  908.     return (tif->tif_nextdiroff == 0);
  909. }
  910.  
  911. /*
  912.  * Unlink the specified directory from the directory chain.
  913.  */
  914. int
  915. TIFFUnlinkDirectory(TIFF* tif, tdir_t dirn)
  916. {
  917.     static const char module[] = "TIFFUnlinkDirectory";
  918.     uint32 nextdir;
  919.     toff_t off;
  920.     tdir_t n;
  921.  
  922.     if (tif->tif_mode == O_RDONLY) {
  923.         TIFFError(module, "Can not unlink directory in read-only file");
  924.         return (0);
  925.     }
  926.     /*
  927.      * Go to the directory before the one we want
  928.      * to unlink and nab the offset of the link
  929.      * field we'll need to patch.
  930.      */
  931.     nextdir = tif->tif_header.tiff_diroff;
  932.     off = sizeof (uint16) + sizeof (uint16);
  933.     for (n = dirn-1; n > 0; n--) {
  934.         if (nextdir == 0) {
  935.             TIFFError(module, "Directory %d does not exist", dirn);
  936.             return (0);
  937.         }
  938.         if (!TIFFAdvanceDirectory(tif, &nextdir, &off))
  939.             return (0);
  940.     }
  941.     /*
  942.      * Advance to the directory to be unlinked and fetch
  943.      * the offset of the directory that follows.
  944.      */
  945.     if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
  946.         return (0);
  947.     /*
  948.      * Go back and patch the link field of the preceding
  949.      * directory to point to the offset of the directory
  950.      * that follows.
  951.      */
  952.     (void) TIFFSeekFile(tif, off, SEEK_SET);
  953.     if (tif->tif_flags & TIFF_SWAB)
  954.         TIFFSwabLong(&nextdir);
  955.     if (!WriteOK(tif, &nextdir, sizeof (uint32))) {
  956.         TIFFError(module, "Error writing directory link");
  957.         return (0);
  958.     }
  959.     /*
  960.      * Leave directory state setup safely.  We don't have
  961.      * facilities for doing inserting and removing directories,
  962.      * so it's safest to just invalidate everything.  This
  963.      * means that the caller can only append to the directory
  964.      * chain.
  965.      */
  966.     (*tif->tif_cleanup)(tif);
  967.     if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
  968.         _TIFFfree(tif->tif_rawdata);
  969.         tif->tif_rawdata = NULL;
  970.         tif->tif_rawcc = 0;
  971.     }
  972.     tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP|TIFF_POSTENCODE);
  973.     TIFFFreeDirectory(tif);
  974.     TIFFDefaultDirectory(tif);
  975.     tif->tif_diroff = 0;            /* force link on next write */
  976.     tif->tif_nextdiroff = 0;        /* next write must be at end */
  977.     tif->tif_curoff = 0;
  978.     tif->tif_row = (uint32) -1;
  979.     tif->tif_curstrip = (tstrip_t) -1;
  980.     return (1);
  981. }
  982.