src/tiff/tif_dir.c

   1 /* $Header$ */
   2
   3 /*
   4  * Copyright (c) 1988-1997 Sam Leffler
   5  * Copyright (c) 1991-1997 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 static void
  44 setByteArray(void** vpp, void* vp, size_t nmemb, size_t elem_size)
  45 {
  46         if (*vpp)
  47                 _TIFFfree(*vpp), *vpp = 0;
  48         if (vp) {
  49                 tsize_t bytes = nmemb * elem_size;
  50                 if (elem_size && bytes / elem_size == nmemb)
  51                         *vpp = (void*) _TIFFmalloc(bytes);
  52                 if (*vpp)
  53                         _TIFFmemcpy(*vpp, vp, bytes);
  54         }
  55 }
  56 void _TIFFsetByteArray(void** vpp, void* vp, long n)
  57     { setByteArray(vpp, vp, n, 1); }
  58 void _TIFFsetString(char** cpp, char* cp)
  59     { setByteArray((void**) cpp, (void*) cp, strlen(cp)+1, 1); }
  60 void _TIFFsetNString(char** cpp, char* cp, long n)
  61     { setByteArray((void**) cpp, (void*) cp, n, 1); }
  62 void _TIFFsetShortArray(uint16** wpp, uint16* wp, long n)
  63     { setByteArray((void**) wpp, (void*) wp, n, sizeof (uint16)); }
  64 void _TIFFsetLongArray(uint32** lpp, uint32* lp, long n)
  65     { setByteArray((void**) lpp, (void*) lp, n, sizeof (uint32)); }
  66 void _TIFFsetFloatArray(float** fpp, float* fp, long n)
  67     { setByteArray((void**) fpp, (void*) fp, n, sizeof (float)); }
  68 void _TIFFsetDoubleArray(double** dpp, double* dp, long n)
  69     { setByteArray((void**) dpp, (void*) dp, n, sizeof (double)); }
  70
  71 /*
  72  * Install extra samples information.
  73  */
  74 static int
  75 setExtraSamples(TIFFDirectory* td, va_list ap, int* v)
  76 {
  77         uint16* va;
  78         int i;
  79
  80         *v = va_arg(ap, int);
  81         if ((uint16) *v > td->td_samplesperpixel)
  82                 return (0);
  83         va = va_arg(ap, uint16*);
  84         if (*v > 0 && va == NULL)               /* typically missing param */
  85                 return (0);
  86         for (i = 0; i < *v; i++)
  87                 if (va[i] > EXTRASAMPLE_UNASSALPHA)
  88                         return (0);
  89         td->td_extrasamples = (uint16) *v;
  90         _TIFFsetShortArray(&td->td_sampleinfo, va, td->td_extrasamples);
  91         return (1);
  92 }
  93
  94 static int
  95 checkInkNamesString(TIFF* tif, int slen, const char* s)
  96 {
  97         TIFFDirectory* td = &tif->tif_dir;
  98         int i = td->td_samplesperpixel;
  99
 100         if (slen > 0) {
 101                 const char* ep = s+slen;
 102                 const char* cp = s;
 103                 for (; i > 0; i--) {
 104                         for (; *cp != '\0'; cp++)
 105                                 if (cp >= ep)
 106                                         goto bad;
 107                         cp++;                           /* skip \0 */
 108                 }
 109                 return (cp-s);
 110         }
 111 bad:
 112         TIFFError("TIFFSetField",
 113             "%s: Invalid InkNames value; expecting %d names, found %d",
 114             tif->tif_name,
 115             td->td_samplesperpixel,
 116             td->td_samplesperpixel-i);
 117         return (0);
 118 }
 119
 120 static int
 121 _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
 122 {
 123         static const char module[] = "_TIFFVSetField";
 124
 125         TIFFDirectory* td = &tif->tif_dir;
 126         int status = 1;
 127         uint32 v32;
 128         int i, v;
 129         double d;
 130         char* s;
 131
 132         switch (tag) {
 133         case TIFFTAG_SUBFILETYPE:
 134                 td->td_subfiletype = va_arg(ap, uint32);
 135                 break;
 136         case TIFFTAG_IMAGEWIDTH:
 137                 td->td_imagewidth = va_arg(ap, uint32);
 138                 break;
 139         case TIFFTAG_IMAGELENGTH:
 140                 td->td_imagelength = va_arg(ap, uint32);
 141                 break;
 142         case TIFFTAG_BITSPERSAMPLE:
 143                 td->td_bitspersample = (uint16) va_arg(ap, int);
 144                 /*
 145                  * If the data require post-decoding processing
 146                  * to byte-swap samples, set it up here.  Note
 147                  * that since tags are required to be ordered,
 148                  * compression code can override this behaviour
 149                  * in the setup method if it wants to roll the
 150                  * post decoding work in with its normal work.
 151                  */
 152                 if (tif->tif_flags & TIFF_SWAB) {
 153                         if (td->td_bitspersample == 16)
 154                                 tif->tif_postdecode = _TIFFSwab16BitData;
 155                         else if (td->td_bitspersample == 32)
 156                                 tif->tif_postdecode = _TIFFSwab32BitData;
 157                         else if (td->td_bitspersample == 64)
 158                                 tif->tif_postdecode = _TIFFSwab64BitData;
 159                 }
 160                 break;
 161         case TIFFTAG_COMPRESSION:
 162                 v = va_arg(ap, int) & 0xffff;
 163                 /*
 164                  * If we're changing the compression scheme,
 165                  * the notify the previous module so that it
 166                  * can cleanup any state it's setup.
 167                  */
 168                 if (TIFFFieldSet(tif, FIELD_COMPRESSION)) {
 169                         if (td->td_compression == v)
 170                                 break;
 171                         (*tif->tif_cleanup)(tif);
 172                         tif->tif_flags &= ~TIFF_CODERSETUP;
 173                 }
 174                 /*
 175                  * Setup new compression routine state.
 176                  */
 177                 if( (status = TIFFSetCompressionScheme(tif, v)) != 0 )
 178                     td->td_compression = (uint16) v;
 179                 else
 180                     status = 0;
 181                 break;
 182         case TIFFTAG_PHOTOMETRIC:
 183                 td->td_photometric = (uint16) va_arg(ap, int);
 184                 break;
 185         case TIFFTAG_THRESHHOLDING:
 186                 td->td_threshholding = (uint16) va_arg(ap, int);
 187                 break;
 188         case TIFFTAG_FILLORDER:
 189                 v = va_arg(ap, int);
 190                 if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB)
 191                         goto badvalue;
 192                 td->td_fillorder = (uint16) v;
 193                 break;
 194         case TIFFTAG_DOCUMENTNAME:
 195                 _TIFFsetString(&td->td_documentname, va_arg(ap, char*));
 196                 break;
 197         case TIFFTAG_ARTIST:
 198                 _TIFFsetString(&td->td_artist, va_arg(ap, char*));
 199                 break;
 200         case TIFFTAG_DATETIME:
 201                 _TIFFsetString(&td->td_datetime, va_arg(ap, char*));
 202                 break;
 203         case TIFFTAG_HOSTCOMPUTER:
 204                 _TIFFsetString(&td->td_hostcomputer, va_arg(ap, char*));
 205                 break;
 206         case TIFFTAG_IMAGEDESCRIPTION:
 207                 _TIFFsetString(&td->td_imagedescription, va_arg(ap, char*));
 208                 break;
 209         case TIFFTAG_MAKE:
 210                 _TIFFsetString(&td->td_make, va_arg(ap, char*));
 211                 break;
 212         case TIFFTAG_MODEL:
 213                 _TIFFsetString(&td->td_model, va_arg(ap, char*));
 214                 break;
 215         case TIFFTAG_COPYRIGHT:
 216                 _TIFFsetString(&td->td_copyright, va_arg(ap, char*));
 217                 break;
 218         case TIFFTAG_ORIENTATION:
 219                 v = va_arg(ap, int);
 220                 if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v) {
 221                         TIFFWarning(tif->tif_name,
 222                             "Bad value %ld for \"%s\" tag ignored",
 223                             v, _TIFFFieldWithTag(tif, tag)->field_name);
 224                 } else
 225                         td->td_orientation = (uint16) v;
 226                 break;
 227         case TIFFTAG_SAMPLESPERPIXEL:
 228                 /* XXX should cross check -- e.g. if pallette, then 1 */
 229                 v = va_arg(ap, int);
 230                 if (v == 0)
 231                         goto badvalue;
 232                 td->td_samplesperpixel = (uint16) v;
 233                 break;
 234         case TIFFTAG_ROWSPERSTRIP:
 235                 v32 = va_arg(ap, uint32);
 236                 if (v32 == 0)
 237                         goto badvalue32;
 238                 td->td_rowsperstrip = v32;
 239                 if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
 240                         td->td_tilelength = v32;
 241                         td->td_tilewidth = td->td_imagewidth;
 242                 }
 243                 break;
 244         case TIFFTAG_MINSAMPLEVALUE:
 245                 td->td_minsamplevalue = (uint16) va_arg(ap, int);
 246                 break;
 247         case TIFFTAG_MAXSAMPLEVALUE:
 248                 td->td_maxsamplevalue = (uint16) va_arg(ap, int);
 249                 break;
 250         case TIFFTAG_SMINSAMPLEVALUE:
 251                 td->td_sminsamplevalue = (double) va_arg(ap, dblparam_t);
 252                 break;
 253         case TIFFTAG_SMAXSAMPLEVALUE:
 254                 td->td_smaxsamplevalue = (double) va_arg(ap, dblparam_t);
 255                 break;
 256         case TIFFTAG_XRESOLUTION:
 257                 td->td_xresolution = (float) va_arg(ap, dblparam_t);
 258                 break;
 259         case TIFFTAG_YRESOLUTION:
 260                 td->td_yresolution = (float) va_arg(ap, dblparam_t);
 261                 break;
 262         case TIFFTAG_PLANARCONFIG:
 263                 v = va_arg(ap, int);
 264                 if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE)
 265                         goto badvalue;
 266                 td->td_planarconfig = (uint16) v;
 267                 break;
 268         case TIFFTAG_PAGENAME:
 269                 _TIFFsetString(&td->td_pagename, va_arg(ap, char*));
 270                 break;
 271         case TIFFTAG_XPOSITION:
 272                 td->td_xposition = (float) va_arg(ap, dblparam_t);
 273                 break;
 274         case TIFFTAG_YPOSITION:
 275                 td->td_yposition = (float) va_arg(ap, dblparam_t);
 276                 break;
 277         case TIFFTAG_RESOLUTIONUNIT:
 278                 v = va_arg(ap, int);
 279                 if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v)
 280                         goto badvalue;
 281                 td->td_resolutionunit = (uint16) v;
 282                 break;
 283         case TIFFTAG_PAGENUMBER:
 284                 td->td_pagenumber[0] = (uint16) va_arg(ap, int);
 285                 td->td_pagenumber[1] = (uint16) va_arg(ap, int);
 286                 break;
 287         case TIFFTAG_HALFTONEHINTS:
 288                 td->td_halftonehints[0] = (uint16) va_arg(ap, int);
 289                 td->td_halftonehints[1] = (uint16) va_arg(ap, int);
 290                 break;
 291         case TIFFTAG_COLORMAP:
 292                 v32 = (uint32)(1L<<td->td_bitspersample);
 293                 _TIFFsetShortArray(&td->td_colormap[0], va_arg(ap, uint16*), v32);
 294                 _TIFFsetShortArray(&td->td_colormap[1], va_arg(ap, uint16*), v32);
 295                 _TIFFsetShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v32);
 296                 break;
 297         case TIFFTAG_EXTRASAMPLES:
 298                 if (!setExtraSamples(td, ap, &v))
 299                         goto badvalue;
 300                 break;
 301         case TIFFTAG_MATTEING:
 302                 td->td_extrasamples = (uint16) (va_arg(ap, int) != 0);
 303                 if (td->td_extrasamples) {
 304                         uint16 sv = EXTRASAMPLE_ASSOCALPHA;
 305                         _TIFFsetShortArray(&td->td_sampleinfo, &sv, 1);
 306                 }
 307                 break;
 308         case TIFFTAG_TILEWIDTH:
 309                 v32 = va_arg(ap, uint32);
 310                 if (v32 % 16) {
 311                         if (tif->tif_mode != O_RDONLY)
 312                                 goto badvalue32;
 313                         TIFFWarning(tif->tif_name,
 314                             "Nonstandard tile width %d, convert file", v32);
 315                 }
 316                 td->td_tilewidth = v32;
 317                 tif->tif_flags |= TIFF_ISTILED;
 318                 break;
 319         case TIFFTAG_TILELENGTH:
 320                 v32 = va_arg(ap, uint32);
 321                 if (v32 % 16) {
 322                         if (tif->tif_mode != O_RDONLY)
 323                                 goto badvalue32;
 324                         TIFFWarning(tif->tif_name,
 325                             "Nonstandard tile length %d, convert file", v32);
 326                 }
 327                 td->td_tilelength = v32;
 328                 tif->tif_flags |= TIFF_ISTILED;
 329                 break;
 330         case TIFFTAG_TILEDEPTH:
 331                 v32 = va_arg(ap, uint32);
 332                 if (v32 == 0)
 333                         goto badvalue32;
 334                 td->td_tiledepth = v32;
 335                 break;
 336         case TIFFTAG_DATATYPE:
 337                 v = va_arg(ap, int);
 338                 switch (v) {
 339                 case DATATYPE_VOID:     v = SAMPLEFORMAT_VOID;  break;
 340                 case DATATYPE_INT:      v = SAMPLEFORMAT_INT;   break;
 341                 case DATATYPE_UINT:     v = SAMPLEFORMAT_UINT;  break;
 342                 case DATATYPE_IEEEFP:   v = SAMPLEFORMAT_IEEEFP;break;
 343                 default:                goto badvalue;
 344                 }
 345                 td->td_sampleformat = (uint16) v;
 346                 break;
 347         case TIFFTAG_SAMPLEFORMAT:
 348                 v = va_arg(ap, int);
 349                 if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_COMPLEXIEEEFP < v)
 350                         goto badvalue;
 351                 td->td_sampleformat = (uint16) v;
 352
 353                 /*  Try to fix up the SWAB function for complex data. */
 354                 if( td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT
 355                     && td->td_bitspersample == 32
 356                     && tif->tif_postdecode == _TIFFSwab32BitData )
 357                     tif->tif_postdecode = _TIFFSwab16BitData;
 358                 else if( (td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT
 359                           || td->td_sampleformat == SAMPLEFORMAT_COMPLEXIEEEFP)
 360                          && td->td_bitspersample == 64
 361                          && tif->tif_postdecode == _TIFFSwab64BitData )
 362                     tif->tif_postdecode = _TIFFSwab32BitData;
 363                 else if( td->td_sampleformat == SAMPLEFORMAT_COMPLEXIEEEFP
 364                          && td->td_bitspersample == 128
 365                          && tif->tif_postdecode == NULL )
 366                     tif->tif_postdecode = _TIFFSwab64BitData;
 367                 break;
 368         case TIFFTAG_IMAGEDEPTH:
 369                 td->td_imagedepth = va_arg(ap, uint32);
 370                 break;
 371         case TIFFTAG_STONITS:
 372                 d = va_arg(ap, dblparam_t);
 373                 if (d <= 0.)
 374                         goto badvaluedbl;
 375                 td->td_stonits = d;
 376                 break;
 377         /* Begin Pixar Tags */
 378         case TIFFTAG_PIXAR_IMAGEFULLWIDTH:
 379                 td->td_imagefullwidth = va_arg(ap, uint32);
 380                 break;
 381         case TIFFTAG_PIXAR_IMAGEFULLLENGTH:
 382                 td->td_imagefulllength = va_arg(ap, uint32);
 383                 break;
 384         case TIFFTAG_PIXAR_TEXTUREFORMAT:
 385                 _TIFFsetString(&td->td_textureformat, va_arg(ap, char*));
 386                 break;
 387         case TIFFTAG_PIXAR_WRAPMODES:
 388                 _TIFFsetString(&td->td_wrapmodes, va_arg(ap, char*));
 389                 break;
 390         case TIFFTAG_PIXAR_FOVCOT:
 391                 td->td_fovcot = (float) va_arg(ap, dblparam_t);
 392                 break;
 393         case TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN:
 394                 _TIFFsetFloatArray(&td->td_matrixWorldToScreen,
 395                         va_arg(ap, float*), 16);
 396                 break;
 397         case TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA:
 398                 _TIFFsetFloatArray(&td->td_matrixWorldToCamera,
 399                         va_arg(ap, float*), 16);
 400                 break;
 401         /* End Pixar Tags */
 402
 403         case TIFFTAG_SUBIFD:
 404                 if ((tif->tif_flags & TIFF_INSUBIFD) == 0) {
 405                         td->td_nsubifd = (uint16) va_arg(ap, int);
 406                         _TIFFsetLongArray(&td->td_subifd, va_arg(ap, uint32*),
 407                             (long) td->td_nsubifd);
 408                 } else {
 409                         TIFFError(module, "%s: Sorry, cannot nest SubIFDs",
 410                                   tif->tif_name);
 411                         status = 0;
 412                 }
 413                 break;
 414         case TIFFTAG_YCBCRCOEFFICIENTS:
 415                 _TIFFsetFloatArray(&td->td_ycbcrcoeffs, va_arg(ap, float*), 3);
 416                 break;
 417         case TIFFTAG_YCBCRPOSITIONING:
 418                 td->td_ycbcrpositioning = (uint16) va_arg(ap, int);
 419                 break;
 420         case TIFFTAG_YCBCRSUBSAMPLING:
 421                 td->td_ycbcrsubsampling[0] = (uint16) va_arg(ap, int);
 422                 td->td_ycbcrsubsampling[1] = (uint16) va_arg(ap, int);
 423                 break;
 424         case TIFFTAG_WHITEPOINT:
 425                 _TIFFsetFloatArray(&td->td_whitepoint, va_arg(ap, float*), 2);
 426                 break;
 427         case TIFFTAG_PRIMARYCHROMATICITIES:
 428                 _TIFFsetFloatArray(&td->td_primarychromas, va_arg(ap, float*), 6);
 429                 break;
 430         case TIFFTAG_TRANSFERFUNCTION:
 431                 v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1;
 432                 for (i = 0; i < v; i++)
 433                         _TIFFsetShortArray(&td->td_transferfunction[i],
 434                             va_arg(ap, uint16*), 1L<<td->td_bitspersample);
 435                 break;
 436         case TIFFTAG_REFERENCEBLACKWHITE:
 437                 /* XXX should check for null range */
 438                 _TIFFsetFloatArray(&td->td_refblackwhite, va_arg(ap, float*), 6);
 439                 break;
 440         case TIFFTAG_INKSET:
 441                 td->td_inkset = (uint16) va_arg(ap, int);
 442                 break;
 443         case TIFFTAG_DOTRANGE:
 444                 /* XXX should check for null range */
 445                 td->td_dotrange[0] = (uint16) va_arg(ap, int);
 446                 td->td_dotrange[1] = (uint16) va_arg(ap, int);
 447                 break;
 448         case TIFFTAG_INKNAMES:
 449                 i = va_arg(ap, int);
 450                 s = va_arg(ap, char*);
 451                 i = checkInkNamesString(tif, i, s);
 452                 status = i > 0;
 453                 if( i > 0 ) {
 454                         _TIFFsetNString(&td->td_inknames, s, i);
 455                         td->td_inknameslen = i;
 456                 }
 457                 break;
 458         case TIFFTAG_NUMBEROFINKS:
 459                 td->td_ninks = (uint16) va_arg(ap, int);
 460                 break;
 461         case TIFFTAG_TARGETPRINTER:
 462                 _TIFFsetString(&td->td_targetprinter, va_arg(ap, char*));
 463                 break;
 464         case TIFFTAG_ICCPROFILE:
 465                 td->td_profileLength = (uint32) va_arg(ap, uint32);
 466                 _TIFFsetByteArray(&td->td_profileData, va_arg(ap, void*),
 467                     td->td_profileLength);
 468                 break;
 469         case TIFFTAG_PHOTOSHOP:
 470                 td->td_photoshopLength = (uint32) va_arg(ap, uint32);
 471                 _TIFFsetByteArray (&td->td_photoshopData, va_arg(ap, void*),
 472                         td->td_photoshopLength);
 473                 break;
 474         case TIFFTAG_RICHTIFFIPTC:
 475                 td->td_richtiffiptcLength = (uint32) va_arg(ap, uint32);
 476                 _TIFFsetLongArray ((uint32**)&td->td_richtiffiptcData,
 477                                    va_arg(ap, uint32*),
 478                                    td->td_richtiffiptcLength);
 479                 break;
 480         case TIFFTAG_XMLPACKET:
 481                 td->td_xmlpacketLength = (uint32) va_arg(ap, uint32);
 482                 _TIFFsetByteArray(&td->td_xmlpacketData, va_arg(ap, void*),
 483                     td->td_xmlpacketLength);
 484                 break;
 485         default: {
 486             const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
 487             TIFFTagValue *tv;
 488             int           tv_size, iCustom;
 489
 490             /*
 491              * This can happen if multiple images are open with
 492              * different codecs which have private tags.  The
 493              * global tag information table may then have tags
 494              * that are valid for one file but not the other.
 495              * If the client tries to set a tag that is not valid
 496              * for the image's codec then we'll arrive here.  This
 497              * happens, for example, when tiffcp is used to convert
 498              * between compression schemes and codec-specific tags
 499              * are blindly copied.
 500              */
 501             if( fip == NULL || fip->field_bit != FIELD_CUSTOM )
 502             {
 503                 TIFFError(module,
 504                     "%s: Invalid %stag \"%s\" (not supported by codec)",
 505                     tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "",
 506                     _TIFFFieldWithTag(tif, tag)->field_name);
 507                 status = 0;
 508                 break;
 509             }
 510
 511             /*
 512              * Find the existing entry for this custom value.
 513              */
 514             tv = NULL;
 515             for( iCustom = 0; iCustom < td->td_customValueCount; iCustom++ )
 516             {
 517                 if( td->td_customValues[iCustom].info == fip )
 518                 {
 519                     tv = td->td_customValues + iCustom;
 520                     if( tv->value != NULL )
 521                         _TIFFfree( tv->value );
 522                     break;
 523                 }
 524             }
 525
 526             /*
 527              * Grow the custom list if the entry was not found.
 528              */
 529             if( tv == NULL )
 530             {
 531                 TIFFTagValue    *new_customValues;
 532
 533                 td->td_customValueCount++;
 534                 new_customValues = (TIFFTagValue *)
 535                         _TIFFrealloc(td->td_customValues,
 536                                      sizeof(TIFFTagValue) * td->td_customValueCount);
 537                 if (!new_customValues) {
 538                         TIFFError(module,
 539                 "%s: Failed to allocate space for list of custom values",
 540                                   tif->tif_name);
 541                         status = 0;
 542                         goto end;
 543                 }
 544
 545                 td->td_customValues = new_customValues;
 546
 547                 tv = td->td_customValues + (td->td_customValueCount-1);
 548                 tv->info = fip;
 549                 tv->value = NULL;
 550                 tv->count = 0;
 551             }
 552
 553             /*
 554              * Set custom value ... save a copy of the custom tag value.
 555              */
 556             tv_size = TIFFDataWidth(fip->field_type);
 557             if( fip->field_passcount )
 558                 tv->count = (int) va_arg(ap, int);
 559             else
 560                 tv->count = 1;
 561             if( fip->field_passcount )
 562             {
 563                 tv->value = _TIFFmalloc(tv_size * tv->count);
 564                 if ( !tv->value ) {
 565                         va_end(ap);
 566                         return 0;
 567                 }
 568                 _TIFFmemcpy( tv->value, (void *) va_arg(ap,void*),
 569                              tv->count * tv_size );
 570             }
 571             else if( fip->field_type == TIFF_ASCII )
 572             {
 573                 const char *value = (const char *) va_arg(ap,const char *);
 574                 tv->count = strlen(value)+1;
 575                 tv->value = _TIFFmalloc(tv->count);
 576                 if ( !tv->value ) {
 577                         va_end(ap);
 578                         return 0;
 579                 }
 580                 strcpy( tv->value, value );
 581             }
 582             else
 583             {
 584                 /* not supporting "pass by value" types yet */
 585                 TIFFWarning(module, " ... pass by value not implemented.");
 586
 587                 tv->value = _TIFFmalloc(tv_size * tv->count);
 588                 if ( !tv->value ) {
 589                         va_end(ap);
 590                         return 0;
 591                 }
 592                 _TIFFmemset( tv->value, 0, tv->count * tv_size );
 593                 status = 0;
 594             }
 595           }
 596         }
 597         if (status) {
 598             TIFFSetFieldBit(tif, _TIFFFieldWithTag(tif, tag)->field_bit);
 599             tif->tif_flags |= TIFF_DIRTYDIRECT;
 600         }
 601
 602 end:
 603         va_end(ap);
 604         return (status);
 605 badvalue:
 606         TIFFError(module, "%.1000s: Bad value %d for \"%s\"",
 607                   tif->tif_name, v, _TIFFFieldWithTag(tif, tag)->field_name);
 608         va_end(ap);
 609         return (0);
 610 badvalue32:
 611         TIFFError(module, "%.1000s: Bad value %ld for \"%s\"",
 612                    tif->tif_name, v32, _TIFFFieldWithTag(tif, tag)->field_name);
 613         va_end(ap);
 614         return (0);
 615 badvaluedbl:
 616         TIFFError(module, "%.1000s: Bad value %f for \"%s\"",
 617                   tif->tif_name, d, _TIFFFieldWithTag(tif, tag)->field_name);
 618         va_end(ap);
 619         return (0);
 620 }
 621
 622 /*
 623  * Return 1/0 according to whether or not
 624  * it is permissible to set the tag's value.
 625  * Note that we allow ImageLength to be changed
 626  * so that we can append and extend to images.
 627  * Any other tag may not be altered once writing
 628  * has commenced, unless its value has no effect
 629  * on the format of the data that is written.
 630  */
 631 static int
 632 OkToChangeTag(TIFF* tif, ttag_t tag)
 633 {
 634         const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
 635         if (!fip) {                     /* unknown tag */
 636                 TIFFError("TIFFSetField", "%s: Unknown %stag %u",
 637                     tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", tag);
 638                 return (0);
 639         }
 640         if (tag != TIFFTAG_IMAGELENGTH && (tif->tif_flags & TIFF_BEENWRITING) &&
 641             !fip->field_oktochange) {
 642                 /*
 643                  * Consult info table to see if tag can be changed
 644                  * after we've started writing.  We only allow changes
 645                  * to those tags that don't/shouldn't affect the
 646                  * compression and/or format of the data.
 647                  */
 648                 TIFFError("TIFFSetField",
 649                     "%s: Cannot modify tag \"%s\" while writing",
 650                     tif->tif_name, fip->field_name);
 651                 return (0);
 652         }
 653         return (1);
 654 }
 655
 656 /*
 657  * Record the value of a field in the
 658  * internal directory structure.  The
 659  * field will be written to the file
 660  * when/if the directory structure is
 661  * updated.
 662  */
 663 int
 664 TIFFSetField(TIFF* tif, ttag_t tag, ...)
 665 {
 666         va_list ap;
 667         int status;
 668
 669         va_start(ap, tag);
 670         status = TIFFVSetField(tif, tag, ap);
 671         va_end(ap);
 672         return (status);
 673 }
 674
 675 /*
 676  * Like TIFFSetField, but taking a varargs
 677  * parameter list.  This routine is useful
 678  * for building higher-level interfaces on
 679  * top of the library.
 680  */
 681 int
 682 TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
 683 {
 684         return OkToChangeTag(tif, tag) ?
 685             (*tif->tif_tagmethods.vsetfield)(tif, tag, ap) : 0;
 686 }
 687
 688 static int
 689 _TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
 690 {
 691     TIFFDirectory* td = &tif->tif_dir;
 692     int            ret_val = 1;
 693
 694     switch (tag) {
 695         case TIFFTAG_SUBFILETYPE:
 696             *va_arg(ap, uint32*) = td->td_subfiletype;
 697             break;
 698         case TIFFTAG_IMAGEWIDTH:
 699             *va_arg(ap, uint32*) = td->td_imagewidth;
 700             break;
 701         case TIFFTAG_IMAGELENGTH:
 702             *va_arg(ap, uint32*) = td->td_imagelength;
 703             break;
 704         case TIFFTAG_BITSPERSAMPLE:
 705             *va_arg(ap, uint16*) = td->td_bitspersample;
 706             break;
 707         case TIFFTAG_COMPRESSION:
 708             *va_arg(ap, uint16*) = td->td_compression;
 709             break;
 710         case TIFFTAG_PHOTOMETRIC:
 711             *va_arg(ap, uint16*) = td->td_photometric;
 712             break;
 713         case TIFFTAG_THRESHHOLDING:
 714             *va_arg(ap, uint16*) = td->td_threshholding;
 715             break;
 716         case TIFFTAG_FILLORDER:
 717             *va_arg(ap, uint16*) = td->td_fillorder;
 718             break;
 719         case TIFFTAG_DOCUMENTNAME:
 720             *va_arg(ap, char**) = td->td_documentname;
 721             break;
 722         case TIFFTAG_ARTIST:
 723             *va_arg(ap, char**) = td->td_artist;
 724             break;
 725         case TIFFTAG_DATETIME:
 726             *va_arg(ap, char**) = td->td_datetime;
 727             break;
 728         case TIFFTAG_HOSTCOMPUTER:
 729             *va_arg(ap, char**) = td->td_hostcomputer;
 730             break;
 731         case TIFFTAG_IMAGEDESCRIPTION:
 732             *va_arg(ap, char**) = td->td_imagedescription;
 733             break;
 734         case TIFFTAG_MAKE:
 735             *va_arg(ap, char**) = td->td_make;
 736             break;
 737         case TIFFTAG_MODEL:
 738             *va_arg(ap, char**) = td->td_model;
 739             break;
 740         case TIFFTAG_COPYRIGHT:
 741             *va_arg(ap, char**) = td->td_copyright;
 742             break;
 743         case TIFFTAG_ORIENTATION:
 744             *va_arg(ap, uint16*) = td->td_orientation;
 745             break;
 746         case TIFFTAG_SAMPLESPERPIXEL:
 747             *va_arg(ap, uint16*) = td->td_samplesperpixel;
 748             break;
 749         case TIFFTAG_ROWSPERSTRIP:
 750             *va_arg(ap, uint32*) = td->td_rowsperstrip;
 751             break;
 752         case TIFFTAG_MINSAMPLEVALUE:
 753             *va_arg(ap, uint16*) = td->td_minsamplevalue;
 754             break;
 755         case TIFFTAG_MAXSAMPLEVALUE:
 756             *va_arg(ap, uint16*) = td->td_maxsamplevalue;
 757             break;
 758         case TIFFTAG_SMINSAMPLEVALUE:
 759             *va_arg(ap, double*) = td->td_sminsamplevalue;
 760             break;
 761         case TIFFTAG_SMAXSAMPLEVALUE:
 762             *va_arg(ap, double*) = td->td_smaxsamplevalue;
 763             break;
 764         case TIFFTAG_XRESOLUTION:
 765             *va_arg(ap, float*) = td->td_xresolution;
 766             break;
 767         case TIFFTAG_YRESOLUTION:
 768             *va_arg(ap, float*) = td->td_yresolution;
 769             break;
 770         case TIFFTAG_PLANARCONFIG:
 771             *va_arg(ap, uint16*) = td->td_planarconfig;
 772             break;
 773         case TIFFTAG_XPOSITION:
 774             *va_arg(ap, float*) = td->td_xposition;
 775             break;
 776         case TIFFTAG_YPOSITION:
 777             *va_arg(ap, float*) = td->td_yposition;
 778             break;
 779         case TIFFTAG_PAGENAME:
 780             *va_arg(ap, char**) = td->td_pagename;
 781             break;
 782         case TIFFTAG_RESOLUTIONUNIT:
 783             *va_arg(ap, uint16*) = td->td_resolutionunit;
 784             break;
 785         case TIFFTAG_PAGENUMBER:
 786             *va_arg(ap, uint16*) = td->td_pagenumber[0];
 787             *va_arg(ap, uint16*) = td->td_pagenumber[1];
 788             break;
 789         case TIFFTAG_HALFTONEHINTS:
 790             *va_arg(ap, uint16*) = td->td_halftonehints[0];
 791             *va_arg(ap, uint16*) = td->td_halftonehints[1];
 792             break;
 793         case TIFFTAG_COLORMAP:
 794             *va_arg(ap, uint16**) = td->td_colormap[0];
 795             *va_arg(ap, uint16**) = td->td_colormap[1];
 796             *va_arg(ap, uint16**) = td->td_colormap[2];
 797             break;
 798         case TIFFTAG_STRIPOFFSETS:
 799         case TIFFTAG_TILEOFFSETS:
 800             *va_arg(ap, uint32**) = td->td_stripoffset;
 801             break;
 802         case TIFFTAG_STRIPBYTECOUNTS:
 803         case TIFFTAG_TILEBYTECOUNTS:
 804             *va_arg(ap, uint32**) = td->td_stripbytecount;
 805             break;
 806         case TIFFTAG_MATTEING:
 807             *va_arg(ap, uint16*) =
 808                 (td->td_extrasamples == 1 &&
 809                  td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
 810             break;
 811         case TIFFTAG_EXTRASAMPLES:
 812             *va_arg(ap, uint16*) = td->td_extrasamples;
 813             *va_arg(ap, uint16**) = td->td_sampleinfo;
 814             break;
 815         case TIFFTAG_TILEWIDTH:
 816             *va_arg(ap, uint32*) = td->td_tilewidth;
 817             break;
 818         case TIFFTAG_TILELENGTH:
 819             *va_arg(ap, uint32*) = td->td_tilelength;
 820             break;
 821         case TIFFTAG_TILEDEPTH:
 822             *va_arg(ap, uint32*) = td->td_tiledepth;
 823             break;
 824         case TIFFTAG_DATATYPE:
 825             switch (td->td_sampleformat) {
 826                 case SAMPLEFORMAT_UINT:
 827                     *va_arg(ap, uint16*) = DATATYPE_UINT;
 828                     break;
 829                 case SAMPLEFORMAT_INT:
 830                     *va_arg(ap, uint16*) = DATATYPE_INT;
 831                     break;
 832                 case SAMPLEFORMAT_IEEEFP:
 833                     *va_arg(ap, uint16*) = DATATYPE_IEEEFP;
 834                     break;
 835                 case SAMPLEFORMAT_VOID:
 836                     *va_arg(ap, uint16*) = DATATYPE_VOID;
 837                     break;
 838             }
 839             break;
 840         case TIFFTAG_SAMPLEFORMAT:
 841             *va_arg(ap, uint16*) = td->td_sampleformat;
 842             break;
 843         case TIFFTAG_IMAGEDEPTH:
 844             *va_arg(ap, uint32*) = td->td_imagedepth;
 845             break;
 846         case TIFFTAG_STONITS:
 847             *va_arg(ap, double*) = td->td_stonits;
 848             break;
 849         case TIFFTAG_SUBIFD:
 850             *va_arg(ap, uint16*) = td->td_nsubifd;
 851             *va_arg(ap, uint32**) = td->td_subifd;
 852             break;
 853         case TIFFTAG_YCBCRCOEFFICIENTS:
 854             *va_arg(ap, float**) = td->td_ycbcrcoeffs;
 855             break;
 856         case TIFFTAG_YCBCRPOSITIONING:
 857             *va_arg(ap, uint16*) = td->td_ycbcrpositioning;
 858             break;
 859         case TIFFTAG_YCBCRSUBSAMPLING:
 860             *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[0];
 861             *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[1];
 862             break;
 863         case TIFFTAG_WHITEPOINT:
 864             *va_arg(ap, float**) = td->td_whitepoint;
 865             break;
 866         case TIFFTAG_PRIMARYCHROMATICITIES:
 867             *va_arg(ap, float**) = td->td_primarychromas;
 868             break;
 869         case TIFFTAG_TRANSFERFUNCTION:
 870             *va_arg(ap, uint16**) = td->td_transferfunction[0];
 871             if (td->td_samplesperpixel - td->td_extrasamples > 1) {
 872                 *va_arg(ap, uint16**) = td->td_transferfunction[1];
 873                 *va_arg(ap, uint16**) = td->td_transferfunction[2];
 874             }
 875             break;
 876         case TIFFTAG_REFERENCEBLACKWHITE:
 877             *va_arg(ap, float**) = td->td_refblackwhite;
 878             break;
 879         case TIFFTAG_INKSET:
 880             *va_arg(ap, uint16*) = td->td_inkset;
 881             break;
 882         case TIFFTAG_DOTRANGE:
 883             *va_arg(ap, uint16*) = td->td_dotrange[0];
 884             *va_arg(ap, uint16*) = td->td_dotrange[1];
 885             break;
 886         case TIFFTAG_INKNAMES:
 887             *va_arg(ap, char**) = td->td_inknames;
 888             break;
 889         case TIFFTAG_NUMBEROFINKS:
 890             *va_arg(ap, uint16*) = td->td_ninks;
 891             break;
 892         case TIFFTAG_TARGETPRINTER:
 893             *va_arg(ap, char**) = td->td_targetprinter;
 894             break;
 895         case TIFFTAG_ICCPROFILE:
 896             *va_arg(ap, uint32*) = td->td_profileLength;
 897             *va_arg(ap, void**) = td->td_profileData;
 898             break;
 899         case TIFFTAG_PHOTOSHOP:
 900             *va_arg(ap, uint32*) = td->td_photoshopLength;
 901             *va_arg(ap, void**) = td->td_photoshopData;
 902             break;
 903         case TIFFTAG_RICHTIFFIPTC:
 904             *va_arg(ap, uint32*) = td->td_richtiffiptcLength;
 905             *va_arg(ap, void**) = td->td_richtiffiptcData;
 906             break;
 907         case TIFFTAG_XMLPACKET:
 908             *va_arg(ap, uint32*) = td->td_xmlpacketLength;
 909             *va_arg(ap, void**) = td->td_xmlpacketData;
 910             break;
 911             /* Begin Pixar Tags */
 912         case TIFFTAG_PIXAR_IMAGEFULLWIDTH:
 913             *va_arg(ap, uint32*) = td->td_imagefullwidth;
 914             break;
 915         case TIFFTAG_PIXAR_IMAGEFULLLENGTH:
 916             *va_arg(ap, uint32*) = td->td_imagefulllength;
 917             break;
 918         case TIFFTAG_PIXAR_TEXTUREFORMAT:
 919             *va_arg(ap, char**) = td->td_textureformat;
 920             break;
 921         case TIFFTAG_PIXAR_WRAPMODES:
 922             *va_arg(ap, char**) = td->td_wrapmodes;
 923             break;
 924         case TIFFTAG_PIXAR_FOVCOT:
 925             *va_arg(ap, float*) = td->td_fovcot;
 926             break;
 927         case TIFFTAG_PIXAR_MATRIX_WORLDTOSCREEN:
 928             *va_arg(ap, float**) = td->td_matrixWorldToScreen;
 929             break;
 930         case TIFFTAG_PIXAR_MATRIX_WORLDTOCAMERA:
 931             *va_arg(ap, float**) = td->td_matrixWorldToCamera;
 932             break;
 933             /* End Pixar Tags */
 934
 935         default:
 936         {
 937             const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
 938             int           i;
 939
 940             /*
 941              * This can happen if multiple images are open with
 942              * different codecs which have private tags.  The
 943              * global tag information table may then have tags
 944              * that are valid for one file but not the other.
 945              * If the client tries to get a tag that is not valid
 946              * for the image's codec then we'll arrive here.
 947              */
 948             if( fip == NULL || fip->field_bit != FIELD_CUSTOM )
 949             {
 950                 TIFFError("_TIFFVGetField",
 951                           "%s: Invalid %stag \"%s\" (not supported by codec)",
 952                           tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "",
 953                           _TIFFFieldWithTag(tif, tag)->field_name);
 954                 ret_val = 0;
 955                 break;
 956             }
 957
 958             /*
 959             ** Do we have a custom value?
 960             */
 961             ret_val = 0;
 962             for( i = 0; i < td->td_customValueCount; i++ )
 963             {
 964                 TIFFTagValue *tv = td->td_customValues + i;
 965
 966                 if( tv->info->field_tag != tag )
 967                     continue;
 968
 969                 if( fip->field_passcount )
 970                 {
 971                     *va_arg(ap, u_short *) = (u_short) tv->count;
 972                     *va_arg(ap, void **) = tv->value;
 973                     ret_val = 1;
 974                     break;
 975                 }
 976                 else if( fip->field_type == TIFF_ASCII )
 977                 {
 978                     *va_arg(ap, void **) = tv->value;
 979                     ret_val = 1;
 980                     break;
 981                 }
 982                 else
 983                 {
 984                     printf( "TIFFVGetField ... pass by value not imp.\n" );
 985                     break;
 986                 }
 987             }
 988         }
 989     }
 990     return( ret_val );
 991 }
 992
 993 /*
 994  * Return the value of a field in the
 995  * internal directory structure.
 996  */
 997 int
 998 TIFFGetField(TIFF* tif, ttag_t tag, ...)
 999 {
1000         int status;
1001         va_list ap;
1002
1003         va_start(ap, tag);
1004         status = TIFFVGetField(tif, tag, ap);
1005         va_end(ap);
1006         return (status);
1007 }
1008
1009 /*
1010  * Like TIFFGetField, but taking a varargs
1011  * parameter list.  This routine is useful
1012  * for building higher-level interfaces on
1013  * top of the library.
1014  */
1015 int
1016 TIFFVGetField(TIFF* tif, ttag_t tag, va_list ap)
1017 {
1018         const TIFFFieldInfo* fip = _TIFFFindFieldInfo(tif, tag, TIFF_ANY);
1019         return (fip && (isPseudoTag(tag) || TIFFFieldSet(tif, fip->field_bit)) ?
1020             (*tif->tif_tagmethods.vgetfield)(tif, tag, ap) : 0);
1021 }
1022
1023 #define CleanupField(member) {          \
1024     if (td->member) {                   \
1025         _TIFFfree(td->member);          \
1026         td->member = 0;                 \
1027     }                                   \
1028 }
1029
1030 /*
1031  * Release storage associated with a directory.
1032  */
1033 void
1034 TIFFFreeDirectory(TIFF* tif)
1035 {
1036     TIFFDirectory *td = &tif->tif_dir;
1037     int            i;
1038
1039     CleanupField(td_colormap[0]);
1040     CleanupField(td_colormap[1]);
1041     CleanupField(td_colormap[2]);
1042     CleanupField(td_documentname);
1043     CleanupField(td_artist);
1044     CleanupField(td_datetime);
1045     CleanupField(td_hostcomputer);
1046     CleanupField(td_imagedescription);
1047     CleanupField(td_make);
1048     CleanupField(td_model);
1049     CleanupField(td_copyright);
1050     CleanupField(td_pagename);
1051     CleanupField(td_sampleinfo);
1052     CleanupField(td_subifd);
1053     CleanupField(td_ycbcrcoeffs);
1054     CleanupField(td_inknames);
1055     CleanupField(td_targetprinter);
1056     CleanupField(td_whitepoint);
1057     CleanupField(td_primarychromas);
1058     CleanupField(td_refblackwhite);
1059     CleanupField(td_transferfunction[0]);
1060     CleanupField(td_transferfunction[1]);
1061     CleanupField(td_transferfunction[2]);
1062     CleanupField(td_profileData);
1063     CleanupField(td_photoshopData);
1064     CleanupField(td_richtiffiptcData);
1065     CleanupField(td_xmlpacketData);
1066     CleanupField(td_stripoffset);
1067     CleanupField(td_stripbytecount);
1068     /* Begin Pixar Tags */
1069     CleanupField(td_textureformat);
1070     CleanupField(td_wrapmodes);
1071     CleanupField(td_matrixWorldToScreen);
1072     CleanupField(td_matrixWorldToCamera);
1073     /* End Pixar Tags */
1074
1075     /* Cleanup custom tag values */
1076     for( i = 0; i < td->td_customValueCount; i++ )
1077         _TIFFfree( td->td_customValues[i].value );
1078
1079     if( td->td_customValues != NULL )
1080         _TIFFfree( td->td_customValues );
1081
1082 }
1083 #undef CleanupField
1084
1085 /*
1086  * Client Tag extension support (from Niles Ritter).
1087  */
1088 static TIFFExtendProc _TIFFextender = (TIFFExtendProc) NULL;
1089
1090 TIFFExtendProc
1091 TIFFSetTagExtender(TIFFExtendProc extender)
1092 {
1093         TIFFExtendProc prev = _TIFFextender;
1094         _TIFFextender = extender;
1095         return (prev);
1096 }
1097
1098 /*
1099  * Setup for a new directory.  Should we automatically call
1100  * TIFFWriteDirectory() if the current one is dirty?
1101  *
1102  * The newly created directory will not exist on the file till
1103  * TIFFWriteDirectory(), TIFFFlush() or TIFFClose() is called.
1104  */
1105 int
1106 TIFFCreateDirectory(TIFF* tif)
1107 {
1108     TIFFDefaultDirectory(tif);
1109     tif->tif_diroff = 0;
1110     tif->tif_nextdiroff = 0;
1111     tif->tif_curoff = 0;
1112     tif->tif_row = (uint32) -1;
1113     tif->tif_curstrip = (tstrip_t) -1;
1114
1115     return 0;
1116 }
1117
1118 /*
1119  * Setup a default directory structure.
1120  */
1121 int
1122 TIFFDefaultDirectory(TIFF* tif)
1123 {
1124         register TIFFDirectory* td = &tif->tif_dir;
1125
1126         _TIFFSetupFieldInfo(tif);
1127         _TIFFmemset(td, 0, sizeof (*td));
1128         td->td_fillorder = FILLORDER_MSB2LSB;
1129         td->td_bitspersample = 1;
1130         td->td_threshholding = THRESHHOLD_BILEVEL;
1131         td->td_orientation = ORIENTATION_TOPLEFT;
1132         td->td_samplesperpixel = 1;
1133         td->td_rowsperstrip = (uint32) -1;
1134         td->td_tilewidth = (uint32) -1;
1135         td->td_tilelength = (uint32) -1;
1136         td->td_tiledepth = 1;
1137         td->td_resolutionunit = RESUNIT_INCH;
1138         td->td_sampleformat = SAMPLEFORMAT_UINT;
1139         td->td_imagedepth = 1;
1140         td->td_ycbcrsubsampling[0] = 2;
1141         td->td_ycbcrsubsampling[1] = 2;
1142         td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
1143         td->td_inkset = INKSET_CMYK;
1144         td->td_ninks = 4;
1145         tif->tif_postdecode = _TIFFNoPostDecode;
1146         tif->tif_tagmethods.vsetfield = _TIFFVSetField;
1147         tif->tif_tagmethods.vgetfield = _TIFFVGetField;
1148         tif->tif_tagmethods.printdir = NULL;
1149         /*
1150          *  Give client code a chance to install their own
1151          *  tag extensions & methods, prior to compression overloads.
1152          */
1153         if (_TIFFextender)
1154                 (*_TIFFextender)(tif);
1155         (void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
1156         /*
1157          * NB: The directory is marked dirty as a result of setting
1158          * up the default compression scheme.  However, this really
1159          * isn't correct -- we want TIFF_DIRTYDIRECT to be set only
1160          * if the user does something.  We could just do the setup
1161          * by hand, but it seems better to use the normal mechanism
1162          * (i.e. TIFFSetField).
1163          */
1164         tif->tif_flags &= ~TIFF_DIRTYDIRECT;
1165
1166         /*
1167          * As per http://bugzilla.remotesensing.org/show_bug.cgi?id=19
1168          * we clear the ISTILED flag when setting up a new directory.
1169          * Should we also be clearing stuff like INSUBIFD?
1170          */
1171         tif->tif_flags &= ~TIFF_ISTILED;
1172
1173         return (1);
1174 }
1175
1176 static int
1177 TIFFAdvanceDirectory(TIFF* tif, uint32* nextdir, toff_t* off)
1178 {
1179     static const char module[] = "TIFFAdvanceDirectory";
1180     uint16 dircount;
1181     if (isMapped(tif))
1182     {
1183         toff_t poff=*nextdir;
1184         if (poff+sizeof(uint16) > tif->tif_size)
1185         {
1186             TIFFError(module, "%s: Error fetching directory count",
1187                       tif->tif_name);
1188             return (0);
1189         }
1190         _TIFFmemcpy(&dircount, tif->tif_base+poff, sizeof (uint16));
1191         if (tif->tif_flags & TIFF_SWAB)
1192             TIFFSwabShort(&dircount);
1193         poff+=sizeof (uint16)+dircount*sizeof (TIFFDirEntry);
1194         if (off != NULL)
1195             *off = poff;
1196         if (((toff_t) (poff+sizeof (uint32))) > tif->tif_size)
1197         {
1198             TIFFError(module, "%s: Error fetching directory link",
1199                       tif->tif_name);
1200             return (0);
1201         }
1202         _TIFFmemcpy(nextdir, tif->tif_base+poff, sizeof (uint32));
1203         if (tif->tif_flags & TIFF_SWAB)
1204             TIFFSwabLong(nextdir);
1205         return (1);
1206     }
1207     else
1208     {
1209         if (!SeekOK(tif, *nextdir) ||
1210             !ReadOK(tif, &dircount, sizeof (uint16))) {
1211             TIFFError(module, "%s: Error fetching directory count",
1212                       tif->tif_name);
1213             return (0);
1214         }
1215         if (tif->tif_flags & TIFF_SWAB)
1216             TIFFSwabShort(&dircount);
1217         if (off != NULL)
1218             *off = TIFFSeekFile(tif,
1219                                 dircount*sizeof (TIFFDirEntry), SEEK_CUR);
1220         else
1221             (void) TIFFSeekFile(tif,
1222                                 dircount*sizeof (TIFFDirEntry), SEEK_CUR);
1223         if (!ReadOK(tif, nextdir, sizeof (uint32))) {
1224             TIFFError(module, "%s: Error fetching directory link",
1225                       tif->tif_name);
1226             return (0);
1227         }
1228         if (tif->tif_flags & TIFF_SWAB)
1229             TIFFSwabLong(nextdir);
1230         return (1);
1231     }
1232 }
1233
1234 /*
1235  * Count the number of directories in a file.
1236  */
1237 tdir_t
1238 TIFFNumberOfDirectories(TIFF* tif)
1239 {
1240     toff_t nextdir = tif->tif_header.tiff_diroff;
1241     tdir_t n = 0;
1242
1243     while (nextdir != 0 && TIFFAdvanceDirectory(tif, &nextdir, NULL))
1244         n++;
1245     return (n);
1246 }
1247
1248 /*
1249  * Set the n-th directory as the current directory.
1250  * NB: Directories are numbered starting at 0.
1251  */
1252 int
1253 TIFFSetDirectory(TIFF* tif, tdir_t dirn)
1254 {
1255         toff_t nextdir;
1256         tdir_t n;
1257
1258         nextdir = tif->tif_header.tiff_diroff;
1259         for (n = dirn; n > 0 && nextdir != 0; n--)
1260                 if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
1261                         return (0);
1262         tif->tif_nextdiroff = nextdir;
1263         /*
1264          * Set curdir to the actual directory index.  The
1265          * -1 is because TIFFReadDirectory will increment
1266          * tif_curdir after successfully reading the directory.
1267          */
1268         tif->tif_curdir = (dirn - n) - 1;
1269         /*
1270          * Reset tif_dirnumber counter nad start new list of seen directories.
1271          * We need this in order to prevent IFD loops.
1272          */
1273         tif->tif_dirnumber = 0;
1274         return (TIFFReadDirectory(tif));
1275 }
1276
1277 /*
1278  * Set the current directory to be the directory
1279  * located at the specified file offset.  This interface
1280  * is used mainly to access directories linked with
1281  * the SubIFD tag (e.g. thumbnail images).
1282  */
1283 int
1284 TIFFSetSubDirectory(TIFF* tif, uint32 diroff)
1285 {
1286         tif->tif_nextdiroff = diroff;
1287         /*
1288          * Reset tif_dirnumber counter nad start new list of seen directories.
1289          * We need this in order to prevent IFD loops.
1290          */
1291         tif->tif_dirnumber = 0;
1292         return (TIFFReadDirectory(tif));
1293 }
1294
1295 /*
1296  * Return file offset of the current directory.
1297  */
1298 uint32
1299 TIFFCurrentDirOffset(TIFF* tif)
1300 {
1301         return (tif->tif_diroff);
1302 }
1303
1304 /*
1305  * Return an indication of whether or not we are
1306  * at the last directory in the file.
1307  */
1308 int
1309 TIFFLastDirectory(TIFF* tif)
1310 {
1311         return (tif->tif_nextdiroff == 0);
1312 }
1313
1314 /*
1315  * Unlink the specified directory from the directory chain.
1316  */
1317 int
1318 TIFFUnlinkDirectory(TIFF* tif, tdir_t dirn)
1319 {
1320         static const char module[] = "TIFFUnlinkDirectory";
1321         toff_t nextdir;
1322         toff_t off;
1323         tdir_t n;
1324
1325         if (tif->tif_mode == O_RDONLY) {
1326                 TIFFError(module, "Can not unlink directory in read-only file");
1327                 return (0);
1328         }
1329         /*
1330          * Go to the directory before the one we want
1331          * to unlink and nab the offset of the link
1332          * field we'll need to patch.
1333          */
1334         nextdir = tif->tif_header.tiff_diroff;
1335         off = sizeof (uint16) + sizeof (uint16);
1336         for (n = dirn-1; n > 0; n--) {
1337                 if (nextdir == 0) {
1338                         TIFFError(module, "Directory %d does not exist", dirn);
1339                         return (0);
1340                 }
1341                 if (!TIFFAdvanceDirectory(tif, &nextdir, &off))
1342                         return (0);
1343         }
1344         /*
1345          * Advance to the directory to be unlinked and fetch
1346          * the offset of the directory that follows.
1347          */
1348         if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
1349                 return (0);
1350         /*
1351          * Go back and patch the link field of the preceding
1352          * directory to point to the offset of the directory
1353          * that follows.
1354          */
1355         (void) TIFFSeekFile(tif, off, SEEK_SET);
1356         if (tif->tif_flags & TIFF_SWAB)
1357                 TIFFSwabLong(&nextdir);
1358         if (!WriteOK(tif, &nextdir, sizeof (uint32))) {
1359                 TIFFError(module, "Error writing directory link");
1360                 return (0);
1361         }
1362         /*
1363          * Leave directory state setup safely.  We don't have
1364          * facilities for doing inserting and removing directories,
1365          * so it's safest to just invalidate everything.  This
1366          * means that the caller can only append to the directory
1367          * chain.
1368          */
1369         (*tif->tif_cleanup)(tif);
1370         if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
1371                 _TIFFfree(tif->tif_rawdata);
1372                 tif->tif_rawdata = NULL;
1373                 tif->tif_rawcc = 0;
1374         }
1375         tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP|TIFF_POSTENCODE);
1376         TIFFFreeDirectory(tif);
1377         TIFFDefaultDirectory(tif);
1378         tif->tif_diroff = 0;                    /* force link on next write */
1379         tif->tif_nextdiroff = 0;                /* next write must be at end */
1380         tif->tif_curoff = 0;
1381         tif->tif_row = (uint32) -1;
1382         tif->tif_curstrip = (tstrip_t) -1;
1383         return (1);
1384 }
1385
1386 /*                      [BFC]
1387  *
1388  * Author: Bruce Cameron <cameron@petris.com>
1389  *
1390  * Set a table of tags that are to be replaced during directory process by the
1391  * 'IGNORE' state - or return TRUE/FALSE for the requested tag such that
1392  * 'ReadDirectory' can use the stored information.
1393  */
1394 int
1395 TIFFReassignTagToIgnore (enum TIFFIgnoreSense task, int TIFFtagID)
1396 {
1397     static int TIFFignoretags [FIELD_LAST];
1398     static int tagcount = 0 ;
1399     int         i;                                      /* Loop index */
1400     int         j;                                      /* Loop index */
1401
1402     switch (task)
1403     {
1404       case TIS_STORE:
1405         if ( tagcount < (FIELD_LAST - 1) )
1406         {
1407             for ( j = 0 ; j < tagcount ; ++j )
1408             {                                   /* Do not add duplicate tag */
1409                 if ( TIFFignoretags [j] == TIFFtagID )
1410                     return (TRUE) ;
1411             }
1412             TIFFignoretags [tagcount++] = TIFFtagID ;
1413             return (TRUE) ;
1414         }
1415         break ;
1416
1417       case TIS_EXTRACT:
1418         for ( i = 0 ; i < tagcount ; ++i )
1419         {
1420             if ( TIFFignoretags [i] == TIFFtagID )
1421                 return (TRUE) ;
1422         }
1423         break;
1424
1425       case TIS_EMPTY:
1426         tagcount = 0 ;                  /* Clear the list */
1427         return (TRUE) ;
1428
1429       default:
1430         break;
1431     }
1432
1433     return (FALSE);
1434 }
1435