home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / NETWORK / netpbm_src.lzh / NETPBM / LIBTIFF / tif_dir.c < prev    next >
Text File  |  1996-11-18  |  26KB  |  997 lines
  1. #ifndef lint
  2. static char rcsid[] = "$Header: /usr/people/sam/tiff/libtiff/RCS/tif_dir.c,v 1.128 93/08/26 14:21:10 sam Exp Locker: sam $";
  3. #endif
  4.  
  5. /*
  6.  * Copyright (c) 1988, 1989, 1990, 1991, 1992 Sam Leffler
  7.  * Copyright (c) 1991, 1992 Silicon Graphics, Inc.
  8.  *
  9.  * Permission to use, copy, modify, distribute, and sell this software and 
  10.  * its documentation for any purpose is hereby granted without fee, provided
  11.  * that (i) the above copyright notices and this permission notice appear in
  12.  * all copies of the software and related documentation, and (ii) the names of
  13.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  14.  * publicity relating to the software without the specific, prior written
  15.  * permission of Sam Leffler and Silicon Graphics.
  16.  * 
  17.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  18.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  19.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  20.  * 
  21.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  22.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  23.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  24.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  25.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  26.  * OF THIS SOFTWARE.
  27.  */
  28.  
  29. /*
  30.  * TIFF Library.
  31.  *
  32.  * Directory Tag Get & Set Routines.
  33.  * (and also some miscellaneous stuff)
  34.  */
  35. #include "tiffiop.h"
  36.  
  37. static void
  38. setString(char** cpp, char* cp)
  39. {
  40.     if (*cpp)
  41.         _TIFFfree(*cpp), *cpp = 0;
  42.     if (cp) {
  43.         size_t len = strlen(cp)+1;
  44.         if (*cpp = _TIFFmalloc(len))
  45.             memcpy(*cpp, cp, len);
  46.     }
  47. }
  48.  
  49. static void
  50. setShortArray(uint16** wpp, uint16* wp, long n)
  51. {
  52.     if (*wpp)
  53.         _TIFFfree((char *)*wpp), *wpp = 0;
  54.     n *= sizeof (uint16);
  55.     if (wp && (*wpp = (uint16 *)_TIFFmalloc(n)))
  56.         memcpy(*wpp, wp, n);
  57. }
  58.  
  59. static void
  60. setLongArray(uint32** wpp, uint32* wp, long n)
  61. {
  62.     if (*wpp)
  63.         _TIFFfree((char *)*wpp), *wpp = 0;
  64.     n *= sizeof (uint32);
  65.     if (wp && (*wpp = (uint32 *)_TIFFmalloc(n)))
  66.         memcpy(*wpp, wp, n);
  67. }
  68.  
  69. static void
  70. setFloatArray(float** wpp, float* wp, long n)
  71. {
  72.     if (*wpp)
  73.         _TIFFfree((char *)*wpp), *wpp = 0;
  74.     n *= sizeof (float);
  75.     if (wp && (*wpp = (float *)_TIFFmalloc(n)))
  76.         memcpy(*wpp, wp, n);
  77. }
  78.  
  79. #ifdef JPEG_SUPPORT
  80. /*
  81.  * Install a JPEG Quantization table.
  82.  * Note that we reorder the elements
  83.  * of the array in the zig-zag order
  84.  * that is expected by the compression code
  85.  * and that is to be stored in the file.
  86.  */
  87. static void
  88. setJPEGQTable(u_char*** wpp, u_char** wp, int nc)
  89. {
  90.     static u_char zigzag[64] = {
  91.         0,  1,  5,  6, 14, 15, 27, 28,
  92.         2,  4,  7, 13, 16, 26, 29, 42,
  93.         3,  8, 12, 17, 25, 30, 41, 43,
  94.         9, 11, 18, 24, 31, 40, 44, 53,
  95.        10, 19, 23, 32, 39, 45, 52, 54,
  96.        20, 22, 33, 38, 46, 51, 55, 60,
  97.        21, 34, 37, 47, 50, 56, 59, 61,
  98.        35, 36, 48, 49, 57, 58, 62, 63
  99.     };
  100.     char *tab;
  101.     int i, j;
  102.  
  103.     if (*wpp)
  104.         _TIFFfree((char *)*wpp), *wpp = 0;
  105.     *wpp = (u_char **)
  106.         _TIFFmalloc(nc * (sizeof (u_char *) + 64*sizeof (u_char)));
  107.     tab = (((char *)*wpp) + nc*sizeof (u_char *));
  108.     for (i = 0; i < nc; i++) {
  109.         (*wpp)[i] = (u_char *)tab;
  110.         for (j = 0; j < 64; j++)
  111.             tab[zigzag[j]] = wp[i][j];
  112.         tab += 64*sizeof (u_char);
  113.     }
  114. }
  115.  
  116. /*
  117.  * Install a JPEG Coefficient table.
  118.  */
  119. static void
  120. setJPEGCTable(u_char*** cpp, u_char** cp, int nc)
  121. {
  122.     u_char *tab;
  123.     int i, j, nw;
  124.  
  125.     if (*cpp)
  126.         _TIFFfree(*cpp), *cpp = 0;
  127.     /*
  128.      * Calculate the size of the table by counting
  129.      * the number of codes specified in the bits array.
  130.      */
  131.     nw = 0;
  132.     for (i = 0; i < nc; i++) {
  133.         nw += 16;        /* 16 bytes for bits array */
  134.         for (j = 0; j < 16; j++)/* sum up count of codes */
  135.             nw += cp[i][j];
  136.     }
  137.     *cpp = (u_char **)_TIFFmalloc(nc*sizeof (u_char *) + nw);
  138.     tab = ((u_char *)*cpp) + nc*sizeof (u_char *);
  139.     /*
  140.      * Setup internal array and copy user data.
  141.      */
  142.     for (i = 0; i < nc; i++) {
  143.         (*cpp)[i] = tab;
  144.         for (nw = 16, j = 0; j < 16; j++)
  145.             nw += cp[i][j];
  146.         memcpy(tab, cp[i], nw);
  147.         tab += nw;
  148.     }
  149. }
  150. #endif
  151.  
  152. /*
  153.  * Install extra samples information.
  154.  */
  155. static int
  156. setExtraSamples(TIFFDirectory* td, va_list ap, int* v)
  157. {
  158.     uint16* va;
  159.     int i;
  160.  
  161.     *v = va_arg(ap, int);
  162.     if (*v > td->td_samplesperpixel)
  163.         return (0);
  164.     va = va_arg(ap, uint16*);
  165.     if (va == NULL)            /* typically missing param */
  166.         return (0);
  167.     for (i = 0; i < *v; i++)
  168.         if (va[i] > EXTRASAMPLE_UNASSALPHA)
  169.             return (0);
  170.     td->td_extrasamples = *v;
  171.     setShortArray(&td->td_sampleinfo, va, td->td_extrasamples);
  172.     return (1);
  173. }
  174.  
  175. static int
  176. TIFFSetField1(TIFF* tif, ttag_t tag, va_list ap)
  177. {
  178.     TIFFDirectory *td = &tif->tif_dir;
  179.     int status = 1;
  180.     uint32 v32;
  181.     int i, v;
  182.  
  183.     switch (tag) {
  184.     case TIFFTAG_SUBFILETYPE:
  185.         td->td_subfiletype = va_arg(ap, uint32);
  186.         break;
  187.     case TIFFTAG_IMAGEWIDTH:
  188.         td->td_imagewidth = va_arg(ap, uint32);
  189.         break;
  190.     case TIFFTAG_IMAGELENGTH:
  191.         td->td_imagelength = va_arg(ap, uint32);
  192.         break;
  193.     case TIFFTAG_BITSPERSAMPLE:
  194.         td->td_bitspersample = va_arg(ap, int);
  195.         /*
  196.          * If the data require post-decoding processing
  197.          * to byte-swap samples, set it up here.  Note
  198.          * that since tags are required to be ordered,
  199.          * compression code can override this behaviour
  200.          * in the setup method if it wants to roll the
  201.          * post decoding work in with its normal work.
  202.          */
  203.         if (tif->tif_flags & TIFF_SWAB) {
  204.             if (td->td_bitspersample == 16)
  205.                 tif->tif_postdecode = TIFFSwab16BitData;
  206.             else if (td->td_bitspersample == 32)
  207.                 tif->tif_postdecode = TIFFSwab32BitData;
  208.         }
  209.         break;
  210.     case TIFFTAG_COMPRESSION:
  211.         v = va_arg(ap, int) & 0xffff;
  212.         /*
  213.          * If we're changing the compression scheme,
  214.          * the notify the previous module so that it
  215.          * can cleanup any state it's setup.
  216.          */
  217.         if (TIFFFieldSet(tif, FIELD_COMPRESSION)) {
  218.             if (td->td_compression == v)
  219.                 break;
  220.             if (tif->tif_cleanup)
  221.                 (*tif->tif_cleanup)(tif);
  222.         }
  223.         /*
  224.          * Setup new compression routine state.
  225.          */
  226.         if (status = TIFFSetCompressionScheme(tif, v))
  227.             td->td_compression = v;
  228.         break;
  229.     case TIFFTAG_PHOTOMETRIC:
  230.         td->td_photometric = va_arg(ap, int);
  231.         break;
  232.     case TIFFTAG_THRESHHOLDING:
  233.         td->td_threshholding = va_arg(ap, int);
  234.         break;
  235.     case TIFFTAG_FILLORDER:
  236.         v = va_arg(ap, int);
  237.         if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB)
  238.             goto badvalue;
  239.         td->td_fillorder = v;
  240.         break;
  241.     case TIFFTAG_DOCUMENTNAME:
  242.         setString(&td->td_documentname, va_arg(ap, char *));
  243.         break;
  244.     case TIFFTAG_ARTIST:
  245.         setString(&td->td_artist, va_arg(ap, char *));
  246.         break;
  247.     case TIFFTAG_DATETIME:
  248.         setString(&td->td_datetime, va_arg(ap, char *));
  249.         break;
  250.     case TIFFTAG_HOSTCOMPUTER:
  251.         setString(&td->td_hostcomputer, va_arg(ap, char *));
  252.         break;
  253.     case TIFFTAG_IMAGEDESCRIPTION:
  254.         setString(&td->td_imagedescription, va_arg(ap, char *));
  255.         break;
  256.     case TIFFTAG_MAKE:
  257.         setString(&td->td_make, va_arg(ap, char *));
  258.         break;
  259.     case TIFFTAG_MODEL:
  260.         setString(&td->td_model, va_arg(ap, char *));
  261.         break;
  262.     case TIFFTAG_SOFTWARE:
  263.         setString(&td->td_software, va_arg(ap, char *));
  264.         break;
  265.     case TIFFTAG_ORIENTATION:
  266.         v = va_arg(ap, int);
  267.         if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v) {
  268.             TIFFWarning(tif->tif_name,
  269.                 "Bad value %ld for \"%s\" tag ignored",
  270.                 v, TIFFFieldWithTag(tag)->field_name);
  271.         } else
  272.             td->td_orientation = v;
  273.         break;
  274.     case TIFFTAG_SAMPLESPERPIXEL:
  275.         /* XXX should cross check -- e.g. if pallette, then 1 */
  276.         v = va_arg(ap, int);
  277.         if (v == 0)
  278.             goto badvalue;
  279.         td->td_samplesperpixel = v;
  280.         break;
  281.     case TIFFTAG_ROWSPERSTRIP:
  282.         v32 = va_arg(ap, uint32);
  283.         if (v32 == 0)
  284.             goto badvalue32;
  285.         td->td_rowsperstrip = v32;
  286.         if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
  287.             td->td_tilelength = v32;
  288.             td->td_tilewidth = td->td_imagewidth;
  289.         }
  290.         break;
  291.     case TIFFTAG_MINSAMPLEVALUE:
  292.         td->td_minsamplevalue = va_arg(ap, int) & 0xffff;
  293.         break;
  294.     case TIFFTAG_MAXSAMPLEVALUE:
  295.         td->td_maxsamplevalue = va_arg(ap, int) & 0xffff;
  296.         break;
  297.     case TIFFTAG_XRESOLUTION:
  298.         td->td_xresolution = va_arg(ap, dblparam_t);
  299.         break;
  300.     case TIFFTAG_YRESOLUTION:
  301.         td->td_yresolution = va_arg(ap, dblparam_t);
  302.         break;
  303.     case TIFFTAG_PLANARCONFIG:
  304.         v = va_arg(ap, int);
  305.         if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE)
  306.             goto badvalue;
  307.         td->td_planarconfig = v;
  308.         break;
  309.     case TIFFTAG_PAGENAME:
  310.         setString(&td->td_pagename, va_arg(ap, char *));
  311.         break;
  312.     case TIFFTAG_XPOSITION:
  313.         td->td_xposition = va_arg(ap, dblparam_t);
  314.         break;
  315.     case TIFFTAG_YPOSITION:
  316.         td->td_yposition = va_arg(ap, dblparam_t);
  317.         break;
  318.     case TIFFTAG_GROUP3OPTIONS:
  319.         td->td_group3options = va_arg(ap, uint32);
  320.         break;
  321.     case TIFFTAG_GROUP4OPTIONS:
  322.         td->td_group4options = va_arg(ap, uint32);
  323.         break;
  324.     case TIFFTAG_RESOLUTIONUNIT:
  325.         v = va_arg(ap, int);
  326.         if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v)
  327.             goto badvalue;
  328.         td->td_resolutionunit = v;
  329.         break;
  330.     case TIFFTAG_PAGENUMBER:
  331.         td->td_pagenumber[0] = va_arg(ap, int);
  332.         td->td_pagenumber[1] = va_arg(ap, int);
  333.         break;
  334.     case TIFFTAG_HALFTONEHINTS:
  335.         td->td_halftonehints[0] = va_arg(ap, int);
  336.         td->td_halftonehints[1] = va_arg(ap, int);
  337.         break;
  338.     case TIFFTAG_COLORMAP:
  339.         v = 1L<<td->td_bitspersample;
  340.         setShortArray(&td->td_colormap[0], va_arg(ap, uint16*), v);
  341.         setShortArray(&td->td_colormap[1], va_arg(ap, uint16*), v);
  342.         setShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v);
  343.         break;
  344.     case TIFFTAG_PREDICTOR:
  345.         td->td_predictor = va_arg(ap, int);
  346.         break;
  347.     case TIFFTAG_EXTRASAMPLES:
  348.         if (!setExtraSamples(td, ap, &v))
  349.             goto badvalue;
  350.         break;
  351.     case TIFFTAG_MATTEING:
  352.         td->td_extrasamples = (va_arg(ap, int) != 0);
  353.         if (td->td_extrasamples) {
  354.             uint16 sv = EXTRASAMPLE_ASSOCALPHA;
  355.             setShortArray(&td->td_sampleinfo, &sv, 1);
  356.         }
  357.         break;
  358.     case TIFFTAG_BADFAXLINES:
  359.         td->td_badfaxlines = va_arg(ap, uint32);
  360.         break;
  361.     case TIFFTAG_CLEANFAXDATA:
  362.         td->td_cleanfaxdata = va_arg(ap, int);
  363.         break;
  364.     case TIFFTAG_CONSECUTIVEBADFAXLINES:
  365.         td->td_badfaxrun = va_arg(ap, uint32);
  366.         break;
  367.     case TIFFTAG_TILEWIDTH:
  368.         v32 = va_arg(ap, uint32);
  369.         if (v32 % 16)
  370.             goto badvalue32;
  371.         td->td_tilewidth = v32;
  372.         tif->tif_flags |= TIFF_ISTILED;
  373.         break;
  374.     case TIFFTAG_TILELENGTH:
  375.         v32 = va_arg(ap, uint32);
  376.         if (v32 % 16)
  377.             goto badvalue32;
  378.         td->td_tilelength = v32;
  379.         tif->tif_flags |= TIFF_ISTILED;
  380.         break;
  381.     case TIFFTAG_TILEDEPTH:
  382.         v32 = va_arg(ap, uint32);
  383.         if (v == 0)
  384.             goto badvalue32;
  385.         td->td_tiledepth = v32;
  386.         break;
  387.     case TIFFTAG_DATATYPE:
  388.     case TIFFTAG_SAMPLEFORMAT:
  389.         v = va_arg(ap, int);
  390.         if (tag == TIFFTAG_DATATYPE && v == 0)
  391.             v = SAMPLEFORMAT_VOID;
  392.         if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_VOID < v)
  393.             goto badvalue;
  394.         td->td_sampleformat = v;
  395.         break;
  396.     case TIFFTAG_IMAGEDEPTH:
  397.         td->td_imagedepth = va_arg(ap, uint32);
  398.         break;
  399. #ifdef YCBCR_SUPPORT
  400.     case TIFFTAG_YCBCRCOEFFICIENTS:
  401.         setFloatArray(&td->td_ycbcrcoeffs, va_arg(ap, float *), 3);
  402.         break;
  403.     case TIFFTAG_YCBCRPOSITIONING:
  404.         td->td_ycbcrpositioning = va_arg(ap, int);
  405.         break;
  406.     case TIFFTAG_YCBCRSUBSAMPLING:
  407.         td->td_ycbcrsubsampling[0] = va_arg(ap, int);
  408.         td->td_ycbcrsubsampling[1] = va_arg(ap, int);
  409.         break;
  410. #endif
  411. #ifdef JPEG_SUPPORT
  412.     case TIFFTAG_JPEGPROC:
  413.         td->td_jpegproc = va_arg(ap, int);
  414.         break;
  415.     case TIFFTAG_JPEGRESTARTINTERVAL:
  416.         td->td_jpegrestartinterval = va_arg(ap, int);
  417.         break;
  418.     case TIFFTAG_JPEGQTABLES:
  419.         setJPEGQTable(&td->td_qtab, va_arg(ap, u_char **),
  420.             td->td_samplesperpixel);
  421.         break;
  422.     case TIFFTAG_JPEGDCTABLES:
  423.         setJPEGCTable(&td->td_dctab, va_arg(ap, u_char **),
  424.             td->td_samplesperpixel);
  425.         break;
  426.     case TIFFTAG_JPEGACTABLES:
  427.         setJPEGCTable(&td->td_actab, va_arg(ap, u_char **),
  428.             td->td_samplesperpixel);
  429.         break;
  430. #endif
  431. #ifdef COLORIMETRY_SUPPORT
  432.     case TIFFTAG_WHITEPOINT:
  433.         setFloatArray(&td->td_whitepoint, va_arg(ap, float *), 2);
  434.         break;
  435.     case TIFFTAG_PRIMARYCHROMATICITIES:
  436.         setFloatArray(&td->td_primarychromas, va_arg(ap, float *), 6);
  437.         break;
  438.     case TIFFTAG_TRANSFERFUNCTION:
  439.         v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1;
  440.         for (i = 0; i < v; i++)
  441.             setShortArray(&td->td_transferfunction[i],
  442.                 va_arg(ap, uint16*), 1L<<td->td_bitspersample);
  443.         break;
  444.     case TIFFTAG_REFERENCEBLACKWHITE:
  445.         /* XXX should check for null range */
  446.         setFloatArray(&td->td_refblackwhite, va_arg(ap, float *), 6);
  447.         break;
  448. #endif
  449. #ifdef CMYK_SUPPORT
  450.     case TIFFTAG_INKSET:
  451.         td->td_inkset = va_arg(ap, int);
  452.         break;
  453.     case TIFFTAG_DOTRANGE:
  454.         /* XXX should check for null range */
  455.         td->td_dotrange[0] = va_arg(ap, int);
  456.         td->td_dotrange[1] = va_arg(ap, int);
  457.         break;
  458.     case TIFFTAG_INKNAMES:
  459.         setString(&td->td_inknames, va_arg(ap, char *));
  460.         break;
  461.     case TIFFTAG_TARGETPRINTER:
  462.         setString(&td->td_targetprinter, va_arg(ap, char *));
  463.         break;
  464. #endif
  465.     default:
  466.         TIFFError(tif->tif_name,
  467.             "Internal error, tag value botch, tag \"%s\"",
  468.             TIFFFieldWithTag(tag)->field_name);
  469.         status = 0;
  470.         break;
  471.     }
  472.     if (status) {
  473.         TIFFSetFieldBit(tif, TIFFFieldWithTag(tag)->field_bit);
  474.         tif->tif_flags |= TIFF_DIRTYDIRECT;
  475.     }
  476.     va_end(ap);
  477.     return (status);
  478. badvalue:
  479.     TIFFError(tif->tif_name, "%d: Bad value for \"%s\"", v,
  480.         TIFFFieldWithTag(tag)->field_name);
  481.     va_end(ap);
  482.     return (0);
  483. badvalue32:
  484.     TIFFError(tif->tif_name, "%ld: Bad value for \"%s\"", v32,
  485.         TIFFFieldWithTag(tag)->field_name);
  486.     va_end(ap);
  487.     return (0);
  488. }
  489.  
  490. /*
  491.  * Return 1/0 according to whether or not
  492.  * it is permissible to set the tag's value.
  493.  * Note that we allow ImageLength to be changed
  494.  * so that we can append and extend to images.
  495.  * Any other tag may not be altered once writing
  496.  * has commenced, unless its value has no effect
  497.  * on the format of the data that is written.
  498.  */
  499. static int
  500. OkToChangeTag(TIFF* tif, ttag_t tag)
  501. {
  502.     if (tag != TIFFTAG_IMAGELENGTH &&
  503.         (tif->tif_flags & TIFF_BEENWRITING)) {
  504.         const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  505.         /*
  506.          * Consult info table to see if tag can be changed
  507.          * after we've started writing.  We only allow changes
  508.          * to those tags that don't/shouldn't affect the
  509.          * compression and/or format of the data.
  510.          */
  511.         if (fip && !fip->field_oktochange)
  512.             return (0);
  513.     }
  514.     return (1);
  515. }
  516.  
  517. /*
  518.  * Record the value of a field in the
  519.  * internal directory structure.  The
  520.  * field will be written to the file
  521.  * when/if the directory structure is
  522.  * updated.
  523.  */
  524. int
  525. TIFFSetField(TIFF* tif, ttag_t tag, ...)
  526. {
  527.     int status = 0;
  528.  
  529.     if (OkToChangeTag(tif, tag)) {
  530.         va_list ap;
  531.  
  532.         va_start(ap, tag);
  533.         status = TIFFSetField1(tif, tag, ap);
  534.         va_end(ap);
  535.     } else {
  536.         const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  537.         if (fip)
  538.             TIFFError("TIFFSetField",
  539.                 "%s: Cannot modify tag \"%s\" while writing",
  540.                 tif->tif_name, fip->field_name);
  541.     }
  542.     return (status);
  543. }
  544.  
  545. /*
  546.  * Like TIFFSetField, but taking a varargs
  547.  * parameter list.  This routine is useful
  548.  * for building higher-level interfaces on
  549.  * top of the library.
  550.  */
  551. int
  552. TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
  553. {
  554.     int status = 0;
  555.  
  556.     if (!OkToChangeTag(tif, tag)) {
  557.         const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  558.         if (fip)
  559.             TIFFError("TIFFVSetField",
  560.                 "%s: Cannot modify tag \"%s\" while writing",
  561.                 tif->tif_name, fip->field_name);
  562.     } else
  563.         status = TIFFSetField1(tif, tag, ap);
  564.     return (status);
  565. }
  566.  
  567. static void
  568. TIFFGetField1(TIFFDirectory* td, ttag_t tag, va_list ap)
  569. {
  570.     switch (tag) {
  571.     case TIFFTAG_SUBFILETYPE:
  572.         *va_arg(ap, uint32*) = td->td_subfiletype;
  573.         break;
  574.     case TIFFTAG_IMAGEWIDTH:
  575.         *va_arg(ap, uint32*) = td->td_imagewidth;
  576.         break;
  577.     case TIFFTAG_IMAGELENGTH:
  578.         *va_arg(ap, uint32*) = td->td_imagelength;
  579.         break;
  580.     case TIFFTAG_BITSPERSAMPLE:
  581.         *va_arg(ap, uint16*) = td->td_bitspersample;
  582.         break;
  583.     case TIFFTAG_COMPRESSION:
  584.         *va_arg(ap, uint16*) = td->td_compression;
  585.         break;
  586.     case TIFFTAG_PHOTOMETRIC:
  587.         *va_arg(ap, uint16*) = td->td_photometric;
  588.         break;
  589.     case TIFFTAG_THRESHHOLDING:
  590.         *va_arg(ap, uint16*) = td->td_threshholding;
  591.         break;
  592.     case TIFFTAG_FILLORDER:
  593.         *va_arg(ap, uint16*) = td->td_fillorder;
  594.         break;
  595.     case TIFFTAG_DOCUMENTNAME:
  596.         *va_arg(ap, char **) = td->td_documentname;
  597.         break;
  598.     case TIFFTAG_ARTIST:
  599.         *va_arg(ap, char **) = td->td_artist;
  600.         break;
  601.     case TIFFTAG_DATETIME:
  602.         *va_arg(ap, char **) = td->td_datetime;
  603.         break;
  604.     case TIFFTAG_HOSTCOMPUTER:
  605.         *va_arg(ap, char **) = td->td_hostcomputer;
  606.         break;
  607.     case TIFFTAG_IMAGEDESCRIPTION:
  608.         *va_arg(ap, char **) = td->td_imagedescription;
  609.         break;
  610.     case TIFFTAG_MAKE:
  611.         *va_arg(ap, char **) = td->td_make;
  612.         break;
  613.     case TIFFTAG_MODEL:
  614.         *va_arg(ap, char **) = td->td_model;
  615.         break;
  616.     case TIFFTAG_SOFTWARE:
  617.         *va_arg(ap, char **) = td->td_software;
  618.         break;
  619.     case TIFFTAG_ORIENTATION:
  620.         *va_arg(ap, uint16*) = td->td_orientation;
  621.         break;
  622.     case TIFFTAG_SAMPLESPERPIXEL:
  623.         *va_arg(ap, uint16*) = td->td_samplesperpixel;
  624.         break;
  625.     case TIFFTAG_ROWSPERSTRIP:
  626.         *va_arg(ap, uint32*) = td->td_rowsperstrip;
  627.         break;
  628.     case TIFFTAG_MINSAMPLEVALUE:
  629.         *va_arg(ap, uint16*) = td->td_minsamplevalue;
  630.         break;
  631.     case TIFFTAG_MAXSAMPLEVALUE:
  632.         *va_arg(ap, uint16*) = td->td_maxsamplevalue;
  633.         break;
  634.     case TIFFTAG_XRESOLUTION:
  635.         *va_arg(ap, float *) = td->td_xresolution;
  636.         break;
  637.     case TIFFTAG_YRESOLUTION:
  638.         *va_arg(ap, float *) = td->td_yresolution;
  639.         break;
  640.     case TIFFTAG_PLANARCONFIG:
  641.         *va_arg(ap, uint16*) = td->td_planarconfig;
  642.         break;
  643.     case TIFFTAG_XPOSITION:
  644.         *va_arg(ap, float *) = td->td_xposition;
  645.         break;
  646.     case TIFFTAG_YPOSITION:
  647.         *va_arg(ap, float *) = td->td_yposition;
  648.         break;
  649.     case TIFFTAG_PAGENAME:
  650.         *va_arg(ap, char **) = td->td_pagename;
  651.         break;
  652.     case TIFFTAG_GROUP3OPTIONS:
  653.         *va_arg(ap, uint32*) = td->td_group3options;
  654.         break;
  655.     case TIFFTAG_GROUP4OPTIONS:
  656.         *va_arg(ap, uint32*) = td->td_group4options;
  657.         break;
  658.     case TIFFTAG_RESOLUTIONUNIT:
  659.         *va_arg(ap, uint16*) = td->td_resolutionunit;
  660.         break;
  661.     case TIFFTAG_PAGENUMBER:
  662.         *va_arg(ap, uint16*) = td->td_pagenumber[0];
  663.         *va_arg(ap, uint16*) = td->td_pagenumber[1];
  664.         break;
  665.     case TIFFTAG_HALFTONEHINTS:
  666.         *va_arg(ap, uint16*) = td->td_halftonehints[0];
  667.         *va_arg(ap, uint16*) = td->td_halftonehints[1];
  668.         break;
  669.     case TIFFTAG_COLORMAP:
  670.         *va_arg(ap, uint16**) = td->td_colormap[0];
  671.         *va_arg(ap, uint16**) = td->td_colormap[1];
  672.         *va_arg(ap, uint16**) = td->td_colormap[2];
  673.         break;
  674.     case TIFFTAG_PREDICTOR:
  675.         *va_arg(ap, uint16*) = td->td_predictor;
  676.         break;
  677.     case TIFFTAG_STRIPOFFSETS:
  678.     case TIFFTAG_TILEOFFSETS:
  679.         *va_arg(ap, uint32**) = td->td_stripoffset;
  680.         break;
  681.     case TIFFTAG_STRIPBYTECOUNTS:
  682.     case TIFFTAG_TILEBYTECOUNTS:
  683.         *va_arg(ap, uint32**) = td->td_stripbytecount;
  684.         break;
  685.     case TIFFTAG_MATTEING:
  686.         *va_arg(ap, uint16*) =
  687.             (td->td_extrasamples == 1 &&
  688.              td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
  689.         break;
  690.     case TIFFTAG_EXTRASAMPLES:
  691.         *va_arg(ap, uint16*) = td->td_extrasamples;
  692.         *va_arg(ap, uint16**) = td->td_sampleinfo;
  693.         break;
  694.     case TIFFTAG_BADFAXLINES:
  695.         *va_arg(ap, uint32*) = td->td_badfaxlines;
  696.         break;
  697.     case TIFFTAG_CLEANFAXDATA:
  698.         *va_arg(ap, uint16*) = td->td_cleanfaxdata;
  699.         break;
  700.     case TIFFTAG_CONSECUTIVEBADFAXLINES:
  701.         *va_arg(ap, uint32*) = td->td_badfaxrun;
  702.         break;
  703.     case TIFFTAG_TILEWIDTH:
  704.         *va_arg(ap, uint32*) = td->td_tilewidth;
  705.         break;
  706.     case TIFFTAG_TILELENGTH:
  707.         *va_arg(ap, uint32*) = td->td_tilelength;
  708.         break;
  709.     case TIFFTAG_TILEDEPTH:
  710.         *va_arg(ap, uint32*) = td->td_tiledepth;
  711.         break;
  712.     case TIFFTAG_DATATYPE:
  713.         *va_arg(ap, uint16*) =
  714.             (td->td_sampleformat == SAMPLEFORMAT_VOID ?
  715.             0 : td->td_sampleformat);
  716.         break;
  717.     case TIFFTAG_SAMPLEFORMAT:
  718.         *va_arg(ap, uint16*) = td->td_sampleformat;
  719.         break;
  720.     case TIFFTAG_IMAGEDEPTH:
  721.         *va_arg(ap, uint32*) = td->td_imagedepth;
  722.         break;
  723. #ifdef YCBCR_SUPPORT
  724.     case TIFFTAG_YCBCRCOEFFICIENTS:
  725.         *va_arg(ap, float **) = td->td_ycbcrcoeffs;
  726.         break;
  727.     case TIFFTAG_YCBCRPOSITIONING:
  728.         *va_arg(ap, uint16*) = td->td_ycbcrpositioning;
  729.         break;
  730.     case TIFFTAG_YCBCRSUBSAMPLING:
  731.         *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[0];
  732.         *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[1];
  733.         break;
  734. #endif
  735. #ifdef JPEG_SUPPORT
  736.     case TIFFTAG_JPEGPROC:
  737.         *va_arg(ap, uint16*) = td->td_jpegproc;
  738.         break;
  739.     case TIFFTAG_JPEGRESTARTINTERVAL:
  740.         *va_arg(ap, uint16*) = td->td_jpegrestartinterval;
  741.         break;
  742.     case TIFFTAG_JPEGQTABLES:
  743.         *va_arg(ap, u_char ***) = td->td_qtab;
  744.         break;
  745.     case TIFFTAG_JPEGDCTABLES:
  746.         *va_arg(ap, u_char ***) = td->td_dctab;
  747.         break;
  748.     case TIFFTAG_JPEGACTABLES:
  749.         *va_arg(ap, u_char ***) = td->td_actab;
  750.         break;
  751. #endif
  752. #ifdef COLORIMETRY_SUPPORT
  753.     case TIFFTAG_WHITEPOINT:
  754.         *va_arg(ap, float **) = td->td_whitepoint;
  755.         break;
  756.     case TIFFTAG_PRIMARYCHROMATICITIES:
  757.         *va_arg(ap, float **) = td->td_primarychromas;
  758.         break;
  759.     case TIFFTAG_TRANSFERFUNCTION:
  760.         *va_arg(ap, uint16**) = td->td_transferfunction[0];
  761.         if (td->td_samplesperpixel - td->td_extrasamples > 1) {
  762.             *va_arg(ap, uint16**) = td->td_transferfunction[1];
  763.             *va_arg(ap, uint16**) = td->td_transferfunction[2];
  764.         }
  765.         break;
  766.     case TIFFTAG_REFERENCEBLACKWHITE:
  767.         *va_arg(ap, float **) = td->td_refblackwhite;
  768.         break;
  769. #endif
  770. #ifdef CMYK_SUPPORT
  771.     case TIFFTAG_INKSET:
  772.         *va_arg(ap, uint16*) = td->td_inkset;
  773.         break;
  774.     case TIFFTAG_DOTRANGE:
  775.         *va_arg(ap, uint16*) = td->td_dotrange[0];
  776.         *va_arg(ap, uint16*) = td->td_dotrange[1];
  777.         break;
  778.     case TIFFTAG_INKNAMES:
  779.         *va_arg(ap, char **) = td->td_inknames;
  780.         break;
  781.     case TIFFTAG_TARGETPRINTER:
  782.         *va_arg(ap, char **) = td->td_targetprinter;
  783.         break;
  784. #endif
  785.     default:
  786.         TIFFError("TIFFGetField1",
  787.             "Internal error, no value returned for tag \"%s\"",
  788.             TIFFFieldWithTag(tag)->field_name);
  789.         break;
  790.     }
  791.     va_end(ap);
  792. }
  793.  
  794. /*
  795.  * Return the value of a field in the
  796.  * internal directory structure.
  797.  */
  798. int
  799. TIFFGetField(TIFF* tif, ttag_t tag, ...)
  800. {
  801.     const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  802.  
  803.     if (fip) {
  804.         u_short bit = fip->field_bit;
  805.         if (bit != FIELD_IGNORE && TIFFFieldSet(tif, bit)) {
  806.             va_list ap;
  807.             va_start(ap, tag);
  808.             TIFFGetField1(&tif->tif_dir, tag, ap);
  809.             va_end(ap);
  810.             return (1);
  811.         }
  812.     } else
  813.         TIFFError("TIFFGetField", "Unknown field, tag 0x%x", tag);
  814.     return (0);
  815. }
  816.  
  817. /*
  818.  * Like TIFFGetField, but taking a varargs
  819.  * parameter list.  This routine is useful
  820.  * for building higher-level interfaces on
  821.  * top of the library.
  822.  */
  823. int
  824. TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
  825. {
  826.     const TIFFFieldInfo *fip = TIFFFindFieldInfo(tag, TIFF_ANY);
  827.  
  828.     if (fip) {
  829.         u_short bit = fip->field_bit;
  830.         if (bit != FIELD_IGNORE && TIFFFieldSet(tif, bit)) {
  831.             TIFFGetField1(&tif->tif_dir, tag, ap);
  832.             return (1);
  833.         }
  834.     } else
  835.         TIFFError("TIFFGetField", "Unknown field, tag 0x%x", tag);
  836.     return (0);
  837. }
  838.  
  839. /*
  840.  * Internal interface to TIFFGetField...
  841.  */
  842. void
  843. _TIFFgetfield(TIFFDirectory* td, ttag_t tag, ...)
  844. {
  845.     va_list ap;
  846.     va_start(ap, tag);
  847.     TIFFGetField1(td, tag, ap);
  848.     va_end(ap);
  849. }
  850.  
  851. #define    CleanupField(member) {        \
  852.     if (td->member) {            \
  853.     _TIFFfree((char *)td->member);    \
  854.     td->member = 0;            \
  855.     }                    \
  856. }
  857.  
  858. /*
  859.  * Release storage associated with a directory.
  860.  */
  861. void
  862. TIFFFreeDirectory(TIFF* tif)
  863. {
  864.     register TIFFDirectory *td = &tif->tif_dir;
  865.  
  866.     CleanupField(td_colormap[0]);
  867.     CleanupField(td_colormap[1]);
  868.     CleanupField(td_colormap[2]);
  869.     CleanupField(td_documentname);
  870.     CleanupField(td_artist);
  871.     CleanupField(td_datetime);
  872.     CleanupField(td_hostcomputer);
  873.     CleanupField(td_imagedescription);
  874.     CleanupField(td_make);
  875.     CleanupField(td_model);
  876.     CleanupField(td_software);
  877.     CleanupField(td_pagename);
  878.     CleanupField(td_sampleinfo);
  879. #ifdef YCBCR_SUPPORT
  880.     CleanupField(td_ycbcrcoeffs);
  881. #endif
  882. #ifdef JPEG_SUPPORT
  883.     CleanupField(td_qtab);
  884.     CleanupField(td_dctab);
  885.     CleanupField(td_actab);
  886. #endif
  887. #ifdef CMYK_SUPPORT
  888.     CleanupField(td_inknames);
  889.     CleanupField(td_targetprinter);
  890. #endif
  891. #ifdef COLORIMETRY_SUPPORT
  892.     CleanupField(td_whitepoint);
  893.     CleanupField(td_primarychromas);
  894.     CleanupField(td_refblackwhite);
  895.     CleanupField(td_transferfunction[0]);
  896.     CleanupField(td_transferfunction[1]);
  897.     CleanupField(td_transferfunction[2]);
  898. #endif
  899.     CleanupField(td_stripoffset);
  900.     CleanupField(td_stripbytecount);
  901. }
  902. #undef CleanupField
  903.  
  904. /*
  905.  * Setup a default directory structure.
  906.  */
  907. int
  908. TIFFDefaultDirectory(TIFF* tif)
  909. {
  910.     register TIFFDirectory *td = &tif->tif_dir;
  911.  
  912.     memset(td, 0, sizeof (*td));
  913.     td->td_fillorder = FILLORDER_MSB2LSB;
  914.     td->td_bitspersample = 1;
  915.     td->td_threshholding = THRESHHOLD_BILEVEL;
  916.     td->td_orientation = ORIENTATION_TOPLEFT;
  917.     td->td_samplesperpixel = 1;
  918.     td->td_predictor = 1;
  919.     td->td_rowsperstrip = 0xffffffff;
  920.     td->td_tilewidth = 0xffffffff;
  921.     td->td_tilelength = 0xffffffff;
  922.     td->td_tiledepth = 1;
  923.     td->td_resolutionunit = RESUNIT_INCH;
  924.     td->td_sampleformat = SAMPLEFORMAT_VOID;
  925.     td->td_imagedepth = 1;
  926. #ifdef YCBCR_SUPPORT
  927.     td->td_ycbcrsubsampling[0] = 2;
  928.     td->td_ycbcrsubsampling[1] = 2;
  929.     td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
  930. #endif
  931. #ifdef CMYK_SUPPORT
  932.     td->td_inkset = INKSET_CMYK;
  933. #endif
  934.     (void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
  935.     /*
  936.      * NB: The directory is marked dirty as a result of setting
  937.      * up the default compression scheme.  However, this really
  938.      * isn't correct -- we want TIFF_DIRTYDIRECT to be set only
  939.      * if the user does something.  We could just do the setup
  940.      * by hand, but it seems better to use the normal mechanism
  941.      * (i.e. TIFFSetField).
  942.      */
  943.     tif->tif_flags &= ~TIFF_DIRTYDIRECT;
  944.     return (1);
  945. }
  946.  
  947. /*
  948.  * Set the n-th directory as the current directory.
  949.  * NB: Directories are numbered starting at 0.
  950.  */
  951. int
  952. TIFFSetDirectory(TIFF* tif, tdir_t dirn)
  953. {
  954.     static const char module[] = "TIFFSetDirectory";
  955.     uint16 dircount;
  956.     uint32 nextdir;
  957.     tdir_t n;
  958.  
  959.     nextdir = tif->tif_header.tiff_diroff;
  960.     for (n = dirn; n > 0 && nextdir != 0; n--) {
  961.         if (!SeekOK(tif, nextdir) ||
  962.             !ReadOK(tif, &dircount, sizeof (uint16))) {
  963.             TIFFError(module, "%s: Error fetching directory count",
  964.                 tif->tif_name);
  965.             return (0);
  966.         }
  967.         if (tif->tif_flags & TIFF_SWAB)
  968.             TIFFSwabShort(&dircount);
  969.         TIFFSeekFile(tif, dircount*sizeof (TIFFDirEntry), L_INCR);
  970.         if (!ReadOK(tif, &nextdir, sizeof (uint32))) {
  971.             TIFFError(module, "%s: Error fetching directory link",
  972.                 tif->tif_name);
  973.             return (0);
  974.         }
  975.         if (tif->tif_flags & TIFF_SWAB)
  976.             TIFFSwabLong(&nextdir);
  977.     }
  978.     tif->tif_nextdiroff = nextdir;
  979.     /*
  980.      * Set curdir to the actual directory index.  The
  981.      * -1 is because TIFFReadDirectory will increment
  982.      * tif_curdir after successfully reading the directory.
  983.      */
  984.     tif->tif_curdir = (dirn - n) - 1;
  985.     return (TIFFReadDirectory(tif));
  986. }
  987.  
  988. /*
  989.  * Return an indication of whether or not we are
  990.  * at the last directory in the file.
  991.  */
  992. int
  993. TIFFLastDirectory(TIFF* tif)
  994. {
  995.     return (tif->tif_nextdiroff == 0);
  996. }
  997.