Visualization Library 2.0.0-b5

A lightweight C++ OpenGL middleware for 2D/3D graphics

VL     Star     Watch     Fork     Issue

[Download] [Tutorials] [All Classes] [Grouped Classes]
tif_dirwrite.c
Go to the documentation of this file.
1 /* $Id: tif_dirwrite.c,v 1.34 2006/02/23 16:07:45 dron 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 Write Support Routines.
31  */
32 #include "tiffiop.h"
33 
34 #ifdef HAVE_IEEEFP
35 # define TIFFCvtNativeToIEEEFloat(tif, n, fp)
36 # define TIFFCvtNativeToIEEEDouble(tif, n, dp)
37 #else
38 extern void TIFFCvtNativeToIEEEFloat(TIFF*, uint32, float*);
39 extern void TIFFCvtNativeToIEEEDouble(TIFF*, uint32, double*);
40 #endif
41 
42 static int TIFFWriteNormalTag(TIFF*, TIFFDirEntry*, const TIFFFieldInfo*);
43 static void TIFFSetupShortLong(TIFF*, ttag_t, TIFFDirEntry*, uint32);
44 static void TIFFSetupShort(TIFF*, ttag_t, TIFFDirEntry*, uint16);
45 static int TIFFSetupShortPair(TIFF*, ttag_t, TIFFDirEntry*);
46 static int TIFFWritePerSampleShorts(TIFF*, ttag_t, TIFFDirEntry*);
47 static int TIFFWritePerSampleAnys(TIFF*, TIFFDataType, ttag_t, TIFFDirEntry*);
48 static int TIFFWriteShortTable(TIFF*, ttag_t, TIFFDirEntry*, uint32, uint16**);
49 static int TIFFWriteShortArray(TIFF*, TIFFDirEntry*, uint16*);
50 static int TIFFWriteLongArray(TIFF *, TIFFDirEntry*, uint32*);
51 static int TIFFWriteRationalArray(TIFF *, TIFFDirEntry*, float*);
52 static int TIFFWriteFloatArray(TIFF *, TIFFDirEntry*, float*);
53 static int TIFFWriteDoubleArray(TIFF *, TIFFDirEntry*, double*);
54 static int TIFFWriteByteArray(TIFF*, TIFFDirEntry*, char*);
55 static int TIFFWriteAnyArray(TIFF*,
56  TIFFDataType, ttag_t, TIFFDirEntry*, uint32, double*);
57 static int TIFFWriteTransferFunction(TIFF*, TIFFDirEntry*);
58 static int TIFFWriteInkNames(TIFF*, TIFFDirEntry*);
59 static int TIFFWriteData(TIFF*, TIFFDirEntry*, char*);
60 static int TIFFLinkDirectory(TIFF*);
61 
62 #define WriteRationalPair(type, tag1, v1, tag2, v2) { \
63  TIFFWriteRational((tif), (type), (tag1), (dir), (v1)) \
64  TIFFWriteRational((tif), (type), (tag2), (dir)+1, (v2)) \
65  (dir)++; \
66 }
67 #define TIFFWriteRational(tif, type, tag, dir, v) \
68  (dir)->tdir_tag = (tag); \
69  (dir)->tdir_type = (type); \
70  (dir)->tdir_count = 1; \
71  if (!TIFFWriteRationalArray((tif), (dir), &(v))) \
72  goto bad;
73 
74 /*
75  * Write the contents of the current directory
76  * to the specified file. This routine doesn't
77  * handle overwriting a directory with auxiliary
78  * storage that's been changed.
79  */
80 static int
81 _TIFFWriteDirectory(TIFF* tif, int done)
82 {
83  uint16 dircount;
84  toff_t diroff;
85  ttag_t tag;
86  uint32 nfields;
87  tsize_t dirsize;
88  char* data;
89  TIFFDirEntry* dir;
90  TIFFDirectory* td;
91  unsigned long b, fields[FIELD_SETLONGS];
92  int fi, nfi;
93 
94  if (tif->tif_mode == O_RDONLY)
95  return (1);
96  /*
97  * Clear write state so that subsequent images with
98  * different characteristics get the right buffers
99  * setup for them.
100  */
101  if (done)
102  {
103  if (tif->tif_flags & TIFF_POSTENCODE) {
104  tif->tif_flags &= ~TIFF_POSTENCODE;
105  if (!(*tif->tif_postencode)(tif)) {
107  "Error post-encoding before directory write");
108  return (0);
109  }
110  }
111  (*tif->tif_close)(tif); /* shutdown encoder */
112  /*
113  * Flush any data that might have been written
114  * by the compression close+cleanup routines.
115  */
116  if (tif->tif_rawcc > 0 && !TIFFFlushData1(tif)) {
118  "Error flushing data before directory write");
119  return (0);
120  }
121  if ((tif->tif_flags & TIFF_MYBUFFER) && tif->tif_rawdata) {
122  _TIFFfree(tif->tif_rawdata);
123  tif->tif_rawdata = NULL;
124  tif->tif_rawcc = 0;
125  tif->tif_rawdatasize = 0;
126  }
128  }
129 
130  td = &tif->tif_dir;
131  /*
132  * Size the directory so that we can calculate
133  * offsets for the data items that aren't kept
134  * in-place in each field.
135  */
136  nfields = 0;
137  for (b = 0; b <= FIELD_LAST; b++)
138  if (TIFFFieldSet(tif, b) && b != FIELD_CUSTOM)
139  nfields += (b < FIELD_SUBFILETYPE ? 2 : 1);
140  nfields += td->td_customValueCount;
141  dirsize = nfields * sizeof (TIFFDirEntry);
142  data = (char*) _TIFFmalloc(dirsize);
143  if (data == NULL) {
145  "Cannot write directory, out of space");
146  return (0);
147  }
148  /*
149  * Directory hasn't been placed yet, put
150  * it at the end of the file and link it
151  * into the existing directory structure.
152  */
153  if (tif->tif_diroff == 0 && !TIFFLinkDirectory(tif))
154  goto bad;
155  tif->tif_dataoff = (toff_t)(
156  tif->tif_diroff + sizeof (uint16) + dirsize + sizeof (toff_t));
157  if (tif->tif_dataoff & 1)
158  tif->tif_dataoff++;
159  (void) TIFFSeekFile(tif, tif->tif_dataoff, SEEK_SET);
160  tif->tif_curdir++;
161  dir = (TIFFDirEntry*) data;
162  /*
163  * Setup external form of directory
164  * entries and write data items.
165  */
166  _TIFFmemcpy(fields, td->td_fieldsset, sizeof (fields));
167  /*
168  * Write out ExtraSamples tag only if
169  * extra samples are present in the data.
170  */
171  if (FieldSet(fields, FIELD_EXTRASAMPLES) && !td->td_extrasamples) {
173  nfields--;
174  dirsize -= sizeof (TIFFDirEntry);
175  } /*XXX*/
176  for (fi = 0, nfi = tif->tif_nfields; nfi > 0; nfi--, fi++) {
177  const TIFFFieldInfo* fip = tif->tif_fieldinfo[fi];
178 
179  /*
180  ** For custom fields, we test to see if the custom field
181  ** is set or not. For normal fields, we just use the
182  ** FieldSet test.
183  */
184  if( fip->field_bit == FIELD_CUSTOM )
185  {
186  int ci, is_set = FALSE;
187 
188  for( ci = 0; ci < td->td_customValueCount; ci++ )
189  is_set |= (td->td_customValues[ci].info == fip);
190 
191  if( !is_set )
192  continue;
193  }
194  else if (!FieldSet(fields, fip->field_bit))
195  continue;
196 
197 
198  /*
199  ** Handle other fields.
200  */
201  switch (fip->field_bit)
202  {
203  case FIELD_STRIPOFFSETS:
204  /*
205  * We use one field bit for both strip and tile
206 
207  * offsets, and so must be careful in selecting
208  * the appropriate field descriptor (so that tags
209  * are written in sorted order).
210  */
211  tag = isTiled(tif) ?
213  if (tag != fip->field_tag)
214  continue;
215 
216  dir->tdir_tag = (uint16) tag;
217  dir->tdir_type = (uint16) TIFF_LONG;
218  dir->tdir_count = (uint32) td->td_nstrips;
219  if (!TIFFWriteLongArray(tif, dir, td->td_stripoffset))
220  goto bad;
221  break;
223  /*
224  * We use one field bit for both strip and tile
225  * byte counts, and so must be careful in selecting
226  * the appropriate field descriptor (so that tags
227  * are written in sorted order).
228  */
229  tag = isTiled(tif) ?
231  if (tag != fip->field_tag)
232  continue;
233 
234  dir->tdir_tag = (uint16) tag;
235  dir->tdir_type = (uint16) TIFF_LONG;
236  dir->tdir_count = (uint32) td->td_nstrips;
237  if (!TIFFWriteLongArray(tif, dir,
238  td->td_stripbytecount))
239  goto bad;
240  break;
241  case FIELD_ROWSPERSTRIP:
242  TIFFSetupShortLong(tif, TIFFTAG_ROWSPERSTRIP,
243  dir, td->td_rowsperstrip);
244  break;
245  case FIELD_COLORMAP:
246  if (!TIFFWriteShortTable(tif, TIFFTAG_COLORMAP, dir,
247  3, td->td_colormap))
248  goto bad;
249  break;
251  TIFFSetupShortLong(tif, TIFFTAG_IMAGEWIDTH,
252  dir++, td->td_imagewidth);
253  TIFFSetupShortLong(tif, TIFFTAG_IMAGELENGTH,
254  dir, td->td_imagelength);
255  break;
257  TIFFSetupShortLong(tif, TIFFTAG_TILEWIDTH,
258  dir++, td->td_tilewidth);
259  TIFFSetupShortLong(tif, TIFFTAG_TILELENGTH,
260  dir, td->td_tilelength);
261  break;
262  case FIELD_COMPRESSION:
263  TIFFSetupShort(tif, TIFFTAG_COMPRESSION,
264  dir, td->td_compression);
265  break;
266  case FIELD_PHOTOMETRIC:
267  TIFFSetupShort(tif, TIFFTAG_PHOTOMETRIC,
268  dir, td->td_photometric);
269  break;
270  case FIELD_POSITION:
274  break;
275  case FIELD_RESOLUTION:
279  break;
280  case FIELD_BITSPERSAMPLE:
283  case FIELD_SAMPLEFORMAT:
284  if (!TIFFWritePerSampleShorts(tif, fip->field_tag, dir))
285  goto bad;
286  break;
289  if (!TIFFWritePerSampleAnys(tif,
290  _TIFFSampleToTagType(tif), fip->field_tag, dir))
291  goto bad;
292  break;
293  case FIELD_PAGENUMBER:
294  case FIELD_HALFTONEHINTS:
296  if (!TIFFSetupShortPair(tif, fip->field_tag, dir))
297  goto bad;
298  break;
299  case FIELD_INKNAMES:
300  if (!TIFFWriteInkNames(tif, dir))
301  goto bad;
302  break;
304  if (!TIFFWriteTransferFunction(tif, dir))
305  goto bad;
306  break;
307  case FIELD_SUBIFD:
308  /*
309  * XXX: Always write this field using LONG type
310  * for backward compatibility.
311  */
312  dir->tdir_tag = (uint16) fip->field_tag;
313  dir->tdir_type = (uint16) TIFF_LONG;
314  dir->tdir_count = (uint32) td->td_nsubifd;
315  if (!TIFFWriteLongArray(tif, dir, td->td_subifd))
316  goto bad;
317  /*
318  * Total hack: if this directory includes a SubIFD
319  * tag then force the next <n> directories to be
320  * written as ``sub directories'' of this one. This
321  * is used to write things like thumbnails and
322  * image masks that one wants to keep out of the
323  * normal directory linkage access mechanism.
324  */
325  if (dir->tdir_count > 0) {
326  tif->tif_flags |= TIFF_INSUBIFD;
327  tif->tif_nsubifd = (uint16) dir->tdir_count;
328  if (dir->tdir_count > 1)
329  tif->tif_subifdoff = dir->tdir_offset;
330  else
331  tif->tif_subifdoff = (uint32)(
332  tif->tif_diroff
333  + sizeof (uint16)
334  + ((char*)&dir->tdir_offset-data));
335  }
336  break;
337  default:
338  /* XXX: Should be fixed and removed. */
339  if (fip->field_tag == TIFFTAG_DOTRANGE) {
340  if (!TIFFSetupShortPair(tif, fip->field_tag, dir))
341  goto bad;
342  }
343  else if (!TIFFWriteNormalTag(tif, dir, fip))
344  goto bad;
345  break;
346  }
347  dir++;
348 
349  if( fip->field_bit != FIELD_CUSTOM )
350  ResetFieldBit(fields, fip->field_bit);
351  }
352 
353  /*
354  * Write directory.
355  */
356  dircount = (uint16) nfields;
357  diroff = (uint32) tif->tif_nextdiroff;
358  if (tif->tif_flags & TIFF_SWAB) {
359  /*
360  * The file's byte order is opposite to the
361  * native machine architecture. We overwrite
362  * the directory information with impunity
363  * because it'll be released below after we
364  * write it to the file. Note that all the
365  * other tag construction routines assume that
366  * we do this byte-swapping; i.e. they only
367  * byte-swap indirect data.
368  */
369  for (dir = (TIFFDirEntry*) data; dircount; dir++, dircount--) {
370  TIFFSwabArrayOfShort(&dir->tdir_tag, 2);
372  }
373  dircount = (uint16) nfields;
374  TIFFSwabShort(&dircount);
375  TIFFSwabLong(&diroff);
376  }
377  (void) TIFFSeekFile(tif, tif->tif_diroff, SEEK_SET);
378  if (!WriteOK(tif, &dircount, sizeof (dircount))) {
379  TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error writing directory count");
380  goto bad;
381  }
382  if (!WriteOK(tif, data, dirsize)) {
383  TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error writing directory contents");
384  goto bad;
385  }
386  if (!WriteOK(tif, &diroff, sizeof (diroff))) {
387  TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error writing directory link");
388  goto bad;
389  }
390  if (done) {
391  TIFFFreeDirectory(tif);
392  tif->tif_flags &= ~TIFF_DIRTYDIRECT;
393  (*tif->tif_cleanup)(tif);
394 
395  /*
396  * Reset directory-related state for subsequent
397  * directories.
398  */
399  TIFFCreateDirectory(tif);
400  }
401  _TIFFfree(data);
402  return (1);
403 bad:
404  _TIFFfree(data);
405  return (0);
406 }
407 #undef WriteRationalPair
408 
409 int
411 {
412  return _TIFFWriteDirectory(tif, TRUE);
413 }
414 
415 /*
416  * Similar to TIFFWriteDirectory(), writes the directory out
417  * but leaves all data structures in memory so that it can be
418  * written again. This will make a partially written TIFF file
419  * readable before it is successfully completed/closed.
420  */
421 int
423 {
424  int rc;
425  /* Setup the strips arrays, if they haven't already been. */
426  if (tif->tif_dir.td_stripoffset == NULL)
427  (void) TIFFSetupStrips(tif);
428  rc = _TIFFWriteDirectory(tif, FALSE);
429  (void) TIFFSetWriteOffset(tif, TIFFSeekFile(tif, 0, SEEK_END));
430  return rc;
431 }
432 
433 /*
434  * Process tags that are not special cased.
435  */
436 static int
437 TIFFWriteNormalTag(TIFF* tif, TIFFDirEntry* dir, const TIFFFieldInfo* fip)
438 {
439  uint16 wc = (uint16) fip->field_writecount;
440  uint32 wc2;
441 
442  dir->tdir_tag = (uint16) fip->field_tag;
443  dir->tdir_type = (uint16) fip->field_type;
444  dir->tdir_count = wc;
445 
446  switch (fip->field_type) {
447  case TIFF_SHORT:
448  case TIFF_SSHORT:
449  if (fip->field_passcount) {
450  uint16* wp;
451  if (wc == (uint16) TIFF_VARIABLE2) {
452  TIFFGetField(tif, fip->field_tag, &wc2, &wp);
453  dir->tdir_count = wc2;
454  } else { /* Assume TIFF_VARIABLE */
455  TIFFGetField(tif, fip->field_tag, &wc, &wp);
456  dir->tdir_count = wc;
457  }
458  if (!TIFFWriteShortArray(tif, dir, wp))
459  return 0;
460  } else {
461  if (wc == 1) {
462  uint16 sv;
463  TIFFGetField(tif, fip->field_tag, &sv);
464  dir->tdir_offset =
465  TIFFInsertData(tif, dir->tdir_type, sv);
466  } else {
467  uint16* wp;
468  TIFFGetField(tif, fip->field_tag, &wp);
469  if (!TIFFWriteShortArray(tif, dir, wp))
470  return 0;
471  }
472  }
473  break;
474  case TIFF_LONG:
475  case TIFF_SLONG:
476  case TIFF_IFD:
477  if (fip->field_passcount) {
478  uint32* lp;
479  if (wc == (uint16) TIFF_VARIABLE2) {
480  TIFFGetField(tif, fip->field_tag, &wc2, &lp);
481  dir->tdir_count = wc2;
482  } else { /* Assume TIFF_VARIABLE */
483  TIFFGetField(tif, fip->field_tag, &wc, &lp);
484  dir->tdir_count = wc;
485  }
486  if (!TIFFWriteLongArray(tif, dir, lp))
487  return 0;
488  } else {
489  if (wc == 1) {
490  /* XXX handle LONG->SHORT conversion */
491  TIFFGetField(tif, fip->field_tag,
492  &dir->tdir_offset);
493  } else {
494  uint32* lp;
495  TIFFGetField(tif, fip->field_tag, &lp);
496  if (!TIFFWriteLongArray(tif, dir, lp))
497  return 0;
498  }
499  }
500  break;
501  case TIFF_RATIONAL:
502  case TIFF_SRATIONAL:
503  if (fip->field_passcount) {
504  float* fp;
505  if (wc == (uint16) TIFF_VARIABLE2) {
506  TIFFGetField(tif, fip->field_tag, &wc2, &fp);
507  dir->tdir_count = wc2;
508  } else { /* Assume TIFF_VARIABLE */
509  TIFFGetField(tif, fip->field_tag, &wc, &fp);
510  dir->tdir_count = wc;
511  }
512  if (!TIFFWriteRationalArray(tif, dir, fp))
513  return 0;
514  } else {
515  if (wc == 1) {
516  float fv;
517  TIFFGetField(tif, fip->field_tag, &fv);
518  if (!TIFFWriteRationalArray(tif, dir, &fv))
519  return 0;
520  } else {
521  float* fp;
522  TIFFGetField(tif, fip->field_tag, &fp);
523  if (!TIFFWriteRationalArray(tif, dir, fp))
524  return 0;
525  }
526  }
527  break;
528  case TIFF_FLOAT:
529  if (fip->field_passcount) {
530  float* fp;
531  if (wc == (uint16) TIFF_VARIABLE2) {
532  TIFFGetField(tif, fip->field_tag, &wc2, &fp);
533  dir->tdir_count = wc2;
534  } else { /* Assume TIFF_VARIABLE */
535  TIFFGetField(tif, fip->field_tag, &wc, &fp);
536  dir->tdir_count = wc;
537  }
538  if (!TIFFWriteFloatArray(tif, dir, fp))
539  return 0;
540  } else {
541  if (wc == 1) {
542  float fv;
543  TIFFGetField(tif, fip->field_tag, &fv);
544  if (!TIFFWriteFloatArray(tif, dir, &fv))
545  return 0;
546  } else {
547  float* fp;
548  TIFFGetField(tif, fip->field_tag, &fp);
549  if (!TIFFWriteFloatArray(tif, dir, fp))
550  return 0;
551  }
552  }
553  break;
554  case TIFF_DOUBLE:
555  if (fip->field_passcount) {
556  double* dp;
557  if (wc == (uint16) TIFF_VARIABLE2) {
558  TIFFGetField(tif, fip->field_tag, &wc2, &dp);
559  dir->tdir_count = wc2;
560  } else { /* Assume TIFF_VARIABLE */
561  TIFFGetField(tif, fip->field_tag, &wc, &dp);
562  dir->tdir_count = wc;
563  }
564  if (!TIFFWriteDoubleArray(tif, dir, dp))
565  return 0;
566  } else {
567  if (wc == 1) {
568  double dv;
569  TIFFGetField(tif, fip->field_tag, &dv);
570  if (!TIFFWriteDoubleArray(tif, dir, &dv))
571  return 0;
572  } else {
573  double* dp;
574  TIFFGetField(tif, fip->field_tag, &dp);
575  if (!TIFFWriteDoubleArray(tif, dir, dp))
576  return 0;
577  }
578  }
579  break;
580  case TIFF_ASCII:
581  {
582  char* cp;
583  if (fip->field_passcount)
584  TIFFGetField(tif, fip->field_tag, &wc, &cp);
585  else
586  TIFFGetField(tif, fip->field_tag, &cp);
587 
588  dir->tdir_count = (uint32) (strlen(cp) + 1);
589  if (!TIFFWriteByteArray(tif, dir, cp))
590  return (0);
591  }
592  break;
593 
594  case TIFF_BYTE:
595  case TIFF_SBYTE:
596  if (fip->field_passcount) {
597  char* cp;
598  if (wc == (uint16) TIFF_VARIABLE2) {
599  TIFFGetField(tif, fip->field_tag, &wc2, &cp);
600  dir->tdir_count = wc2;
601  } else { /* Assume TIFF_VARIABLE */
602  TIFFGetField(tif, fip->field_tag, &wc, &cp);
603  dir->tdir_count = wc;
604  }
605  if (!TIFFWriteByteArray(tif, dir, cp))
606  return 0;
607  } else {
608  if (wc == 1) {
609  char cv;
610  TIFFGetField(tif, fip->field_tag, &cv);
611  if (!TIFFWriteByteArray(tif, dir, &cv))
612  return 0;
613  } else {
614  char* cp;
615  TIFFGetField(tif, fip->field_tag, &cp);
616  if (!TIFFWriteByteArray(tif, dir, cp))
617  return 0;
618  }
619  }
620  break;
621 
622  case TIFF_UNDEFINED:
623  { char* cp;
624  if (wc == (unsigned short) TIFF_VARIABLE) {
625  TIFFGetField(tif, fip->field_tag, &wc, &cp);
626  dir->tdir_count = wc;
627  } else if (wc == (unsigned short) TIFF_VARIABLE2) {
628  TIFFGetField(tif, fip->field_tag, &wc2, &cp);
629  dir->tdir_count = wc2;
630  } else
631  TIFFGetField(tif, fip->field_tag, &cp);
632  if (!TIFFWriteByteArray(tif, dir, cp))
633  return (0);
634  }
635  break;
636 
637  case TIFF_NOTYPE:
638  break;
639  }
640  return (1);
641 }
642 
643 /*
644  * Setup a directory entry with either a SHORT
645  * or LONG type according to the value.
646  */
647 static void
648 TIFFSetupShortLong(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint32 v)
649 {
650  dir->tdir_tag = (uint16) tag;
651  dir->tdir_count = 1;
652  if (v > 0xffffL) {
653  dir->tdir_type = (short) TIFF_LONG;
654  dir->tdir_offset = v;
655  } else {
656  dir->tdir_type = (short) TIFF_SHORT;
657  dir->tdir_offset = TIFFInsertData(tif, (int) TIFF_SHORT, v);
658  }
659 }
660 
661 /*
662  * Setup a SHORT directory entry
663  */
664 static void
665 TIFFSetupShort(TIFF* tif, ttag_t tag, TIFFDirEntry* dir, uint16 v)
666 {
667  dir->tdir_tag = (uint16) tag;
668  dir->tdir_count = 1;
669  dir->tdir_type = (short) TIFF_SHORT;
670  dir->tdir_offset = TIFFInsertData(tif, (int) TIFF_SHORT, v);
671 }
672 #undef MakeShortDirent
673 
674 #define NITEMS(x) (sizeof (x) / sizeof (x[0]))
675 /*
676  * Setup a directory entry that references a
677  * samples/pixel array of SHORT values and
678  * (potentially) write the associated indirect
679  * values.
680  */
681 static int
682 TIFFWritePerSampleShorts(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
683 {
684  uint16 buf[10], v;
685  uint16* w = buf;
687  int status;
688 
689  if (samples > NITEMS(buf)) {
690  w = (uint16*) _TIFFmalloc(samples * sizeof (uint16));
691  if (w == NULL) {
693  "No space to write per-sample shorts");
694  return (0);
695  }
696  }
697  TIFFGetField(tif, tag, &v);
698  for (i = 0; i < samples; i++)
699  w[i] = v;
700 
701  dir->tdir_tag = (uint16) tag;
702  dir->tdir_type = (uint16) TIFF_SHORT;
703  dir->tdir_count = samples;
704  status = TIFFWriteShortArray(tif, dir, w);
705  if (w != buf)
706  _TIFFfree((char*) w);
707  return (status);
708 }
709 
710 /*
711  * Setup a directory entry that references a samples/pixel array of ``type''
712  * values and (potentially) write the associated indirect values. The source
713  * data from TIFFGetField() for the specified tag must be returned as double.
714  */
715 static int
716 TIFFWritePerSampleAnys(TIFF* tif,
718 {
719  double buf[10], v;
720  double* w = buf;
722  int status;
723 
724  if (samples > NITEMS(buf)) {
725  w = (double*) _TIFFmalloc(samples * sizeof (double));
726  if (w == NULL) {
728  "No space to write per-sample values");
729  return (0);
730  }
731  }
732  TIFFGetField(tif, tag, &v);
733  for (i = 0; i < samples; i++)
734  w[i] = v;
735  status = TIFFWriteAnyArray(tif, type, tag, dir, samples, w);
736  if (w != buf)
737  _TIFFfree(w);
738  return (status);
739 }
740 #undef NITEMS
741 
742 /*
743  * Setup a pair of shorts that are returned by
744  * value, rather than as a reference to an array.
745  */
746 static int
747 TIFFSetupShortPair(TIFF* tif, ttag_t tag, TIFFDirEntry* dir)
748 {
749  uint16 v[2];
750 
751  TIFFGetField(tif, tag, &v[0], &v[1]);
752 
753  dir->tdir_tag = (uint16) tag;
754  dir->tdir_type = (uint16) TIFF_SHORT;
755  dir->tdir_count = 2;
756  return (TIFFWriteShortArray(tif, dir, v));
757 }
758 
759 /*
760  * Setup a directory entry for an NxM table of shorts,
761  * where M is known to be 2**bitspersample, and write
762  * the associated indirect data.
763  */
764 static int
765 TIFFWriteShortTable(TIFF* tif,
766  ttag_t tag, TIFFDirEntry* dir, uint32 n, uint16** table)
767 {
768  uint32 i, off;
769 
770  dir->tdir_tag = (uint16) tag;
771  dir->tdir_type = (short) TIFF_SHORT;
772  /* XXX -- yech, fool TIFFWriteData */
773  dir->tdir_count = (uint32) (1L<<tif->tif_dir.td_bitspersample);
774  off = tif->tif_dataoff;
775  for (i = 0; i < n; i++)
776  if (!TIFFWriteData(tif, dir, (char *)table[i]))
777  return (0);
778  dir->tdir_count *= n;
779  dir->tdir_offset = off;
780  return (1);
781 }
782 
783 /*
784  * Write/copy data associated with an ASCII or opaque tag value.
785  */
786 static int
787 TIFFWriteByteArray(TIFF* tif, TIFFDirEntry* dir, char* cp)
788 {
789  if (dir->tdir_count > 4) {
790  if (!TIFFWriteData(tif, dir, cp))
791  return (0);
792  } else
793  _TIFFmemcpy(&dir->tdir_offset, cp, dir->tdir_count);
794  return (1);
795 }
796 
797 /*
798  * Setup a directory entry of an array of SHORT
799  * or SSHORT and write the associated indirect values.
800  */
801 static int
802 TIFFWriteShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
803 {
804  if (dir->tdir_count <= 2) {
805  if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
806  dir->tdir_offset = (uint32) ((long) v[0] << 16);
807  if (dir->tdir_count == 2)
808  dir->tdir_offset |= v[1] & 0xffff;
809  } else {
810  dir->tdir_offset = v[0] & 0xffff;
811  if (dir->tdir_count == 2)
812  dir->tdir_offset |= (long) v[1] << 16;
813  }
814  return (1);
815  } else
816  return (TIFFWriteData(tif, dir, (char*) v));
817 }
818 
819 /*
820  * Setup a directory entry of an array of LONG
821  * or SLONG and write the associated indirect values.
822  */
823 static int
824 TIFFWriteLongArray(TIFF* tif, TIFFDirEntry* dir, uint32* v)
825 {
826  if (dir->tdir_count == 1) {
827  dir->tdir_offset = v[0];
828  return (1);
829  } else
830  return (TIFFWriteData(tif, dir, (char*) v));
831 }
832 
833 /*
834  * Setup a directory entry of an array of RATIONAL
835  * or SRATIONAL and write the associated indirect values.
836  */
837 static int
838 TIFFWriteRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v)
839 {
840  uint32 i;
841  uint32* t;
842  int status;
843 
844  t = (uint32*) _TIFFmalloc(2 * dir->tdir_count * sizeof (uint32));
845  if (t == NULL) {
847  "No space to write RATIONAL array");
848  return (0);
849  }
850  for (i = 0; i < dir->tdir_count; i++) {
851  float fv = v[i];
852  int sign = 1;
853  uint32 den;
854 
855  if (fv < 0) {
856  if (dir->tdir_type == TIFF_RATIONAL) {
858  "\"%s\": Information lost writing value (%g) as (unsigned) RATIONAL",
860  fv);
861  fv = 0;
862  } else
863  fv = -fv, sign = -1;
864  }
865  den = 1L;
866  if (fv > 0) {
867  while (fv < 1L<<(31-3) && den < 1L<<(31-3))
868  fv *= 1<<3, den *= 1L<<3;
869  }
870  t[2*i+0] = (uint32) (sign * (fv + 0.5));
871  t[2*i+1] = den;
872  }
873  status = TIFFWriteData(tif, dir, (char *)t);
874  _TIFFfree((char*) t);
875  return (status);
876 }
877 
878 static int
879 TIFFWriteFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v)
880 {
881  TIFFCvtNativeToIEEEFloat(tif, dir->tdir_count, v);
882  if (dir->tdir_count == 1) {
883  dir->tdir_offset = *(uint32*) &v[0];
884  return (1);
885  } else
886  return (TIFFWriteData(tif, dir, (char*) v));
887 }
888 
889 static int
890 TIFFWriteDoubleArray(TIFF* tif, TIFFDirEntry* dir, double* v)
891 {
893  return (TIFFWriteData(tif, dir, (char*) v));
894 }
895 
896 /*
897  * Write an array of ``type'' values for a specified tag (i.e. this is a tag
898  * which is allowed to have different types, e.g. SMaxSampleType).
899  * Internally the data values are represented as double since a double can
900  * hold any of the TIFF tag types (yes, this should really be an abstract
901  * type tany_t for portability). The data is converted into the specified
902  * type in a temporary buffer and then handed off to the appropriate array
903  * writer.
904  */
905 static int
906 TIFFWriteAnyArray(TIFF* tif,
907  TIFFDataType type, ttag_t tag, TIFFDirEntry* dir, uint32 n, double* v)
908 {
909  char buf[10 * sizeof(double)];
910  char* w = buf;
911  int i, status = 0;
912 
913  if (n * TIFFDataWidth(type) > sizeof buf) {
914  w = (char*) _TIFFmalloc(n * TIFFDataWidth(type));
915  if (w == NULL) {
917  "No space to write array");
918  return (0);
919  }
920  }
921 
922  dir->tdir_tag = (uint16) tag;
923  dir->tdir_type = (uint16) type;
924  dir->tdir_count = n;
925 
926  switch (type) {
927  case TIFF_BYTE:
928  {
929  uint8* bp = (uint8*) w;
930  for (i = 0; i < (int) n; i++)
931  bp[i] = (uint8) v[i];
932  if (!TIFFWriteByteArray(tif, dir, (char*) bp))
933  goto out;
934  }
935  break;
936  case TIFF_SBYTE:
937  {
938  int8* bp = (int8*) w;
939  for (i = 0; i < (int) n; i++)
940  bp[i] = (int8) v[i];
941  if (!TIFFWriteByteArray(tif, dir, (char*) bp))
942  goto out;
943  }
944  break;
945  case TIFF_SHORT:
946  {
947  uint16* bp = (uint16*) w;
948  for (i = 0; i < (int) n; i++)
949  bp[i] = (uint16) v[i];
950  if (!TIFFWriteShortArray(tif, dir, (uint16*)bp))
951  goto out;
952  }
953  break;
954  case TIFF_SSHORT:
955  {
956  int16* bp = (int16*) w;
957  for (i = 0; i < (int) n; i++)
958  bp[i] = (int16) v[i];
959  if (!TIFFWriteShortArray(tif, dir, (uint16*)bp))
960  goto out;
961  }
962  break;
963  case TIFF_LONG:
964  {
965  uint32* bp = (uint32*) w;
966  for (i = 0; i < (int) n; i++)
967  bp[i] = (uint32) v[i];
968  if (!TIFFWriteLongArray(tif, dir, bp))
969  goto out;
970  }
971  break;
972  case TIFF_SLONG:
973  {
974  int32* bp = (int32*) w;
975  for (i = 0; i < (int) n; i++)
976  bp[i] = (int32) v[i];
977  if (!TIFFWriteLongArray(tif, dir, (uint32*) bp))
978  goto out;
979  }
980  break;
981  case TIFF_FLOAT:
982  {
983  float* bp = (float*) w;
984  for (i = 0; i < (int) n; i++)
985  bp[i] = (float) v[i];
986  if (!TIFFWriteFloatArray(tif, dir, bp))
987  goto out;
988  }
989  break;
990  case TIFF_DOUBLE:
991  return (TIFFWriteDoubleArray(tif, dir, v));
992  default:
993  /* TIFF_NOTYPE */
994  /* TIFF_ASCII */
995  /* TIFF_UNDEFINED */
996  /* TIFF_RATIONAL */
997  /* TIFF_SRATIONAL */
998  goto out;
999  }
1000  status = 1;
1001  out:
1002  if (w != buf)
1003  _TIFFfree(w);
1004  return (status);
1005 }
1006 
1007 static int
1008 TIFFWriteTransferFunction(TIFF* tif, TIFFDirEntry* dir)
1009 {
1010  TIFFDirectory* td = &tif->tif_dir;
1011  tsize_t n = (1L<<td->td_bitspersample) * sizeof (uint16);
1012  uint16** tf = td->td_transferfunction;
1013  int ncols;
1014 
1015  /*
1016  * Check if the table can be written as a single column,
1017  * or if it must be written as 3 columns. Note that we
1018  * write a 3-column tag if there are 2 samples/pixel and
1019  * a single column of data won't suffice--hmm.
1020  */
1021  switch (td->td_samplesperpixel - td->td_extrasamples) {
1022  default: if (_TIFFmemcmp(tf[0], tf[2], n)) { ncols = 3; break; }
1023  case 2: if (_TIFFmemcmp(tf[0], tf[1], n)) { ncols = 3; break; }
1024  case 1: case 0: ncols = 1;
1025  }
1026  return (TIFFWriteShortTable(tif,
1027  TIFFTAG_TRANSFERFUNCTION, dir, ncols, tf));
1028 }
1029 
1030 static int
1031 TIFFWriteInkNames(TIFF* tif, TIFFDirEntry* dir)
1032 {
1033  TIFFDirectory* td = &tif->tif_dir;
1034 
1035  dir->tdir_tag = TIFFTAG_INKNAMES;
1036  dir->tdir_type = (short) TIFF_ASCII;
1037  dir->tdir_count = td->td_inknameslen;
1038  return (TIFFWriteByteArray(tif, dir, td->td_inknames));
1039 }
1040 
1041 /*
1042  * Write a contiguous directory item.
1043  */
1044 static int
1045 TIFFWriteData(TIFF* tif, TIFFDirEntry* dir, char* cp)
1046 {
1047  tsize_t cc;
1048 
1049  if (tif->tif_flags & TIFF_SWAB) {
1050  switch (dir->tdir_type) {
1051  case TIFF_SHORT:
1052  case TIFF_SSHORT:
1053  TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count);
1054  break;
1055  case TIFF_LONG:
1056  case TIFF_SLONG:
1057  case TIFF_FLOAT:
1058  TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count);
1059  break;
1060  case TIFF_RATIONAL:
1061  case TIFF_SRATIONAL:
1062  TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count);
1063  break;
1064  case TIFF_DOUBLE:
1065  TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count);
1066  break;
1067  }
1068  }
1069  dir->tdir_offset = tif->tif_dataoff;
1070  cc = dir->tdir_count * TIFFDataWidth((TIFFDataType) dir->tdir_type);
1071  if (SeekOK(tif, dir->tdir_offset) &&
1072  WriteOK(tif, cp, cc)) {
1073  tif->tif_dataoff += (cc + 1) & ~1;
1074  return (1);
1075  }
1076  TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error writing data for field \"%s\"",
1077  _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
1078  return (0);
1079 }
1080 
1081 /*
1082  * Similar to TIFFWriteDirectory(), but if the directory has already
1083  * been written once, it is relocated to the end of the file, in case it
1084  * has changed in size. Note that this will result in the loss of the
1085  * previously used directory space.
1086  */
1087 
1088 int
1090 {
1091  static const char module[] = "TIFFRewriteDirectory";
1092 
1093  /* We don't need to do anything special if it hasn't been written. */
1094  if( tif->tif_diroff == 0 )
1095  return TIFFWriteDirectory( tif );
1096 
1097  /*
1098  ** Find and zero the pointer to this directory, so that TIFFLinkDirectory
1099  ** will cause it to be added after this directories current pre-link.
1100  */
1101 
1102  /* Is it the first directory in the file? */
1103  if (tif->tif_header.tiff_diroff == tif->tif_diroff)
1104  {
1105  tif->tif_header.tiff_diroff = 0;
1106  tif->tif_diroff = 0;
1107 
1109  SEEK_SET);
1110  if (!WriteOK(tif, &(tif->tif_header.tiff_diroff),
1111  sizeof (tif->tif_diroff)))
1112  {
1113  TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error updating TIFF header");
1114  return (0);
1115  }
1116  }
1117  else
1118  {
1119  toff_t nextdir, off;
1120 
1121  nextdir = tif->tif_header.tiff_diroff;
1122  do {
1123  uint16 dircount;
1124 
1125  if (!SeekOK(tif, nextdir) ||
1126  !ReadOK(tif, &dircount, sizeof (dircount))) {
1127  TIFFErrorExt(tif->tif_clientdata, module, "Error fetching directory count");
1128  return (0);
1129  }
1130  if (tif->tif_flags & TIFF_SWAB)
1131  TIFFSwabShort(&dircount);
1132  (void) TIFFSeekFile(tif,
1133  dircount * sizeof (TIFFDirEntry), SEEK_CUR);
1134  if (!ReadOK(tif, &nextdir, sizeof (nextdir))) {
1135  TIFFErrorExt(tif->tif_clientdata, module, "Error fetching directory link");
1136  return (0);
1137  }
1138  if (tif->tif_flags & TIFF_SWAB)
1139  TIFFSwabLong(&nextdir);
1140  } while (nextdir != tif->tif_diroff && nextdir != 0);
1141  off = TIFFSeekFile(tif, 0, SEEK_CUR); /* get current offset */
1142  (void) TIFFSeekFile(tif, off - (toff_t)sizeof(nextdir), SEEK_SET);
1143  tif->tif_diroff = 0;
1144  if (!WriteOK(tif, &(tif->tif_diroff), sizeof (nextdir))) {
1145  TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link");
1146  return (0);
1147  }
1148  }
1149 
1150  /*
1151  ** Now use TIFFWriteDirectory() normally.
1152  */
1153 
1154  return TIFFWriteDirectory( tif );
1155 }
1156 
1157 
1158 /*
1159  * Link the current directory into the
1160  * directory chain for the file.
1161  */
1162 static int
1163 TIFFLinkDirectory(TIFF* tif)
1164 {
1165  static const char module[] = "TIFFLinkDirectory";
1166  toff_t nextdir;
1167  toff_t diroff, off;
1168 
1169  tif->tif_diroff = (TIFFSeekFile(tif, (toff_t) 0, SEEK_END)+1) &~ 1;
1170  diroff = tif->tif_diroff;
1171  if (tif->tif_flags & TIFF_SWAB)
1172  TIFFSwabLong(&diroff);
1173 
1174  /*
1175  * Handle SubIFDs
1176  */
1177  if (tif->tif_flags & TIFF_INSUBIFD) {
1178  (void) TIFFSeekFile(tif, tif->tif_subifdoff, SEEK_SET);
1179  if (!WriteOK(tif, &diroff, sizeof (diroff))) {
1180  TIFFErrorExt(tif->tif_clientdata, module,
1181  "%s: Error writing SubIFD directory link",
1182  tif->tif_name);
1183  return (0);
1184  }
1185  /*
1186  * Advance to the next SubIFD or, if this is
1187  * the last one configured, revert back to the
1188  * normal directory linkage.
1189  */
1190  if (--tif->tif_nsubifd)
1191  tif->tif_subifdoff += sizeof (diroff);
1192  else
1193  tif->tif_flags &= ~TIFF_INSUBIFD;
1194  return (1);
1195  }
1196 
1197  if (tif->tif_header.tiff_diroff == 0) {
1198  /*
1199  * First directory, overwrite offset in header.
1200  */
1201  tif->tif_header.tiff_diroff = tif->tif_diroff;
1202  (void) TIFFSeekFile(tif,
1204  SEEK_SET);
1205  if (!WriteOK(tif, &diroff, sizeof (diroff))) {
1206  TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Error writing TIFF header");
1207  return (0);
1208  }
1209  return (1);
1210  }
1211  /*
1212  * Not the first directory, search to the last and append.
1213  */
1214  nextdir = tif->tif_header.tiff_diroff;
1215  do {
1216  uint16 dircount;
1217 
1218  if (!SeekOK(tif, nextdir) ||
1219  !ReadOK(tif, &dircount, sizeof (dircount))) {
1220  TIFFErrorExt(tif->tif_clientdata, module, "Error fetching directory count");
1221  return (0);
1222  }
1223  if (tif->tif_flags & TIFF_SWAB)
1224  TIFFSwabShort(&dircount);
1225  (void) TIFFSeekFile(tif,
1226  dircount * sizeof (TIFFDirEntry), SEEK_CUR);
1227  if (!ReadOK(tif, &nextdir, sizeof (nextdir))) {
1228  TIFFErrorExt(tif->tif_clientdata, module, "Error fetching directory link");
1229  return (0);
1230  }
1231  if (tif->tif_flags & TIFF_SWAB)
1232  TIFFSwabLong(&nextdir);
1233  } while (nextdir != 0);
1234  off = TIFFSeekFile(tif, 0, SEEK_CUR); /* get current offset */
1235  (void) TIFFSeekFile(tif, off - (toff_t)sizeof(nextdir), SEEK_SET);
1236  if (!WriteOK(tif, &diroff, sizeof (diroff))) {
1237  TIFFErrorExt(tif->tif_clientdata, module, "Error writing directory link");
1238  return (0);
1239  }
1240  return (1);
1241 }
1242 
1243 /* vim: set ts=8 sts=8 sw=8 noet: */
int32 tsize_t
Definition: tiffio.h:66
uint32 ttag_t
Definition: tiffio.h:61
#define TIFF_BEENWRITING
Definition: tiffiop.h:105
uint32 td_imagewidth
Definition: tif_dir.h:41
int TIFFRewriteDirectory(TIFF *tif)
#define TIFF_VARIABLE
Definition: tiffio.h:295
#define FIELD_CUSTOM
Definition: tiffio.h:299
#define NITEMS(x)
Definition: tif_dirwrite.c:674
#define FIELD_MINSAMPLEVALUE
Definition: tif_dir.h:116
#define FIELD_RESOLUTION
Definition: tif_dir.h:103
void TIFFWarningExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_warning.c:63
#define TIFFTAG_ROWSPERSTRIP
Definition: tiff.h:236
uint16 td_bitspersample
Definition: tif_dir.h:44
int TIFFSetupStrips(TIFF *tif)
Definition: tif_write.c:447
uint16 td_nsubifd
Definition: tif_dir.h:69
#define FIELD_STRIPOFFSETS
Definition: tif_dir.h:122
#define TIFFTAG_STRIPBYTECOUNTS
Definition: tiff.h:237
#define TIFFTAG_COLORMAP
Definition: tiff.h:287
float td_xresolution
Definition: tif_dir.h:55
#define NULL
Definition: ftobjs.h:61
T sign(T a)
Definition: glsl_math.hpp:669
#define TIFFInsertData(tif, type, v)
Definition: tif_dir.h:159
#define WriteOK(tif, buf, size)
Definition: tiffiop.h:220
#define FIELD_IMAGEDIMENSIONS
Definition: tif_dir.h:101
#define TIFFSeekFile(tif, off, whence)
Definition: tiffiop.h:197
#define TIFFTAG_IMAGEWIDTH
Definition: tiff.h:165
#define TIFFTAG_YRESOLUTION
Definition: tiff.h:241
sizeof(AF_ModuleRec)
#define TIFFTAG_INKNAMES
Definition: tiff.h:303
tstrip_t td_nstrips
Definition: tif_dir.h:65
#define FIELD_LAST
Definition: tif_dir.h:153
uint32 * td_stripoffset
Definition: tif_dir.h:66
unsigned char uint8
Definition: tiff.h:67
uint16 * td_transferfunction[3]
Definition: tif_dir.h:75
signed char int8
Definition: tiff.h:65
#define FIELD_HALFTONEHINTS
Definition: tif_dir.h:130
TIFFVoidMethod tif_close
Definition: tiffiop.h:152
TIFFTagValue * td_customValues
Definition: tif_dir.h:81
#define TIFFTAG_DOTRANGE
Definition: tiff.h:305
tidata_t tif_rawdata
Definition: tiffiop.h:161
#define TIFFTAG_STRIPOFFSETS
Definition: tiff.h:225
thandle_t tif_clientdata
Definition: tiffiop.h:171
void TIFFSwabArrayOfShort(uint16 *wp, register unsigned long n)
Definition: tif_swab.c:59
#define SEEK_END
Definition: zconf.h:251
#define TIFFTAG_YPOSITION
Definition: tiff.h:247
float td_xposition
Definition: tif_dir.h:58
typedef void(APIENTRY *GLDEBUGPROCARB)(GLenum source
char * tif_name
Definition: tiffiop.h:96
#define TIFF_DIRTYDIRECT
Definition: tiffiop.h:102
int td_inknameslen
Definition: tif_dir.h:77
Definition: tiffiop.h:95
#define FIELD_YCBCRSUBSAMPLING
Definition: tif_dir.h:131
GLboolean GLboolean GLboolean b
#define FIELD_SETLONGS
Definition: tif_dir.h:37
#define FIELD_SMAXSAMPLEVALUE
Definition: tif_dir.h:127
png_uint_32 i
Definition: png.h:2640
#define TIFFTAG_TILEBYTECOUNTS
Definition: tiff.h:292
Definition: tiff.h:116
#define FIELD_SUBIFD
Definition: tif_dir.h:135
uint16 td_extrasamples
Definition: tif_dir.h:62
#define FIELD_TRANSFERFUNCTION
Definition: tif_dir.h:133
unsigned long td_fieldsset[FIELD_SETLONGS]
Definition: tif_dir.h:39
void _TIFFmemcpy(tdata_t d, const tdata_t s, tsize_t c)
Definition: tif_acorn.c:485
#define FIELD_MAXSAMPLEVALUE
Definition: tif_dir.h:117
GLenum GLuint GLenum GLsizei const GLchar * buf
#define SEEK_CUR
Definition: zconf.h:250
#define FIELD_BITSPERSAMPLE
Definition: tif_dir.h:108
int _TIFFmemcmp(const tdata_t p1, const tdata_t p2, tsize_t c)
Definition: tif_acorn.c:491
int td_customValueCount
Definition: tif_dir.h:80
#define TIFF_SWAB
Definition: tiffiop.h:106
const TIFFFieldInfo * info
Definition: tiffio.h:313
#define TIFFTAG_TILEWIDTH
Definition: tiff.h:289
uint16 tif_nsubifd
Definition: tiffiop.h:132
#define FIELD_STRIPBYTECOUNTS
Definition: tif_dir.h:121
TIFFDataType _TIFFSampleToTagType(TIFF *)
Definition: tif_dirinfo.c:684
png_FILE_p fp
Definition: png.h:1791
#define TIFFTAG_TILELENGTH
Definition: tiff.h:290
int tif_mode
Definition: tiffiop.h:98
unsigned char field_passcount
Definition: tiffio.h:308
int TIFFWriteDirectory(TIFF *tif)
Definition: tif_dirwrite.c:410
uint32 tif_flags
Definition: tiffiop.h:99
uint32 td_tilewidth
Definition: tif_dir.h:42
#define TIFFTAG_IMAGELENGTH
Definition: tiff.h:166
#define TIFFTAG_TILEOFFSETS
Definition: tiff.h:291
size_t tif_nfields
Definition: tiffiop.h:181
#define TIFF_MAGIC_SIZE
Definition: tiff.h:97
uint32 td_tilelength
Definition: tif_dir.h:42
local struct tab * done
Definition: enough.c:176
#define TIFF_POSTENCODE
Definition: tiffiop.h:111
void TIFFFreeDirectory(TIFF *tif)
Definition: tif_dir.c:961
#define TIFF_VERSION_SIZE
Definition: tiff.h:99
local int out(void *out_desc, unsigned char *buf, unsigned len)
Definition: gun.c:131
const GLdouble * v
tdir_t tif_curdir
Definition: tiffiop.h:127
uint32 tdir_offset
Definition: tiff.h:120
GLsizei GLsizei GLenum GLenum const GLvoid * data
unsigned short uint16
Definition: tiff.h:71
void TIFFSwabShort(uint16 *wp)
Definition: tif_swab.c:36
TIFFBoolMethod tif_postencode
Definition: tiffiop.h:145
uint16 * td_colormap[3]
Definition: tif_dir.h:60
#define TIFF_BIGENDIAN
Definition: tiff.h:51
uint32 td_imagelength
Definition: tif_dir.h:41
#define TIFFTAG_XPOSITION
Definition: tiff.h:246
typedef long(ZCALLBACK *tell_file_func) OF((voidpf opaque
GLdouble n
uint32 * td_subifd
Definition: tif_dir.h:70
uint32 td_rowsperstrip
Definition: tif_dir.h:52
uint16 tiff_magic
Definition: tiff.h:96
float td_yposition
Definition: tif_dir.h:58
#define FIELD_PHOTOMETRIC
Definition: tif_dir.h:110
#define ResetFieldBit(fields, f)
Definition: tif_dir.h:172
void TIFFErrorExt(thandle_t fd, const char *module, const char *fmt,...)
Definition: tif_error.c:63
#define TIFFTAG_PHOTOMETRIC
Definition: tiff.h:199
tsize_t tif_rawdatasize
Definition: tiffiop.h:162
void TIFFSwabArrayOfLong(register uint32 *lp, register unsigned long n)
Definition: tif_swab.c:91
#define TIFFFieldSet(tif, field)
Definition: tif_dir.h:167
tsize_t tif_rawcc
Definition: tiffiop.h:164
#define FIELD_COMPRESSION
Definition: tif_dir.h:109
#define FIELD_SMINSAMPLEVALUE
Definition: tif_dir.h:126
#define FIELD_ROWSPERSTRIP
Definition: tif_dir.h:115
#define FALSE
Definition: ftobjs.h:57
#define TIFFTAG_TRANSFERFUNCTION
Definition: tiff.h:276
#define FIELD_INKNAMES
Definition: tif_dir.h:134
TIFFFieldInfo ** tif_fieldinfo
Definition: tiffiop.h:180
TIFFHeader tif_header
Definition: tiffiop.h:123
#define TIFFTAG_COMPRESSION
Definition: tiff.h:168
TIFFVoidMethod tif_cleanup
Definition: tiffiop.h:154
#define isTiled(tif)
Definition: tiffiop.h:189
uint32 tdir_count
Definition: tiff.h:119
unsigned long uint32
Definition: md5.h:41
if(!abbox) return FT_THROW(Invalid_Argument)
GLenum type
#define TIFF_BUFFERSETUP
Definition: tiffiop.h:103
uint16 td_samplesperpixel
Definition: tif_dir.h:51
int TIFFDataWidth(TIFFDataType type)
Definition: tif_dirinfo.c:620
float td_yresolution
Definition: tif_dir.h:55
typedef int
Definition: png.h:978
#define FIELD_EXTRASAMPLES
Definition: tif_dir.h:124
void TIFFSetWriteOffset(TIFF *tif, toff_t off)
Definition: tif_write.c:720
#define TIFFCvtNativeToIEEEDouble(tif, n, dp)
Definition: tif_dirwrite.c:36
void TIFFSwabArrayOfDouble(double *dp, register unsigned long n)
Definition: tif_swab.c:120
#define TIFF_VARIABLE2
Definition: tiffio.h:297
char * td_inknames
Definition: tif_dir.h:78
const TIFFFieldInfo * _TIFFFieldWithTag(TIFF *tif, ttag_t tag)
Definition: tif_dirinfo.c:771
GLubyte GLubyte GLubyte GLubyte w
short int16
Definition: tiff.h:69
int TIFFCheckpointDirectory(TIFF *tif)
Definition: tif_dirwrite.c:422
void TIFFSwabLong(uint32 *lp)
Definition: tif_swab.c:47
#define TIFFTAG_XRESOLUTION
Definition: tiff.h:240
#define FIELD_POSITION
Definition: tif_dir.h:104
uint32 toff_t
Definition: tiffio.h:68
TIFFDirectory tif_dir
Definition: tiffiop.h:122
#define FIELD_PAGENUMBER
Definition: tif_dir.h:120
#define FIELD_TILEDIMENSIONS
Definition: tif_dir.h:102
#define SeekOK(tif, off)
Definition: tiffiop.h:216
uint16 tdir_type
Definition: tiff.h:118
ttag_t field_tag
Definition: tiffio.h:302
uint16 td_compression
Definition: tif_dir.h:46
#define FieldSet(fields, f)
Definition: tif_dir.h:171
uint16 tdir_tag
Definition: tiff.h:117
void * _TIFFmalloc(tsize_t s)
Definition: tif_acorn.c:461
#define FIELD_COLORMAP
Definition: tif_dir.h:123
char * field_name
Definition: tiffio.h:309
toff_t tif_nextdiroff
Definition: tiffiop.h:118
#define ReadOK(file, buffer, len)
Definition: rdbmp.c:45
int TIFFGetField(TIFF *tif, ttag_t tag,...)
Definition: tif_dir.c:925
TIFFDataType field_type
Definition: tiffio.h:305
GLsizei samples
#define TIFFCvtNativeToIEEEFloat(tif, n, fp)
Definition: tif_dirwrite.c:35
void _TIFFfree(tdata_t p)
Definition: tif_acorn.c:467
GLdouble GLdouble t
Definition: tiff.h:151
int TIFFCreateDirectory(TIFF *tif)
Definition: tif_dir.c:1013
GLenum GLsizei GLenum GLenum const GLvoid * table
toff_t tif_subifdoff
Definition: tiffiop.h:133
#define FIELD_SAMPLEFORMAT
Definition: tif_dir.h:125
toff_t tif_dataoff
Definition: tiffiop.h:130
#define WriteRationalPair(type, tag1, v1, tag2, v2)
Definition: tif_dirwrite.c:62
unsigned short field_bit
Definition: tiffio.h:306
#define TIFF_INSUBIFD
Definition: tiffiop.h:112
#define TRUE
Definition: ftobjs.h:53
int TIFFFlushData1(TIFF *tif)
Definition: tif_write.c:696
#define TIFF_MYBUFFER
Definition: tiffiop.h:108
short field_writecount
Definition: tiffio.h:304
#define SEEK_SET
Definition: zconf.h:249
TIFFDataType
Definition: tiff.h:137
uint32 tiff_diroff
Definition: tiff.h:100
#define FIELD_SUBFILETYPE
Definition: tif_dir.h:107
toff_t tif_diroff
Definition: tiffiop.h:117
uint16 td_photometric
Definition: tif_dir.h:47
uint32 * td_stripbytecount
Definition: tif_dir.h:67