src/SDL2/external/tiff-4.0.3/libtiff/tif_dir.c

   1 /* $Id: tif_dir.c,v 1.113 2012-06-14 20:32:53 fwarmerdam Exp $ */
   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                 tmsize_t bytes = (tmsize_t)(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, uint32 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, uint32 n)
  61     { setByteArray((void**) cpp, (void*) cp, n, 1); }
  62 void _TIFFsetShortArray(uint16** wpp, uint16* wp, uint32 n)
  63     { setByteArray((void**) wpp, (void*) wp, n, sizeof (uint16)); }
  64 void _TIFFsetLongArray(uint32** lpp, uint32* lp, uint32 n)
  65     { setByteArray((void**) lpp, (void*) lp, n, sizeof (uint32)); }
  66 void _TIFFsetLong8Array(uint64** lpp, uint64* lp, uint32 n)
  67     { setByteArray((void**) lpp, (void*) lp, n, sizeof (uint64)); }
  68 void _TIFFsetFloatArray(float** fpp, float* fp, uint32 n)
  69     { setByteArray((void**) fpp, (void*) fp, n, sizeof (float)); }
  70 void _TIFFsetDoubleArray(double** dpp, double* dp, uint32 n)
  71     { setByteArray((void**) dpp, (void*) dp, n, sizeof (double)); }
  72
  73 static void
  74 setDoubleArrayOneValue(double** vpp, double value, size_t nmemb)
  75 {
  76         if (*vpp)
  77                 _TIFFfree(*vpp);
  78         *vpp = _TIFFmalloc(nmemb*sizeof(double));
  79         if (*vpp)
  80         {
  81                 while (nmemb--)
  82                         ((double*)*vpp)[nmemb] = value;
  83         }
  84 }
  85
  86 /*
  87  * Install extra samples information.
  88  */
  89 static int
  90 setExtraSamples(TIFFDirectory* td, va_list ap, uint32* v)
  91 {
  92 /* XXX: Unassociated alpha data == 999 is a known Corel Draw bug, see below */
  93 #define EXTRASAMPLE_COREL_UNASSALPHA 999
  94
  95         uint16* va;
  96         uint32 i;
  97
  98         *v = (uint16) va_arg(ap, uint16_vap);
  99         if ((uint16) *v > td->td_samplesperpixel)
 100                 return 0;
 101         va = va_arg(ap, uint16*);
 102         if (*v > 0 && va == NULL)               /* typically missing param */
 103                 return 0;
 104         for (i = 0; i < *v; i++) {
 105                 if (va[i] > EXTRASAMPLE_UNASSALPHA) {
 106                         /*
 107                          * XXX: Corel Draw is known to produce incorrect
 108                          * ExtraSamples tags which must be patched here if we
 109                          * want to be able to open some of the damaged TIFF
 110                          * files:
 111                          */
 112                         if (va[i] == EXTRASAMPLE_COREL_UNASSALPHA)
 113                                 va[i] = EXTRASAMPLE_UNASSALPHA;
 114                         else
 115                                 return 0;
 116                 }
 117         }
 118         td->td_extrasamples = (uint16) *v;
 119         _TIFFsetShortArray(&td->td_sampleinfo, va, td->td_extrasamples);
 120         return 1;
 121
 122 #undef EXTRASAMPLE_COREL_UNASSALPHA
 123 }
 124
 125 /*
 126  * Confirm we have "samplesperpixel" ink names separated by \0.  Returns
 127  * zero if the ink names are not as expected.
 128  */
 129 static uint32
 130 checkInkNamesString(TIFF* tif, uint32 slen, const char* s)
 131 {
 132         TIFFDirectory* td = &tif->tif_dir;
 133         uint16 i = td->td_samplesperpixel;
 134
 135         if (slen > 0) {
 136                 const char* ep = s+slen;
 137                 const char* cp = s;
 138                 for (; i > 0; i--) {
 139                         for (; cp < ep && *cp != '\0'; cp++) {}
 140                         if (cp >= ep)
 141                                 goto bad;
 142                         cp++;                           /* skip \0 */
 143                 }
 144                 return ((uint32)(cp-s));
 145         }
 146 bad:
 147         TIFFErrorExt(tif->tif_clientdata, "TIFFSetField",
 148             "%s: Invalid InkNames value; expecting %d names, found %d",
 149             tif->tif_name,
 150             td->td_samplesperpixel,
 151             td->td_samplesperpixel-i);
 152         return (0);
 153 }
 154
 155 static int
 156 _TIFFVSetField(TIFF* tif, uint32 tag, va_list ap)
 157 {
 158         static const char module[] = "_TIFFVSetField";
 159
 160         TIFFDirectory* td = &tif->tif_dir;
 161         int status = 1;
 162         uint32 v32, i, v;
 163         char* s;
 164         const TIFFField *fip = TIFFFindField(tif, tag, TIFF_ANY);
 165         uint32 standard_tag = tag;
 166
 167         /*
 168          * We want to force the custom code to be used for custom
 169          * fields even if the tag happens to match a well known
 170          * one - important for reinterpreted handling of standard
 171          * tag values in custom directories (ie. EXIF)
 172          */
 173         if (fip->field_bit == FIELD_CUSTOM) {
 174                 standard_tag = 0;
 175         }
 176
 177         switch (standard_tag) {
 178         case TIFFTAG_SUBFILETYPE:
 179                 td->td_subfiletype = (uint32) va_arg(ap, uint32);
 180                 break;
 181         case TIFFTAG_IMAGEWIDTH:
 182                 td->td_imagewidth = (uint32) va_arg(ap, uint32);
 183                 break;
 184         case TIFFTAG_IMAGELENGTH:
 185                 td->td_imagelength = (uint32) va_arg(ap, uint32);
 186                 break;
 187         case TIFFTAG_BITSPERSAMPLE:
 188                 td->td_bitspersample = (uint16) va_arg(ap, uint16_vap);
 189                 /*
 190                  * If the data require post-decoding processing to byte-swap
 191                  * samples, set it up here.  Note that since tags are required
 192                  * to be ordered, compression code can override this behaviour
 193                  * in the setup method if it wants to roll the post decoding
 194                  * work in with its normal work.
 195                  */
 196                 if (tif->tif_flags & TIFF_SWAB) {
 197                         if (td->td_bitspersample == 8)
 198                                 tif->tif_postdecode = _TIFFNoPostDecode;
 199                         else if (td->td_bitspersample == 16)
 200                                 tif->tif_postdecode = _TIFFSwab16BitData;
 201                         else if (td->td_bitspersample == 24)
 202                                 tif->tif_postdecode = _TIFFSwab24BitData;
 203                         else if (td->td_bitspersample == 32)
 204                                 tif->tif_postdecode = _TIFFSwab32BitData;
 205                         else if (td->td_bitspersample == 64)
 206                                 tif->tif_postdecode = _TIFFSwab64BitData;
 207                         else if (td->td_bitspersample == 128) /* two 64's */
 208                                 tif->tif_postdecode = _TIFFSwab64BitData;
 209                 }
 210                 break;
 211         case TIFFTAG_COMPRESSION:
 212                 v = (uint16) va_arg(ap, uint16_vap);
 213                 /*
 214                  * If we're changing the compression scheme, the notify the
 215                  * previous module so that it can cleanup any state it's
 216                  * setup.
 217                  */
 218                 if (TIFFFieldSet(tif, FIELD_COMPRESSION)) {
 219                         if ((uint32)td->td_compression == v)
 220                                 break;
 221                         (*tif->tif_cleanup)(tif);
 222                         tif->tif_flags &= ~TIFF_CODERSETUP;
 223                 }
 224                 /*
 225                  * Setup new compression routine state.
 226                  */
 227                 if( (status = TIFFSetCompressionScheme(tif, v)) != 0 )
 228                     td->td_compression = (uint16) v;
 229                 else
 230                     status = 0;
 231                 break;
 232         case TIFFTAG_PHOTOMETRIC:
 233                 td->td_photometric = (uint16) va_arg(ap, uint16_vap);
 234                 break;
 235         case TIFFTAG_THRESHHOLDING:
 236                 td->td_threshholding = (uint16) va_arg(ap, uint16_vap);
 237                 break;
 238         case TIFFTAG_FILLORDER:
 239                 v = (uint16) va_arg(ap, uint16_vap);
 240                 if (v != FILLORDER_LSB2MSB && v != FILLORDER_MSB2LSB)
 241                         goto badvalue;
 242                 td->td_fillorder = (uint16) v;
 243                 break;
 244         case TIFFTAG_ORIENTATION:
 245                 v = (uint16) va_arg(ap, uint16_vap);
 246                 if (v < ORIENTATION_TOPLEFT || ORIENTATION_LEFTBOT < v)
 247                         goto badvalue;
 248                 else
 249                         td->td_orientation = (uint16) v;
 250                 break;
 251         case TIFFTAG_SAMPLESPERPIXEL:
 252                 v = (uint16) va_arg(ap, uint16_vap);
 253                 if (v == 0)
 254                         goto badvalue;
 255                 td->td_samplesperpixel = (uint16) v;
 256                 break;
 257         case TIFFTAG_ROWSPERSTRIP:
 258                 v32 = (uint32) va_arg(ap, uint32);
 259                 if (v32 == 0)
 260                         goto badvalue32;
 261                 td->td_rowsperstrip = v32;
 262                 if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
 263                         td->td_tilelength = v32;
 264                         td->td_tilewidth = td->td_imagewidth;
 265                 }
 266                 break;
 267         case TIFFTAG_MINSAMPLEVALUE:
 268                 td->td_minsamplevalue = (uint16) va_arg(ap, uint16_vap);
 269                 break;
 270         case TIFFTAG_MAXSAMPLEVALUE:
 271                 td->td_maxsamplevalue = (uint16) va_arg(ap, uint16_vap);
 272                 break;
 273         case TIFFTAG_SMINSAMPLEVALUE:
 274                 if (tif->tif_flags & TIFF_PERSAMPLE)
 275                         _TIFFsetDoubleArray(&td->td_sminsamplevalue, va_arg(ap, double*), td->td_samplesperpixel);
 276                 else
 277                         setDoubleArrayOneValue(&td->td_sminsamplevalue, va_arg(ap, double), td->td_samplesperpixel);
 278                 break;
 279         case TIFFTAG_SMAXSAMPLEVALUE:
 280                 if (tif->tif_flags & TIFF_PERSAMPLE)
 281                         _TIFFsetDoubleArray(&td->td_smaxsamplevalue, va_arg(ap, double*), td->td_samplesperpixel);
 282                 else
 283                         setDoubleArrayOneValue(&td->td_smaxsamplevalue, va_arg(ap, double), td->td_samplesperpixel);
 284                 break;
 285         case TIFFTAG_XRESOLUTION:
 286                 td->td_xresolution = (float) va_arg(ap, double);
 287                 break;
 288         case TIFFTAG_YRESOLUTION:
 289                 td->td_yresolution = (float) va_arg(ap, double);
 290                 break;
 291         case TIFFTAG_PLANARCONFIG:
 292                 v = (uint16) va_arg(ap, uint16_vap);
 293                 if (v != PLANARCONFIG_CONTIG && v != PLANARCONFIG_SEPARATE)
 294                         goto badvalue;
 295                 td->td_planarconfig = (uint16) v;
 296                 break;
 297         case TIFFTAG_XPOSITION:
 298                 td->td_xposition = (float) va_arg(ap, double);
 299                 break;
 300         case TIFFTAG_YPOSITION:
 301                 td->td_yposition = (float) va_arg(ap, double);
 302                 break;
 303         case TIFFTAG_RESOLUTIONUNIT:
 304                 v = (uint16) va_arg(ap, uint16_vap);
 305                 if (v < RESUNIT_NONE || RESUNIT_CENTIMETER < v)
 306                         goto badvalue;
 307                 td->td_resolutionunit = (uint16) v;
 308                 break;
 309         case TIFFTAG_PAGENUMBER:
 310                 td->td_pagenumber[0] = (uint16) va_arg(ap, uint16_vap);
 311                 td->td_pagenumber[1] = (uint16) va_arg(ap, uint16_vap);
 312                 break;
 313         case TIFFTAG_HALFTONEHINTS:
 314                 td->td_halftonehints[0] = (uint16) va_arg(ap, uint16_vap);
 315                 td->td_halftonehints[1] = (uint16) va_arg(ap, uint16_vap);
 316                 break;
 317         case TIFFTAG_COLORMAP:
 318                 v32 = (uint32)(1L<<td->td_bitspersample);
 319                 _TIFFsetShortArray(&td->td_colormap[0], va_arg(ap, uint16*), v32);
 320                 _TIFFsetShortArray(&td->td_colormap[1], va_arg(ap, uint16*), v32);
 321                 _TIFFsetShortArray(&td->td_colormap[2], va_arg(ap, uint16*), v32);
 322                 break;
 323         case TIFFTAG_EXTRASAMPLES:
 324                 if (!setExtraSamples(td, ap, &v))
 325                         goto badvalue;
 326                 break;
 327         case TIFFTAG_MATTEING:
 328                 td->td_extrasamples =  (((uint16) va_arg(ap, uint16_vap)) != 0);
 329                 if (td->td_extrasamples) {
 330                         uint16 sv = EXTRASAMPLE_ASSOCALPHA;
 331                         _TIFFsetShortArray(&td->td_sampleinfo, &sv, 1);
 332                 }
 333                 break;
 334         case TIFFTAG_TILEWIDTH:
 335                 v32 = (uint32) va_arg(ap, uint32);
 336                 if (v32 % 16) {
 337                         if (tif->tif_mode != O_RDONLY)
 338                                 goto badvalue32;
 339                         TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
 340                                 "Nonstandard tile width %d, convert file", v32);
 341                 }
 342                 td->td_tilewidth = v32;
 343                 tif->tif_flags |= TIFF_ISTILED;
 344                 break;
 345         case TIFFTAG_TILELENGTH:
 346                 v32 = (uint32) va_arg(ap, uint32);
 347                 if (v32 % 16) {
 348                         if (tif->tif_mode != O_RDONLY)
 349                                 goto badvalue32;
 350                         TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
 351                             "Nonstandard tile length %d, convert file", v32);
 352                 }
 353                 td->td_tilelength = v32;
 354                 tif->tif_flags |= TIFF_ISTILED;
 355                 break;
 356         case TIFFTAG_TILEDEPTH:
 357                 v32 = (uint32) va_arg(ap, uint32);
 358                 if (v32 == 0)
 359                         goto badvalue32;
 360                 td->td_tiledepth = v32;
 361                 break;
 362         case TIFFTAG_DATATYPE:
 363                 v = (uint16) va_arg(ap, uint16_vap);
 364                 switch (v) {
 365                 case DATATYPE_VOID:     v = SAMPLEFORMAT_VOID;  break;
 366                 case DATATYPE_INT:      v = SAMPLEFORMAT_INT;   break;
 367                 case DATATYPE_UINT:     v = SAMPLEFORMAT_UINT;  break;
 368                 case DATATYPE_IEEEFP:   v = SAMPLEFORMAT_IEEEFP;break;
 369                 default:                goto badvalue;
 370                 }
 371                 td->td_sampleformat = (uint16) v;
 372                 break;
 373         case TIFFTAG_SAMPLEFORMAT:
 374                 v = (uint16) va_arg(ap, uint16_vap);
 375                 if (v < SAMPLEFORMAT_UINT || SAMPLEFORMAT_COMPLEXIEEEFP < v)
 376                         goto badvalue;
 377                 td->td_sampleformat = (uint16) v;
 378
 379                 /*  Try to fix up the SWAB function for complex data. */
 380                 if( td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT
 381                     && td->td_bitspersample == 32
 382                     && tif->tif_postdecode == _TIFFSwab32BitData )
 383                     tif->tif_postdecode = _TIFFSwab16BitData;
 384                 else if( (td->td_sampleformat == SAMPLEFORMAT_COMPLEXINT
 385                           || td->td_sampleformat == SAMPLEFORMAT_COMPLEXIEEEFP)
 386                          && td->td_bitspersample == 64
 387                          && tif->tif_postdecode == _TIFFSwab64BitData )
 388                     tif->tif_postdecode = _TIFFSwab32BitData;
 389                 break;
 390         case TIFFTAG_IMAGEDEPTH:
 391                 td->td_imagedepth = (uint32) va_arg(ap, uint32);
 392                 break;
 393         case TIFFTAG_SUBIFD:
 394                 if ((tif->tif_flags & TIFF_INSUBIFD) == 0) {
 395                         td->td_nsubifd = (uint16) va_arg(ap, uint16_vap);
 396                         _TIFFsetLong8Array(&td->td_subifd, (uint64*) va_arg(ap, uint64*),
 397                             (long) td->td_nsubifd);
 398                 } else {
 399                         TIFFErrorExt(tif->tif_clientdata, module,
 400                                      "%s: Sorry, cannot nest SubIFDs",
 401                                      tif->tif_name);
 402                         status = 0;
 403                 }
 404                 break;
 405         case TIFFTAG_YCBCRPOSITIONING:
 406                 td->td_ycbcrpositioning = (uint16) va_arg(ap, uint16_vap);
 407                 break;
 408         case TIFFTAG_YCBCRSUBSAMPLING:
 409                 td->td_ycbcrsubsampling[0] = (uint16) va_arg(ap, uint16_vap);
 410                 td->td_ycbcrsubsampling[1] = (uint16) va_arg(ap, uint16_vap);
 411                 break;
 412         case TIFFTAG_TRANSFERFUNCTION:
 413                 v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1;
 414                 for (i = 0; i < v; i++)
 415                         _TIFFsetShortArray(&td->td_transferfunction[i],
 416                             va_arg(ap, uint16*), 1L<<td->td_bitspersample);
 417                 break;
 418         case TIFFTAG_REFERENCEBLACKWHITE:
 419                 /* XXX should check for null range */
 420                 _TIFFsetFloatArray(&td->td_refblackwhite, va_arg(ap, float*), 6);
 421                 break;
 422         case TIFFTAG_INKNAMES:
 423                 v = (uint16) va_arg(ap, uint16_vap);
 424                 s = va_arg(ap, char*);
 425                 v = checkInkNamesString(tif, v, s);
 426                 status = v > 0;
 427                 if( v > 0 ) {
 428                         _TIFFsetNString(&td->td_inknames, s, v);
 429                         td->td_inknameslen = v;
 430                 }
 431                 break;
 432         case TIFFTAG_PERSAMPLE:
 433                 v = (uint16) va_arg(ap, uint16_vap);
 434                 if( v == PERSAMPLE_MULTI )
 435                         tif->tif_flags |= TIFF_PERSAMPLE;
 436                 else
 437                         tif->tif_flags &= ~TIFF_PERSAMPLE;
 438                 break;
 439         default: {
 440                 TIFFTagValue *tv;
 441                 int tv_size, iCustom;
 442
 443                 /*
 444                  * This can happen if multiple images are open with different
 445                  * codecs which have private tags.  The global tag information
 446                  * table may then have tags that are valid for one file but not
 447                  * the other. If the client tries to set a tag that is not valid
 448                  * for the image's codec then we'll arrive here.  This
 449                  * happens, for example, when tiffcp is used to convert between
 450                  * compression schemes and codec-specific tags are blindly copied.
 451                  */
 452                 if(fip == NULL || fip->field_bit != FIELD_CUSTOM) {
 453                         TIFFErrorExt(tif->tif_clientdata, module,
 454                             "%s: Invalid %stag \"%s\" (not supported by codec)",
 455                             tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "",
 456                             fip ? fip->field_name : "Unknown");
 457                         status = 0;
 458                         break;
 459                 }
 460
 461                 /*
 462                  * Find the existing entry for this custom value.
 463                  */
 464                 tv = NULL;
 465                 for (iCustom = 0; iCustom < td->td_customValueCount; iCustom++) {
 466                         if (td->td_customValues[iCustom].info->field_tag == tag) {
 467                                 tv = td->td_customValues + iCustom;
 468                                 if (tv->value != NULL) {
 469                                         _TIFFfree(tv->value);
 470                                         tv->value = NULL;
 471                                 }
 472                                 break;
 473                         }
 474                 }
 475
 476                 /*
 477                  * Grow the custom list if the entry was not found.
 478                  */
 479                 if(tv == NULL) {
 480                         TIFFTagValue *new_customValues;
 481
 482                         td->td_customValueCount++;
 483                         new_customValues = (TIFFTagValue *)
 484                             _TIFFrealloc(td->td_customValues,
 485                             sizeof(TIFFTagValue) * td->td_customValueCount);
 486                         if (!new_customValues) {
 487                                 TIFFErrorExt(tif->tif_clientdata, module,
 488                                     "%s: Failed to allocate space for list of custom values",
 489                                     tif->tif_name);
 490                                 status = 0;
 491                                 goto end;
 492                         }
 493
 494                         td->td_customValues = new_customValues;
 495
 496                         tv = td->td_customValues + (td->td_customValueCount - 1);
 497                         tv->info = fip;
 498                         tv->value = NULL;
 499                         tv->count = 0;
 500                 }
 501
 502                 /*
 503                  * Set custom value ... save a copy of the custom tag value.
 504                  */
 505                 tv_size = _TIFFDataSize(fip->field_type);
 506                 if (tv_size == 0) {
 507                         status = 0;
 508                         TIFFErrorExt(tif->tif_clientdata, module,
 509                             "%s: Bad field type %d for \"%s\"",
 510                             tif->tif_name, fip->field_type,
 511                             fip->field_name);
 512                         goto end;
 513                 }
 514
 515                 if (fip->field_type == TIFF_ASCII)
 516                 {
 517                         uint32 ma;
 518                         char* mb;
 519                         if (fip->field_passcount)
 520                         {
 521                                 assert(fip->field_writecount==TIFF_VARIABLE2);
 522                                 ma=(uint32)va_arg(ap,uint32);
 523                                 mb=(char*)va_arg(ap,char*);
 524                         }
 525                         else
 526                         {
 527                                 mb=(char*)va_arg(ap,char*);
 528                                 ma=(uint32)(strlen(mb)+1);
 529                         }
 530                         tv->count=ma;
 531                         setByteArray(&tv->value,mb,ma,1);
 532                 }
 533                 else
 534                 {
 535                         if (fip->field_passcount) {
 536                                 if (fip->field_writecount == TIFF_VARIABLE2)
 537                                         tv->count = (uint32) va_arg(ap, uint32);
 538                                 else
 539                                         tv->count = (int) va_arg(ap, int);
 540                         } else if (fip->field_writecount == TIFF_VARIABLE
 541                            || fip->field_writecount == TIFF_VARIABLE2)
 542                                 tv->count = 1;
 543                         else if (fip->field_writecount == TIFF_SPP)
 544                                 tv->count = td->td_samplesperpixel;
 545                         else
 546                                 tv->count = fip->field_writecount;
 547
 548                         if (tv->count == 0) {
 549                                 status = 0;
 550                                 TIFFErrorExt(tif->tif_clientdata, module,
 551                                              "%s: Null count for \"%s\" (type "
 552                                              "%d, writecount %d, passcount %d)",
 553                                              tif->tif_name,
 554                                              fip->field_name,
 555                                              fip->field_type,
 556                                              fip->field_writecount,
 557                                              fip->field_passcount);
 558                                 goto end;
 559                         }
 560
 561                         tv->value = _TIFFCheckMalloc(tif, tv->count, tv_size,
 562                             "custom tag binary object");
 563                         if (!tv->value) {
 564                                 status = 0;
 565                                 goto end;
 566                         }
 567
 568                         if (fip->field_tag == TIFFTAG_DOTRANGE
 569                             && strcmp(fip->field_name,"DotRange") == 0) {
 570                                 /* TODO: This is an evil exception and should not have been
 571                                    handled this way ... likely best if we move it into
 572                                    the directory structure with an explicit field in
 573                                    libtiff 4.1 and assign it a FIELD_ value */
 574                                 uint16 v[2];
 575                                 v[0] = (uint16)va_arg(ap, int);
 576                                 v[1] = (uint16)va_arg(ap, int);
 577                                 _TIFFmemcpy(tv->value, &v, 4);
 578                         }
 579
 580                         else if (fip->field_passcount
 581                                   || fip->field_writecount == TIFF_VARIABLE
 582                                   || fip->field_writecount == TIFF_VARIABLE2
 583                                   || fip->field_writecount == TIFF_SPP
 584                                   || tv->count > 1) {
 585                                 _TIFFmemcpy(tv->value, va_arg(ap, void *),
 586                                     tv->count * tv_size);
 587                         } else {
 588                                 char *val = (char *)tv->value;
 589                                 assert( tv->count == 1 );
 590
 591                                 switch (fip->field_type) {
 592                                 case TIFF_BYTE:
 593                                 case TIFF_UNDEFINED:
 594                                         {
 595                                                 uint8 v = (uint8)va_arg(ap, int);
 596                                                 _TIFFmemcpy(val, &v, tv_size);
 597                                         }
 598                                         break;
 599                                 case TIFF_SBYTE:
 600                                         {
 601                                                 int8 v = (int8)va_arg(ap, int);
 602                                                 _TIFFmemcpy(val, &v, tv_size);
 603                                         }
 604                                         break;
 605                                 case TIFF_SHORT:
 606                                         {
 607                                                 uint16 v = (uint16)va_arg(ap, int);
 608                                                 _TIFFmemcpy(val, &v, tv_size);
 609                                         }
 610                                         break;
 611                                 case TIFF_SSHORT:
 612                                         {
 613                                                 int16 v = (int16)va_arg(ap, int);
 614                                                 _TIFFmemcpy(val, &v, tv_size);
 615                                         }
 616                                         break;
 617                                 case TIFF_LONG:
 618                                 case TIFF_IFD:
 619                                         {
 620                                                 uint32 v = va_arg(ap, uint32);
 621                                                 _TIFFmemcpy(val, &v, tv_size);
 622                                         }
 623                                         break;
 624                                 case TIFF_SLONG:
 625                                         {
 626                                                 int32 v = va_arg(ap, int32);
 627                                                 _TIFFmemcpy(val, &v, tv_size);
 628                                         }
 629                                         break;
 630                                 case TIFF_LONG8:
 631                                 case TIFF_IFD8:
 632                                         {
 633                                                 uint64 v = va_arg(ap, uint64);
 634                                                 _TIFFmemcpy(val, &v, tv_size);
 635                                         }
 636                                         break;
 637                                 case TIFF_SLONG8:
 638                                         {
 639                                                 int64 v = va_arg(ap, int64);
 640                                                 _TIFFmemcpy(val, &v, tv_size);
 641                                         }
 642                                         break;
 643                                 case TIFF_RATIONAL:
 644                                 case TIFF_SRATIONAL:
 645                                 case TIFF_FLOAT:
 646                                         {
 647                                                 float v = (float)va_arg(ap, double);
 648                                                 _TIFFmemcpy(val, &v, tv_size);
 649                                         }
 650                                         break;
 651                                 case TIFF_DOUBLE:
 652                                         {
 653                                                 double v = va_arg(ap, double);
 654                                                 _TIFFmemcpy(val, &v, tv_size);
 655                                         }
 656                                         break;
 657                                 default:
 658                                         _TIFFmemset(val, 0, tv_size);
 659                                         status = 0;
 660                                         break;
 661                                 }
 662                         }
 663                 }
 664         }
 665         }
 666         if (status) {
 667                 const TIFFField* fip=TIFFFieldWithTag(tif,tag);
 668                 if (fip)
 669                         TIFFSetFieldBit(tif, fip->field_bit);
 670                 tif->tif_flags |= TIFF_DIRTYDIRECT;
 671         }
 672
 673 end:
 674         va_end(ap);
 675         return (status);
 676 badvalue:
 677         {
 678                 const TIFFField* fip=TIFFFieldWithTag(tif,tag);
 679                 TIFFErrorExt(tif->tif_clientdata, module,
 680                      "%s: Bad value %u for \"%s\" tag",
 681                      tif->tif_name, v,
 682                      fip ? fip->field_name : "Unknown");
 683                 va_end(ap);
 684         }
 685         return (0);
 686 badvalue32:
 687         {
 688                 const TIFFField* fip=TIFFFieldWithTag(tif,tag);
 689                 TIFFErrorExt(tif->tif_clientdata, module,
 690                      "%s: Bad value %u for \"%s\" tag",
 691                      tif->tif_name, v32,
 692                      fip ? fip->field_name : "Unknown");
 693                 va_end(ap);
 694         }
 695         return (0);
 696 }
 697
 698 /*
 699  * Return 1/0 according to whether or not
 700  * it is permissible to set the tag's value.
 701  * Note that we allow ImageLength to be changed
 702  * so that we can append and extend to images.
 703  * Any other tag may not be altered once writing
 704  * has commenced, unless its value has no effect
 705  * on the format of the data that is written.
 706  */
 707 static int
 708 OkToChangeTag(TIFF* tif, uint32 tag)
 709 {
 710         const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY);
 711         if (!fip) {                     /* unknown tag */
 712                 TIFFErrorExt(tif->tif_clientdata, "TIFFSetField", "%s: Unknown %stag %u",
 713                     tif->tif_name, isPseudoTag(tag) ? "pseudo-" : "", tag);
 714                 return (0);
 715         }
 716         if (tag != TIFFTAG_IMAGELENGTH && (tif->tif_flags & TIFF_BEENWRITING) &&
 717             !fip->field_oktochange) {
 718                 /*
 719                  * Consult info table to see if tag can be changed
 720                  * after we've started writing.  We only allow changes
 721                  * to those tags that don't/shouldn't affect the
 722                  * compression and/or format of the data.
 723                  */
 724                 TIFFErrorExt(tif->tif_clientdata, "TIFFSetField",
 725                     "%s: Cannot modify tag \"%s\" while writing",
 726                     tif->tif_name, fip->field_name);
 727                 return (0);
 728         }
 729         return (1);
 730 }
 731
 732 /*
 733  * Record the value of a field in the
 734  * internal directory structure.  The
 735  * field will be written to the file
 736  * when/if the directory structure is
 737  * updated.
 738  */
 739 int
 740 TIFFSetField(TIFF* tif, uint32 tag, ...)
 741 {
 742         va_list ap;
 743         int status;
 744
 745         va_start(ap, tag);
 746         status = TIFFVSetField(tif, tag, ap);
 747         va_end(ap);
 748         return (status);
 749 }
 750
 751 /*
 752  * Clear the contents of the field in the internal structure.
 753  */
 754 int
 755 TIFFUnsetField(TIFF* tif, uint32 tag)
 756 {
 757     const TIFFField *fip =  TIFFFieldWithTag(tif, tag);
 758     TIFFDirectory* td = &tif->tif_dir;
 759
 760     if( !fip )
 761         return 0;
 762
 763     if( fip->field_bit != FIELD_CUSTOM )
 764         TIFFClrFieldBit(tif, fip->field_bit);
 765     else
 766     {
 767         TIFFTagValue *tv = NULL;
 768         int i;
 769
 770         for (i = 0; i < td->td_customValueCount; i++) {
 771
 772             tv = td->td_customValues + i;
 773             if( tv->info->field_tag == tag )
 774                 break;
 775         }
 776
 777         if( i < td->td_customValueCount )
 778         {
 779             _TIFFfree(tv->value);
 780             for( ; i < td->td_customValueCount-1; i++) {
 781                 td->td_customValues[i] = td->td_customValues[i+1];
 782             }
 783             td->td_customValueCount--;
 784         }
 785     }
 786
 787     tif->tif_flags |= TIFF_DIRTYDIRECT;
 788
 789     return (1);
 790 }
 791
 792 /*
 793  * Like TIFFSetField, but taking a varargs
 794  * parameter list.  This routine is useful
 795  * for building higher-level interfaces on
 796  * top of the library.
 797  */
 798 int
 799 TIFFVSetField(TIFF* tif, uint32 tag, va_list ap)
 800 {
 801         return OkToChangeTag(tif, tag) ?
 802             (*tif->tif_tagmethods.vsetfield)(tif, tag, ap) : 0;
 803 }
 804
 805 static int
 806 _TIFFVGetField(TIFF* tif, uint32 tag, va_list ap)
 807 {
 808         TIFFDirectory* td = &tif->tif_dir;
 809         int ret_val = 1;
 810         uint32 standard_tag = tag;
 811         const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY);
 812
 813         /*
 814          * We want to force the custom code to be used for custom
 815          * fields even if the tag happens to match a well known
 816          * one - important for reinterpreted handling of standard
 817          * tag values in custom directories (ie. EXIF)
 818          */
 819         if (fip->field_bit == FIELD_CUSTOM) {
 820                 standard_tag = 0;
 821         }
 822
 823         switch (standard_tag) {
 824                 case TIFFTAG_SUBFILETYPE:
 825                         *va_arg(ap, uint32*) = td->td_subfiletype;
 826                         break;
 827                 case TIFFTAG_IMAGEWIDTH:
 828                         *va_arg(ap, uint32*) = td->td_imagewidth;
 829                         break;
 830                 case TIFFTAG_IMAGELENGTH:
 831                         *va_arg(ap, uint32*) = td->td_imagelength;
 832                         break;
 833                 case TIFFTAG_BITSPERSAMPLE:
 834                         *va_arg(ap, uint16*) = td->td_bitspersample;
 835                         break;
 836                 case TIFFTAG_COMPRESSION:
 837                         *va_arg(ap, uint16*) = td->td_compression;
 838                         break;
 839                 case TIFFTAG_PHOTOMETRIC:
 840                         *va_arg(ap, uint16*) = td->td_photometric;
 841                         break;
 842                 case TIFFTAG_THRESHHOLDING:
 843                         *va_arg(ap, uint16*) = td->td_threshholding;
 844                         break;
 845                 case TIFFTAG_FILLORDER:
 846                         *va_arg(ap, uint16*) = td->td_fillorder;
 847                         break;
 848                 case TIFFTAG_ORIENTATION:
 849                         *va_arg(ap, uint16*) = td->td_orientation;
 850                         break;
 851                 case TIFFTAG_SAMPLESPERPIXEL:
 852                         *va_arg(ap, uint16*) = td->td_samplesperpixel;
 853                         break;
 854                 case TIFFTAG_ROWSPERSTRIP:
 855                         *va_arg(ap, uint32*) = td->td_rowsperstrip;
 856                         break;
 857                 case TIFFTAG_MINSAMPLEVALUE:
 858                         *va_arg(ap, uint16*) = td->td_minsamplevalue;
 859                         break;
 860                 case TIFFTAG_MAXSAMPLEVALUE:
 861                         *va_arg(ap, uint16*) = td->td_maxsamplevalue;
 862                         break;
 863                 case TIFFTAG_SMINSAMPLEVALUE:
 864                         if (tif->tif_flags & TIFF_PERSAMPLE)
 865                                 *va_arg(ap, double**) = td->td_sminsamplevalue;
 866                         else
 867                         {
 868                                 /* libtiff historially treats this as a single value. */
 869                                 uint16 i;
 870                                 double v = td->td_sminsamplevalue[0];
 871                                 for (i=1; i < td->td_samplesperpixel; ++i)
 872                                         if( td->td_sminsamplevalue[i] < v )
 873                                                 v = td->td_sminsamplevalue[i];
 874                                 *va_arg(ap, double*) = v;
 875                         }
 876                         break;
 877                 case TIFFTAG_SMAXSAMPLEVALUE:
 878                         if (tif->tif_flags & TIFF_PERSAMPLE)
 879                                 *va_arg(ap, double**) = td->td_smaxsamplevalue;
 880                         else
 881                         {
 882                                 /* libtiff historially treats this as a single value. */
 883                                 uint16 i;
 884                                 double v = td->td_smaxsamplevalue[0];
 885                                 for (i=1; i < td->td_samplesperpixel; ++i)
 886                                         if( td->td_smaxsamplevalue[i] > v )
 887                                                 v = td->td_smaxsamplevalue[i];
 888                                 *va_arg(ap, double*) = v;
 889                         }
 890                         break;
 891                 case TIFFTAG_XRESOLUTION:
 892                         *va_arg(ap, float*) = td->td_xresolution;
 893                         break;
 894                 case TIFFTAG_YRESOLUTION:
 895                         *va_arg(ap, float*) = td->td_yresolution;
 896                         break;
 897                 case TIFFTAG_PLANARCONFIG:
 898                         *va_arg(ap, uint16*) = td->td_planarconfig;
 899                         break;
 900                 case TIFFTAG_XPOSITION:
 901                         *va_arg(ap, float*) = td->td_xposition;
 902                         break;
 903                 case TIFFTAG_YPOSITION:
 904                         *va_arg(ap, float*) = td->td_yposition;
 905                         break;
 906                 case TIFFTAG_RESOLUTIONUNIT:
 907                         *va_arg(ap, uint16*) = td->td_resolutionunit;
 908                         break;
 909                 case TIFFTAG_PAGENUMBER:
 910                         *va_arg(ap, uint16*) = td->td_pagenumber[0];
 911                         *va_arg(ap, uint16*) = td->td_pagenumber[1];
 912                         break;
 913                 case TIFFTAG_HALFTONEHINTS:
 914                         *va_arg(ap, uint16*) = td->td_halftonehints[0];
 915                         *va_arg(ap, uint16*) = td->td_halftonehints[1];
 916                         break;
 917                 case TIFFTAG_COLORMAP:
 918                         *va_arg(ap, uint16**) = td->td_colormap[0];
 919                         *va_arg(ap, uint16**) = td->td_colormap[1];
 920                         *va_arg(ap, uint16**) = td->td_colormap[2];
 921                         break;
 922                 case TIFFTAG_STRIPOFFSETS:
 923                 case TIFFTAG_TILEOFFSETS:
 924                         _TIFFFillStriles( tif );
 925                         *va_arg(ap, uint64**) = td->td_stripoffset;
 926                         break;
 927                 case TIFFTAG_STRIPBYTECOUNTS:
 928                 case TIFFTAG_TILEBYTECOUNTS:
 929                         _TIFFFillStriles( tif );
 930                         *va_arg(ap, uint64**) = td->td_stripbytecount;
 931                         break;
 932                 case TIFFTAG_MATTEING:
 933                         *va_arg(ap, uint16*) =
 934                             (td->td_extrasamples == 1 &&
 935                             td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
 936                         break;
 937                 case TIFFTAG_EXTRASAMPLES:
 938                         *va_arg(ap, uint16*) = td->td_extrasamples;
 939                         *va_arg(ap, uint16**) = td->td_sampleinfo;
 940                         break;
 941                 case TIFFTAG_TILEWIDTH:
 942                         *va_arg(ap, uint32*) = td->td_tilewidth;
 943                         break;
 944                 case TIFFTAG_TILELENGTH:
 945                         *va_arg(ap, uint32*) = td->td_tilelength;
 946                         break;
 947                 case TIFFTAG_TILEDEPTH:
 948                         *va_arg(ap, uint32*) = td->td_tiledepth;
 949                         break;
 950                 case TIFFTAG_DATATYPE:
 951                         switch (td->td_sampleformat) {
 952                                 case SAMPLEFORMAT_UINT:
 953                                         *va_arg(ap, uint16*) = DATATYPE_UINT;
 954                                         break;
 955                                 case SAMPLEFORMAT_INT:
 956                                         *va_arg(ap, uint16*) = DATATYPE_INT;
 957                                         break;
 958                                 case SAMPLEFORMAT_IEEEFP:
 959                                         *va_arg(ap, uint16*) = DATATYPE_IEEEFP;
 960                                         break;
 961                                 case SAMPLEFORMAT_VOID:
 962                                         *va_arg(ap, uint16*) = DATATYPE_VOID;
 963                                         break;
 964                         }
 965                         break;
 966                 case TIFFTAG_SAMPLEFORMAT:
 967                         *va_arg(ap, uint16*) = td->td_sampleformat;
 968                         break;
 969                 case TIFFTAG_IMAGEDEPTH:
 970                         *va_arg(ap, uint32*) = td->td_imagedepth;
 971                         break;
 972                 case TIFFTAG_SUBIFD:
 973                         *va_arg(ap, uint16*) = td->td_nsubifd;
 974                         *va_arg(ap, uint64**) = td->td_subifd;
 975                         break;
 976                 case TIFFTAG_YCBCRPOSITIONING:
 977                         *va_arg(ap, uint16*) = td->td_ycbcrpositioning;
 978                         break;
 979                 case TIFFTAG_YCBCRSUBSAMPLING:
 980                         *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[0];
 981                         *va_arg(ap, uint16*) = td->td_ycbcrsubsampling[1];
 982                         break;
 983                 case TIFFTAG_TRANSFERFUNCTION:
 984                         *va_arg(ap, uint16**) = td->td_transferfunction[0];
 985                         if (td->td_samplesperpixel - td->td_extrasamples > 1) {
 986                                 *va_arg(ap, uint16**) = td->td_transferfunction[1];
 987                                 *va_arg(ap, uint16**) = td->td_transferfunction[2];
 988                         }
 989                         break;
 990                 case TIFFTAG_REFERENCEBLACKWHITE:
 991                         *va_arg(ap, float**) = td->td_refblackwhite;
 992                         break;
 993                 case TIFFTAG_INKNAMES:
 994                         *va_arg(ap, char**) = td->td_inknames;
 995                         break;
 996                 default:
 997                         {
 998                                 int i;
 999
1000                                 /*
1001                                  * This can happen if multiple images are open
1002                                  * with different codecs which have private
1003                                  * tags.  The global tag information table may
1004                                  * then have tags that are valid for one file
1005                                  * but not the other. If the client tries to
1006                                  * get a tag that is not valid for the image's
1007                                  * codec then we'll arrive here.
1008                                  */
1009                                 if( fip == NULL || fip->field_bit != FIELD_CUSTOM )
1010                                 {
1011                                         TIFFErrorExt(tif->tif_clientdata, "_TIFFVGetField",
1012                                             "%s: Invalid %stag \"%s\" "
1013                                             "(not supported by codec)",
1014                                             tif->tif_name,
1015                                             isPseudoTag(tag) ? "pseudo-" : "",
1016                                             fip ? fip->field_name : "Unknown");
1017                                         ret_val = 0;
1018                                         break;
1019                                 }
1020
1021                                 /*
1022                                  * Do we have a custom value?
1023                                  */
1024                                 ret_val = 0;
1025                                 for (i = 0; i < td->td_customValueCount; i++) {
1026                                         TIFFTagValue *tv = td->td_customValues + i;
1027
1028                                         if (tv->info->field_tag != tag)
1029                                                 continue;
1030
1031                                         if (fip->field_passcount) {
1032                                                 if (fip->field_readcount == TIFF_VARIABLE2)
1033                                                         *va_arg(ap, uint32*) = (uint32)tv->count;
1034                                                 else  /* Assume TIFF_VARIABLE */
1035                                                         *va_arg(ap, uint16*) = (uint16)tv->count;
1036                                                 *va_arg(ap, void **) = tv->value;
1037                                                 ret_val = 1;
1038                                         } else if (fip->field_tag == TIFFTAG_DOTRANGE
1039                                                    && strcmp(fip->field_name,"DotRange") == 0) {
1040                                                 /* TODO: This is an evil exception and should not have been
1041                                                    handled this way ... likely best if we move it into
1042                                                    the directory structure with an explicit field in
1043                                                    libtiff 4.1 and assign it a FIELD_ value */
1044                                                 *va_arg(ap, uint16*) = ((uint16 *)tv->value)[0];
1045                                                 *va_arg(ap, uint16*) = ((uint16 *)tv->value)[1];
1046                                                 ret_val = 1;
1047                                         } else {
1048                                                 if (fip->field_type == TIFF_ASCII
1049                                                     || fip->field_readcount == TIFF_VARIABLE
1050                                                     || fip->field_readcount == TIFF_VARIABLE2
1051                                                     || fip->field_readcount == TIFF_SPP
1052                                                     || tv->count > 1) {
1053                                                         *va_arg(ap, void **) = tv->value;
1054                                                         ret_val = 1;
1055                                                 } else {
1056                                                         char *val = (char *)tv->value;
1057                                                         assert( tv->count == 1 );
1058                                                         switch (fip->field_type) {
1059                                                         case TIFF_BYTE:
1060                                                         case TIFF_UNDEFINED:
1061                                                                 *va_arg(ap, uint8*) =
1062                                                                         *(uint8 *)val;
1063                                                                 ret_val = 1;
1064                                                                 break;
1065                                                         case TIFF_SBYTE:
1066                                                                 *va_arg(ap, int8*) =
1067                                                                         *(int8 *)val;
1068                                                                 ret_val = 1;
1069                                                                 break;
1070                                                         case TIFF_SHORT:
1071                                                                 *va_arg(ap, uint16*) =
1072                                                                         *(uint16 *)val;
1073                                                                 ret_val = 1;
1074                                                                 break;
1075                                                         case TIFF_SSHORT:
1076                                                                 *va_arg(ap, int16*) =
1077                                                                         *(int16 *)val;
1078                                                                 ret_val = 1;
1079                                                                 break;
1080                                                         case TIFF_LONG:
1081                                                         case TIFF_IFD:
1082                                                                 *va_arg(ap, uint32*) =
1083                                                                         *(uint32 *)val;
1084                                                                 ret_val = 1;
1085                                                                 break;
1086                                                         case TIFF_SLONG:
1087                                                                 *va_arg(ap, int32*) =
1088                                                                         *(int32 *)val;
1089                                                                 ret_val = 1;
1090                                                                 break;
1091                                                         case TIFF_LONG8:
1092                                                         case TIFF_IFD8:
1093                                                                 *va_arg(ap, uint64*) =
1094                                                                         *(uint64 *)val;
1095                                                                 ret_val = 1;
1096                                                                 break;
1097                                                         case TIFF_SLONG8:
1098                                                                 *va_arg(ap, int64*) =
1099                                                                         *(int64 *)val;
1100                                                                 ret_val = 1;
1101                                                                 break;
1102                                                         case TIFF_RATIONAL:
1103                                                         case TIFF_SRATIONAL:
1104                                                         case TIFF_FLOAT:
1105                                                                 *va_arg(ap, float*) =
1106                                                                         *(float *)val;
1107                                                                 ret_val = 1;
1108                                                                 break;
1109                                                         case TIFF_DOUBLE:
1110                                                                 *va_arg(ap, double*) =
1111                                                                         *(double *)val;
1112                                                                 ret_val = 1;
1113                                                                 break;
1114                                                         default:
1115                                                                 ret_val = 0;
1116                                                                 break;
1117                                                         }
1118                                                 }
1119                                         }
1120                                         break;
1121                                 }
1122                         }
1123         }
1124         return(ret_val);
1125 }
1126
1127 /*
1128  * Return the value of a field in the
1129  * internal directory structure.
1130  */
1131 int
1132 TIFFGetField(TIFF* tif, uint32 tag, ...)
1133 {
1134         int status;
1135         va_list ap;
1136
1137         va_start(ap, tag);
1138         status = TIFFVGetField(tif, tag, ap);
1139         va_end(ap);
1140         return (status);
1141 }
1142
1143 /*
1144  * Like TIFFGetField, but taking a varargs
1145  * parameter list.  This routine is useful
1146  * for building higher-level interfaces on
1147  * top of the library.
1148  */
1149 int
1150 TIFFVGetField(TIFF* tif, uint32 tag, va_list ap)
1151 {
1152         const TIFFField* fip = TIFFFindField(tif, tag, TIFF_ANY);
1153         return (fip && (isPseudoTag(tag) || TIFFFieldSet(tif, fip->field_bit)) ?
1154             (*tif->tif_tagmethods.vgetfield)(tif, tag, ap) : 0);
1155 }
1156
1157 #define CleanupField(member) {          \
1158     if (td->member) {                   \
1159         _TIFFfree(td->member);          \
1160         td->member = 0;                 \
1161     }                                   \
1162 }
1163
1164 /*
1165  * Release storage associated with a directory.
1166  */
1167 void
1168 TIFFFreeDirectory(TIFF* tif)
1169 {
1170         TIFFDirectory *td = &tif->tif_dir;
1171         int            i;
1172
1173         _TIFFmemset(td->td_fieldsset, 0, FIELD_SETLONGS);
1174         CleanupField(td_sminsamplevalue);
1175         CleanupField(td_smaxsamplevalue);
1176         CleanupField(td_colormap[0]);
1177         CleanupField(td_colormap[1]);
1178         CleanupField(td_colormap[2]);
1179         CleanupField(td_sampleinfo);
1180         CleanupField(td_subifd);
1181         CleanupField(td_inknames);
1182         CleanupField(td_refblackwhite);
1183         CleanupField(td_transferfunction[0]);
1184         CleanupField(td_transferfunction[1]);
1185         CleanupField(td_transferfunction[2]);
1186         CleanupField(td_stripoffset);
1187         CleanupField(td_stripbytecount);
1188         TIFFClrFieldBit(tif, FIELD_YCBCRSUBSAMPLING);
1189         TIFFClrFieldBit(tif, FIELD_YCBCRPOSITIONING);
1190
1191         /* Cleanup custom tag values */
1192         for( i = 0; i < td->td_customValueCount; i++ ) {
1193                 if (td->td_customValues[i].value)
1194                         _TIFFfree(td->td_customValues[i].value);
1195         }
1196
1197         td->td_customValueCount = 0;
1198         CleanupField(td_customValues);
1199
1200 #if defined(DEFER_STRILE_LOAD)
1201         _TIFFmemset( &(td->td_stripoffset_entry), 0, sizeof(TIFFDirEntry));
1202         _TIFFmemset( &(td->td_stripbytecount_entry), 0, sizeof(TIFFDirEntry));
1203 #endif
1204 }
1205 #undef CleanupField
1206
1207 /*
1208  * Client Tag extension support (from Niles Ritter).
1209  */
1210 static TIFFExtendProc _TIFFextender = (TIFFExtendProc) NULL;
1211
1212 TIFFExtendProc
1213 TIFFSetTagExtender(TIFFExtendProc extender)
1214 {
1215         TIFFExtendProc prev = _TIFFextender;
1216         _TIFFextender = extender;
1217         return (prev);
1218 }
1219
1220 /*
1221  * Setup for a new directory.  Should we automatically call
1222  * TIFFWriteDirectory() if the current one is dirty?
1223  *
1224  * The newly created directory will not exist on the file till
1225  * TIFFWriteDirectory(), TIFFFlush() or TIFFClose() is called.
1226  */
1227 int
1228 TIFFCreateDirectory(TIFF* tif)
1229 {
1230         TIFFDefaultDirectory(tif);
1231         tif->tif_diroff = 0;
1232         tif->tif_nextdiroff = 0;
1233         tif->tif_curoff = 0;
1234         tif->tif_row = (uint32) -1;
1235         tif->tif_curstrip = (uint32) -1;
1236
1237         return 0;
1238 }
1239
1240 int
1241 TIFFCreateCustomDirectory(TIFF* tif, const TIFFFieldArray* infoarray)
1242 {
1243         TIFFDefaultDirectory(tif);
1244
1245         /*
1246          * Reset the field definitions to match the application provided list.
1247          * Hopefully TIFFDefaultDirectory() won't have done anything irreversable
1248          * based on it's assumption this is an image directory.
1249          */
1250         _TIFFSetupFields(tif, infoarray);
1251
1252         tif->tif_diroff = 0;
1253         tif->tif_nextdiroff = 0;
1254         tif->tif_curoff = 0;
1255         tif->tif_row = (uint32) -1;
1256         tif->tif_curstrip = (uint32) -1;
1257
1258         return 0;
1259 }
1260
1261 int
1262 TIFFCreateEXIFDirectory(TIFF* tif)
1263 {
1264         const TIFFFieldArray* exifFieldArray;
1265         exifFieldArray = _TIFFGetExifFields();
1266         return TIFFCreateCustomDirectory(tif, exifFieldArray);
1267 }
1268
1269 /*
1270  * Setup a default directory structure.
1271  */
1272 int
1273 TIFFDefaultDirectory(TIFF* tif)
1274 {
1275         register TIFFDirectory* td = &tif->tif_dir;
1276         const TIFFFieldArray* tiffFieldArray;
1277
1278         tiffFieldArray = _TIFFGetFields();
1279         _TIFFSetupFields(tif, tiffFieldArray);
1280
1281         _TIFFmemset(td, 0, sizeof (*td));
1282         td->td_fillorder = FILLORDER_MSB2LSB;
1283         td->td_bitspersample = 1;
1284         td->td_threshholding = THRESHHOLD_BILEVEL;
1285         td->td_orientation = ORIENTATION_TOPLEFT;
1286         td->td_samplesperpixel = 1;
1287         td->td_rowsperstrip = (uint32) -1;
1288         td->td_tilewidth = 0;
1289         td->td_tilelength = 0;
1290         td->td_tiledepth = 1;
1291         td->td_stripbytecountsorted = 1; /* Our own arrays always sorted. */
1292         td->td_resolutionunit = RESUNIT_INCH;
1293         td->td_sampleformat = SAMPLEFORMAT_UINT;
1294         td->td_imagedepth = 1;
1295         td->td_ycbcrsubsampling[0] = 2;
1296         td->td_ycbcrsubsampling[1] = 2;
1297         td->td_ycbcrpositioning = YCBCRPOSITION_CENTERED;
1298         tif->tif_postdecode = _TIFFNoPostDecode;
1299         tif->tif_foundfield = NULL;
1300         tif->tif_tagmethods.vsetfield = _TIFFVSetField;
1301         tif->tif_tagmethods.vgetfield = _TIFFVGetField;
1302         tif->tif_tagmethods.printdir = NULL;
1303         /*
1304          *  Give client code a chance to install their own
1305          *  tag extensions & methods, prior to compression overloads.
1306          */
1307         if (_TIFFextender)
1308                 (*_TIFFextender)(tif);
1309         (void) TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
1310         /*
1311          * NB: The directory is marked dirty as a result of setting
1312          * up the default compression scheme.  However, this really
1313          * isn't correct -- we want TIFF_DIRTYDIRECT to be set only
1314          * if the user does something.  We could just do the setup
1315          * by hand, but it seems better to use the normal mechanism
1316          * (i.e. TIFFSetField).
1317          */
1318         tif->tif_flags &= ~TIFF_DIRTYDIRECT;
1319
1320         /*
1321          * As per http://bugzilla.remotesensing.org/show_bug.cgi?id=19
1322          * we clear the ISTILED flag when setting up a new directory.
1323          * Should we also be clearing stuff like INSUBIFD?
1324          */
1325         tif->tif_flags &= ~TIFF_ISTILED;
1326
1327         return (1);
1328 }
1329
1330 static int
1331 TIFFAdvanceDirectory(TIFF* tif, uint64* nextdir, uint64* off)
1332 {
1333         static const char module[] = "TIFFAdvanceDirectory";
1334         if (isMapped(tif))
1335         {
1336                 uint64 poff=*nextdir;
1337                 if (!(tif->tif_flags&TIFF_BIGTIFF))
1338                 {
1339                         tmsize_t poffa,poffb,poffc,poffd;
1340                         uint16 dircount;
1341                         uint32 nextdir32;
1342                         poffa=(tmsize_t)poff;
1343                         poffb=poffa+sizeof(uint16);
1344                         if (((uint64)poffa!=poff)||(poffb<poffa)||(poffb<(tmsize_t)sizeof(uint16))||(poffb>tif->tif_size))
1345                         {
1346                                 TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory count");
1347                                 return(0);
1348                         }
1349                         _TIFFmemcpy(&dircount,tif->tif_base+poffa,sizeof(uint16));
1350                         if (tif->tif_flags&TIFF_SWAB)
1351                                 TIFFSwabShort(&dircount);
1352                         poffc=poffb+dircount*12;
1353                         poffd=poffc+sizeof(uint32);
1354                         if ((poffc<poffb)||(poffc<dircount*12)||(poffd<poffc)||(poffd<(tmsize_t)sizeof(uint32))||(poffd>tif->tif_size))
1355                         {
1356                                 TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory link");
1357                                 return(0);
1358                         }
1359                         if (off!=NULL)
1360                                 *off=(uint64)poffc;
1361                         _TIFFmemcpy(&nextdir32,tif->tif_base+poffc,sizeof(uint32));
1362                         if (tif->tif_flags&TIFF_SWAB)
1363                                 TIFFSwabLong(&nextdir32);
1364                         *nextdir=nextdir32;
1365                 }
1366                 else
1367                 {
1368                         tmsize_t poffa,poffb,poffc,poffd;
1369                         uint64 dircount64;
1370                         uint16 dircount16;
1371                         poffa=(tmsize_t)poff;
1372                         poffb=poffa+sizeof(uint64);
1373                         if (((uint64)poffa!=poff)||(poffb<poffa)||(poffb<(tmsize_t)sizeof(uint64))||(poffb>tif->tif_size))
1374                         {
1375                                 TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory count");
1376                                 return(0);
1377                         }
1378                         _TIFFmemcpy(&dircount64,tif->tif_base+poffa,sizeof(uint64));
1379                         if (tif->tif_flags&TIFF_SWAB)
1380                                 TIFFSwabLong8(&dircount64);
1381                         if (dircount64>0xFFFF)
1382                         {
1383                                 TIFFErrorExt(tif->tif_clientdata,module,"Sanity check on directory count failed");
1384                                 return(0);
1385                         }
1386                         dircount16=(uint16)dircount64;
1387                         poffc=poffb+dircount16*20;
1388                         poffd=poffc+sizeof(uint64);
1389                         if ((poffc<poffb)||(poffc<dircount16*20)||(poffd<poffc)||(poffd<(tmsize_t)sizeof(uint64))||(poffd>tif->tif_size))
1390                         {
1391                                 TIFFErrorExt(tif->tif_clientdata,module,"Error fetching directory link");
1392                                 return(0);
1393                         }
1394                         if (off!=NULL)
1395                                 *off=(uint64)poffc;
1396                         _TIFFmemcpy(nextdir,tif->tif_base+poffc,sizeof(uint64));
1397                         if (tif->tif_flags&TIFF_SWAB)
1398                                 TIFFSwabLong8(nextdir);
1399                 }
1400                 return(1);
1401         }
1402         else
1403         {
1404                 if (!(tif->tif_flags&TIFF_BIGTIFF))
1405                 {
1406                         uint16 dircount;
1407                         uint32 nextdir32;
1408                         if (!SeekOK(tif, *nextdir) ||
1409                             !ReadOK(tif, &dircount, sizeof (uint16))) {
1410                                 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count",
1411                                     tif->tif_name);
1412                                 return (0);
1413                         }
1414                         if (tif->tif_flags & TIFF_SWAB)
1415                                 TIFFSwabShort(&dircount);
1416                         if (off != NULL)
1417                                 *off = TIFFSeekFile(tif,
1418                                     dircount*12, SEEK_CUR);
1419                         else
1420                                 (void) TIFFSeekFile(tif,
1421                                     dircount*12, SEEK_CUR);
1422                         if (!ReadOK(tif, &nextdir32, sizeof (uint32))) {
1423                                 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link",
1424                                     tif->tif_name);
1425                                 return (0);
1426                         }
1427                         if (tif->tif_flags & TIFF_SWAB)
1428                                 TIFFSwabLong(&nextdir32);
1429                         *nextdir=nextdir32;
1430                 }
1431                 else
1432                 {
1433                         uint64 dircount64;
1434                         uint16 dircount16;
1435                         if (!SeekOK(tif, *nextdir) ||
1436                             !ReadOK(tif, &dircount64, sizeof (uint64))) {
1437                                 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory count",
1438                                     tif->tif_name);
1439                                 return (0);
1440                         }
1441                         if (tif->tif_flags & TIFF_SWAB)
1442                                 TIFFSwabLong8(&dircount64);
1443                         if (dircount64>0xFFFF)
1444                         {
1445                                 TIFFErrorExt(tif->tif_clientdata, module, "Error fetching directory count");
1446                                 return(0);
1447                         }
1448                         dircount16 = (uint16)dircount64;
1449                         if (off != NULL)
1450                                 *off = TIFFSeekFile(tif,
1451                                     dircount16*20, SEEK_CUR);
1452                         else
1453                                 (void) TIFFSeekFile(tif,
1454                                     dircount16*20, SEEK_CUR);
1455                         if (!ReadOK(tif, nextdir, sizeof (uint64))) {
1456                                 TIFFErrorExt(tif->tif_clientdata, module, "%s: Error fetching directory link",
1457                                     tif->tif_name);
1458                                 return (0);
1459                         }
1460                         if (tif->tif_flags & TIFF_SWAB)
1461                                 TIFFSwabLong8(nextdir);
1462                 }
1463                 return (1);
1464         }
1465 }
1466
1467 /*
1468  * Count the number of directories in a file.
1469  */
1470 uint16
1471 TIFFNumberOfDirectories(TIFF* tif)
1472 {
1473         uint64 nextdir;
1474         uint16 n;
1475         if (!(tif->tif_flags&TIFF_BIGTIFF))
1476                 nextdir = tif->tif_header.classic.tiff_diroff;
1477         else
1478                 nextdir = tif->tif_header.big.tiff_diroff;
1479         n = 0;
1480         while (nextdir != 0 && TIFFAdvanceDirectory(tif, &nextdir, NULL))
1481                 n++;
1482         return (n);
1483 }
1484
1485 /*
1486  * Set the n-th directory as the current directory.
1487  * NB: Directories are numbered starting at 0.
1488  */
1489 int
1490 TIFFSetDirectory(TIFF* tif, uint16 dirn)
1491 {
1492         uint64 nextdir;
1493         uint16 n;
1494
1495         if (!(tif->tif_flags&TIFF_BIGTIFF))
1496                 nextdir = tif->tif_header.classic.tiff_diroff;
1497         else
1498                 nextdir = tif->tif_header.big.tiff_diroff;
1499         for (n = dirn; n > 0 && nextdir != 0; n--)
1500                 if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
1501                         return (0);
1502         tif->tif_nextdiroff = nextdir;
1503         /*
1504          * Set curdir to the actual directory index.  The
1505          * -1 is because TIFFReadDirectory will increment
1506          * tif_curdir after successfully reading the directory.
1507          */
1508         tif->tif_curdir = (dirn - n) - 1;
1509         /*
1510          * Reset tif_dirnumber counter and start new list of seen directories.
1511          * We need this to prevent IFD loops.
1512          */
1513         tif->tif_dirnumber = 0;
1514         return (TIFFReadDirectory(tif));
1515 }
1516
1517 /*
1518  * Set the current directory to be the directory
1519  * located at the specified file offset.  This interface
1520  * is used mainly to access directories linked with
1521  * the SubIFD tag (e.g. thumbnail images).
1522  */
1523 int
1524 TIFFSetSubDirectory(TIFF* tif, uint64 diroff)
1525 {
1526         tif->tif_nextdiroff = diroff;
1527         /*
1528          * Reset tif_dirnumber counter and start new list of seen directories.
1529          * We need this to prevent IFD loops.
1530          */
1531         tif->tif_dirnumber = 0;
1532         return (TIFFReadDirectory(tif));
1533 }
1534
1535 /*
1536  * Return file offset of the current directory.
1537  */
1538 uint64
1539 TIFFCurrentDirOffset(TIFF* tif)
1540 {
1541         return (tif->tif_diroff);
1542 }
1543
1544 /*
1545  * Return an indication of whether or not we are
1546  * at the last directory in the file.
1547  */
1548 int
1549 TIFFLastDirectory(TIFF* tif)
1550 {
1551         return (tif->tif_nextdiroff == 0);
1552 }
1553
1554 /*
1555  * Unlink the specified directory from the directory chain.
1556  */
1557 int
1558 TIFFUnlinkDirectory(TIFF* tif, uint16 dirn)
1559 {
1560         static const char module[] = "TIFFUnlinkDirectory";
1561         uint64 nextdir;
1562         uint64 off;
1563         uint16 n;
1564
1565         if (tif->tif_mode == O_RDONLY) {
1566                 TIFFErrorExt(tif->tif_clientdata, module,
1567                              "Can not unlink directory in read-only file");
1568                 return (0);
1569         }
1570         /*
1571          * Go to the directory before the one we want
1572          * to unlink and nab the offset of the link
1573          * field we'll need to patch.
1574          */
1575         if (!(tif->tif_flags&TIFF_BIGTIFF))
1576         {
1577                 nextdir = tif->tif_header.classic.tiff_diroff;
1578                 off = 4;
1579         }
1580         else
1581         {
1582                 nextdir = tif->tif_header.big.tiff_diroff;
1583                 off = 8;
1584         }
1585         for (n = dirn-1; n > 0; n--) {
1586                 if (nextdir == 0) {
1587                         TIFFErrorExt(tif->tif_clientdata, module, "Directory %d does not exist", dirn);
1588                         return (0);
1589                 }
1590                 if (!TIFFAdvanceDirectory(tif, &nextdir, &off))
1591                         return (0);
1592         }
1593         /*
1594          * Advance to the directory to be unlinked and fetch
1595          * the offset of the directory that follows.
1596          */
1597         if (!TIFFAdvanceDirectory(tif, &nextdir, NULL))
1598                 return (0);
1599         /*
1600          * Go back and patch the link field of the preceding
1601          * directory to point to the offset of the directory
1602          * that follows.
1603          */
1604         (void) TIFFSeekFile(tif, off, SEEK_SET);
1605         if (!(tif->tif_flags&TIFF_BIGTIFF))
1606         {
1607                 uint32 nextdir32;
1608                 nextdir32=(uint32)nextdir;
1609                 assert((uint64)nextdir32==nextdir);
1610                 if (tif->tif_flags & TIFF_SWAB)
1611                         TIFFSwabLong(&nextdir32);
1612                 if (!WriteOK(tif, &nextdir32, sizeof (uint32))) {
1613                         TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link");
1614                         return (0);
1615                 }
1616         }
1617         else
1618         {
1619                 if (tif->tif_flags & TIFF_SWAB)
1620                         TIFFSwabLong8(&nextdir);
1621                 if (!WriteOK(tif, &nextdir, sizeof (uint64))) {
1622                         TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link");
1623                         return (0);
1624                 }
1625         }
1626         /*
1627          * Leave directory state setup safely.  We don't have
1628          * facilities for doing inserting and removing directories,
1629          * so it's safest to just invalidate everything.  This
1630          * means that the caller can only append to the directory
1631          * chain.
1632          */
1633         (*tif->tif_cleanup)(tif);
1634         if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
1635                 _TIFFfree(tif->tif_rawdata);
1636                 tif->tif_rawdata = NULL;
1637                 tif->tif_rawcc = 0;
1638                 tif->tif_rawdataoff = 0;
1639                 tif->tif_rawdataloaded = 0;
1640         }
1641         tif->tif_flags &= ~(TIFF_BEENWRITING|TIFF_BUFFERSETUP|TIFF_POSTENCODE|TIFF_BUF4WRITE);
1642         TIFFFreeDirectory(tif);
1643         TIFFDefaultDirectory(tif);
1644         tif->tif_diroff = 0;                    /* force link on next write */
1645         tif->tif_nextdiroff = 0;                /* next write must be at end */
1646         tif->tif_curoff = 0;
1647         tif->tif_row = (uint32) -1;
1648         tif->tif_curstrip = (uint32) -1;
1649         return (1);
1650 }
1651
1652 /* vim: set ts=8 sts=8 sw=8 noet: */
1653 /*
1654  * Local Variables:
1655  * mode: c
1656  * c-basic-offset: 8
1657  * fill-column: 78
1658  * End:
1659  */