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