src/tiff/libtiff/tif_dir.c

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