开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 打印编程 > 查看源码
tif_dir.c
资源名称：PopFaxPrinter_src_v2.01.zip　[点击查看]
上传用户：looem2003
上传日期：2014-07-20
资源大小：13733k
文件大小：39k
源码类别：

打印编程

开发平台：

Visual C++

tif_dir.c：源码内容
  1. /* $Id: tif_dir.c,v 1.72 2006/03/15 12:49:35 dron Exp $ */
  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.  */
  27. /*
  28.  * TIFF Library.
  29.  *
  30.  * Directory Tag Get & Set Routines.
  31.  * (and also some miscellaneous stuff)
  32.  */
  33. #include "tiffiop.h"
  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 */
  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)); }
  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;
  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. }
  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;
  100. if (slen > 0) {
  101. const char* ep = s+slen;
  102. const char* cp = s;
  103. for (; i > 0; i--) {
  104. for (; *cp != ''; cp++)
  105. if (cp >= ep)
  106. goto bad;
  107. cp++; /* skip  */
  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. }
  120. static int
  121. _TIFFVSetField(TIFF* tif, ttag_t tag, va_list ap)
  122. {
  123. static const char module[] = "_TIFFVSetField";
  125. TIFFDirectory* td = &tif->tif_dir;
  126. int status = 1;
  127. uint32 v32, i, v;
  128. char* s;
  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;
  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;
  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.             }
  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.             }
  415.             /*
  416.              * Grow the custom list if the entry was not found.
  417.              */
  418.             if(tv == NULL) {
  419. TIFFTagValue *new_customValues;
  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. }
  433. td->td_customValues = new_customValues;
  435.                 tv = td->td_customValues + (td->td_customValueCount-1);
  436.                 tv->info = fip;
  437.                 tv->value = NULL;
  438.                 tv->count = 0;
  439.             }
  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. }
  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;
  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. }
  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. }
  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. }
  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;
  632. va_start(ap, tag);
  633. status = TIFFVSetField(tif, tag, ap);
  634. va_end(ap);
  635. return (status);
  636. }
  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. }
  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;
  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.             }
  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;
  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;
  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. }
  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;
  930. va_start(ap, tag);
  931. status = TIFFVGetField(tif, tag, ap);
  932. va_end(ap);
  933. return (status);
  934. }
  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. }
  950. #define CleanupField(member) {
  951.     if (td->member) {
  952. _TIFFfree(td->member);
  953. td->member = 0;
  954.     }
  955. }
  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;
  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);
  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. }
  987. td->td_customValueCount = 0;
  988. CleanupField(td_customValues);
  989. }
  990. #undef CleanupField
  992. /*
  993.  * Client Tag extension support (from Niles Ritter).
  994.  */
  995. static TIFFExtendProc _TIFFextender = (TIFFExtendProc) NULL;
  997. TIFFExtendProc
  998. TIFFSetTagExtender(TIFFExtendProc extender)
  999. {
  1000. TIFFExtendProc prev = _TIFFextender;
  1001. _TIFFextender = extender;
  1002. return (prev);
  1003. }
  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;
  1022.     return 0;
  1023. }
  1025. /*
  1026.  * Setup a default directory structure.
  1027.  */
  1028. int
  1029. TIFFDefaultDirectory(TIFF* tif)
  1030. {
  1031. register TIFFDirectory* td = &tif->tif_dir;
  1033. size_t tiffFieldInfoCount;
  1034. const TIFFFieldInfo *tiffFieldInfo =
  1035. _TIFFGetFieldInfo(&tiffFieldInfoCount);
  1036. _TIFFSetupFieldInfo(tif, tiffFieldInfo, tiffFieldInfoCount);
  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;
  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;
  1084. return (1);
  1085. }
  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. }
  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. }
  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;
  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. }
  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. }
  1206. /*
  1207.  * Return file offset of the current directory.
  1208.  */
  1209. uint32
  1210. TIFFCurrentDirOffset(TIFF* tif)
  1211. {
  1212. return (tif->tif_diroff);
  1213. }
  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. }
  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;
  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. }
  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 */
  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. }
  1350. /* vim: set ts=8 sts=8 sw=8 noet: */