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

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

打印编程

开发平台：

Visual C++

tif_dirread.c：源码内容
  1. /* $Id: tif_dirread.c,v 1.82 2006/03/16 12:24:53 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 Read Support Routines.
  31.  */
  32. #include "tiffiop.h"
  34. #define IGNORE 0 /* tag placeholder used below */
  36. #ifdef HAVE_IEEEFP
  37. # define TIFFCvtIEEEFloatToNative(tif, n, fp)
  38. # define TIFFCvtIEEEDoubleToNative(tif, n, dp)
  39. #else
  40. extern void TIFFCvtIEEEFloatToNative(TIFF*, uint32, float*);
  41. extern void TIFFCvtIEEEDoubleToNative(TIFF*, uint32, double*);
  42. #endif
  44. static int EstimateStripByteCounts(TIFF*, TIFFDirEntry*, uint16);
  45. static void MissingRequired(TIFF*, const char*);
  46. static int CheckDirCount(TIFF*, TIFFDirEntry*, uint32);
  47. static tsize_t TIFFFetchData(TIFF*, TIFFDirEntry*, char*);
  48. static tsize_t TIFFFetchString(TIFF*, TIFFDirEntry*, char*);
  49. static float TIFFFetchRational(TIFF*, TIFFDirEntry*);
  50. static int TIFFFetchNormalTag(TIFF*, TIFFDirEntry*);
  51. static int TIFFFetchPerSampleShorts(TIFF*, TIFFDirEntry*, uint16*);
  52. static int TIFFFetchPerSampleLongs(TIFF*, TIFFDirEntry*, uint32*);
  53. static int TIFFFetchPerSampleAnys(TIFF*, TIFFDirEntry*, double*);
  54. static int TIFFFetchShortArray(TIFF*, TIFFDirEntry*, uint16*);
  55. static int TIFFFetchStripThing(TIFF*, TIFFDirEntry*, long, uint32**);
  56. static int TIFFFetchRefBlackWhite(TIFF*, TIFFDirEntry*);
  57. static float TIFFFetchFloat(TIFF*, TIFFDirEntry*);
  58. static int TIFFFetchFloatArray(TIFF*, TIFFDirEntry*, float*);
  59. static int TIFFFetchDoubleArray(TIFF*, TIFFDirEntry*, double*);
  60. static int TIFFFetchAnyArray(TIFF*, TIFFDirEntry*, double*);
  61. static int TIFFFetchShortPair(TIFF*, TIFFDirEntry*);
  62. static void ChopUpSingleUncompressedStrip(TIFF*);
  64. /*
  65.  * Read the next TIFF directory from a file
  66.  * and convert it to the internal format.
  67.  * We read directories sequentially.
  68.  */
  69. int
  70. TIFFReadDirectory(TIFF* tif)
  71. {
  72. static const char module[] = "TIFFReadDirectory";
  74. int n;
  75. TIFFDirectory* td;
  76. TIFFDirEntry *dp, *dir = NULL;
  77. uint16 iv;
  78. uint32 v;
  79. const TIFFFieldInfo* fip;
  80. size_t fix;
  81. uint16 dircount;
  82. toff_t nextdiroff;
  83. int diroutoforderwarning = 0;
  84. toff_t* new_dirlist;
  86. tif->tif_diroff = tif->tif_nextdiroff;
  87. if (tif->tif_diroff == 0) /* no more directories */
  88. return (0);
  90. /*
  91.  * XXX: Trick to prevent IFD looping. The one can create TIFF file
  92.  * with looped directory pointers. We will maintain a list of already
  93.  * seen directories and check every IFD offset against this list.
  94.  */
  95. for (n = 0; n < tif->tif_dirnumber; n++) {
  96. if (tif->tif_dirlist[n] == tif->tif_diroff)
  97. return (0);
  98. }
  99. tif->tif_dirnumber++;
  100. new_dirlist = (toff_t *)_TIFFrealloc(tif->tif_dirlist,
  101. tif->tif_dirnumber * sizeof(toff_t));
  102. if (!new_dirlist) {
  103. TIFFErrorExt(tif->tif_clientdata, module,
  104.   "%s: Failed to allocate space for IFD list",
  105.   tif->tif_name);
  106. return (0);
  107. }
  108. tif->tif_dirlist = new_dirlist;
  109. tif->tif_dirlist[tif->tif_dirnumber - 1] = tif->tif_diroff;
  111. /*
  112.  * Cleanup any previous compression state.
  113.  */
  114. (*tif->tif_cleanup)(tif);
  115. tif->tif_curdir++;
  116. nextdiroff = 0;
  117. if (!isMapped(tif)) {
  118. if (!SeekOK(tif, tif->tif_diroff)) {
  119. TIFFErrorExt(tif->tif_clientdata, module,
  120.     "%s: Seek error accessing TIFF directory",
  121.                             tif->tif_name);
  122. return (0);
  123. }
  124. if (!ReadOK(tif, &dircount, sizeof (uint16))) {
  125. TIFFErrorExt(tif->tif_clientdata, module,
  126.     "%s: Can not read TIFF directory count",
  127.                             tif->tif_name);
  128. return (0);
  129. }
  130. if (tif->tif_flags & TIFF_SWAB)
  131. TIFFSwabShort(&dircount);
  132. dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
  133.        sizeof (TIFFDirEntry),
  134. "to read TIFF directory");
  135. if (dir == NULL)
  136. return (0);
  137. if (!ReadOK(tif, dir, dircount*sizeof (TIFFDirEntry))) {
  138. TIFFErrorExt(tif->tif_clientdata, module,
  139.                                   "%.100s: Can not read TIFF directory",
  140.                                   tif->tif_name);
  141. goto bad;
  142. }
  143. /*
  144.  * Read offset to next directory for sequential scans.
  145.  */
  146. (void) ReadOK(tif, &nextdiroff, sizeof (uint32));
  147. } else {
  148. toff_t off = tif->tif_diroff;
  150. if (off + sizeof (uint16) > tif->tif_size) {
  151. TIFFErrorExt(tif->tif_clientdata, module,
  152.     "%s: Can not read TIFF directory count",
  153.                             tif->tif_name);
  154. return (0);
  155. } else
  156. _TIFFmemcpy(&dircount, tif->tif_base + off, sizeof (uint16));
  157. off += sizeof (uint16);
  158. if (tif->tif_flags & TIFF_SWAB)
  159. TIFFSwabShort(&dircount);
  160. dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
  161.        sizeof (TIFFDirEntry),
  162. "to read TIFF directory");
  163. if (dir == NULL)
  164. return (0);
  165. if (off + dircount*sizeof (TIFFDirEntry) > tif->tif_size) {
  166. TIFFErrorExt(tif->tif_clientdata, module,
  167.                                   "%s: Can not read TIFF directory",
  168.                                   tif->tif_name);
  169. goto bad;
  170. } else {
  171. _TIFFmemcpy(dir, tif->tif_base + off,
  172.     dircount*sizeof (TIFFDirEntry));
  173. }
  174. off += dircount* sizeof (TIFFDirEntry);
  175. if (off + sizeof (uint32) <= tif->tif_size)
  176. _TIFFmemcpy(&nextdiroff, tif->tif_base+off, sizeof (uint32));
  177. }
  178. if (tif->tif_flags & TIFF_SWAB)
  179. TIFFSwabLong(&nextdiroff);
  180. tif->tif_nextdiroff = nextdiroff;
  182. tif->tif_flags &= ~TIFF_BEENWRITING; /* reset before new dir */
  183. /*
  184.  * Setup default value and then make a pass over
  185.  * the fields to check type and tag information,
  186.  * and to extract info required to size data
  187.  * structures.  A second pass is made afterwards
  188.  * to read in everthing not taken in the first pass.
  189.  */
  190. td = &tif->tif_dir;
  191. /* free any old stuff and reinit */
  192. TIFFFreeDirectory(tif);
  193. TIFFDefaultDirectory(tif);
  194. /*
  195.  * Electronic Arts writes gray-scale TIFF files
  196.  * without a PlanarConfiguration directory entry.
  197.  * Thus we setup a default value here, even though
  198.  * the TIFF spec says there is no default value.
  199.  */
  200. TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
  202. /*
  203.  * Sigh, we must make a separate pass through the
  204.  * directory for the following reason:
  205.  *
  206.  * We must process the Compression tag in the first pass
  207.  * in order to merge in codec-private tag definitions (otherwise
  208.  * we may get complaints about unknown tags).  However, the
  209.  * Compression tag may be dependent on the SamplesPerPixel
  210.  * tag value because older TIFF specs permited Compression
  211.  * to be written as a SamplesPerPixel-count tag entry.
  212.  * Thus if we don't first figure out the correct SamplesPerPixel
  213.  * tag value then we may end up ignoring the Compression tag
  214.  * value because it has an incorrect count value (if the
  215.  * true value of SamplesPerPixel is not 1).
  216.  *
  217.  * It sure would have been nice if Aldus had really thought
  218.  * this stuff through carefully.
  219.  */ 
  220. for (dp = dir, n = dircount; n > 0; n--, dp++) {
  221. if (tif->tif_flags & TIFF_SWAB) {
  222. TIFFSwabArrayOfShort(&dp->tdir_tag, 2);
  223. TIFFSwabArrayOfLong(&dp->tdir_count, 2);
  224. }
  225. if (dp->tdir_tag == TIFFTAG_SAMPLESPERPIXEL) {
  226. if (!TIFFFetchNormalTag(tif, dp))
  227. goto bad;
  228. dp->tdir_tag = IGNORE;
  229. }
  230. }
  231. /*
  232.  * First real pass over the directory.
  233.  */
  234. fix = 0;
  235. for (dp = dir, n = dircount; n > 0; n--, dp++) {
  237. if (fix >= tif->tif_nfields || dp->tdir_tag == IGNORE)
  238. continue;
  239.                
  240. /*
  241.  * Silicon Beach (at least) writes unordered
  242.  * directory tags (violating the spec).  Handle
  243.  * it here, but be obnoxious (maybe they'll fix it?).
  244.  */
  245. if (dp->tdir_tag < tif->tif_fieldinfo[fix]->field_tag) {
  246. if (!diroutoforderwarning) {
  247. TIFFWarningExt(tif->tif_clientdata, module,
  248. "%s: invalid TIFF directory; tags are not sorted in ascending order",
  249.        tif->tif_name);
  250. diroutoforderwarning = 1;
  251. }
  252. fix = 0; /* O(n^2) */
  253. }
  254. while (fix < tif->tif_nfields &&
  255.        tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
  256. fix++;
  257. if (fix >= tif->tif_nfields ||
  258.     tif->tif_fieldinfo[fix]->field_tag != dp->tdir_tag) {
  260. TIFFWarningExt(tif->tif_clientdata,
  261.        module,
  262.                         "%s: unknown field with tag %d (0x%x) encountered",
  263.        tif->tif_name,
  264.        dp->tdir_tag,
  265.        dp->tdir_tag,
  266.        dp->tdir_type);
  268.                     TIFFMergeFieldInfo(tif,
  269.                                        _TIFFCreateAnonFieldInfo(tif,
  270. dp->tdir_tag,
  271. (TIFFDataType) dp->tdir_type),
  272.        1 );
  273.                     fix = 0;
  274.                     while (fix < tif->tif_nfields &&
  275.                            tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
  276. fix++;
  277. }
  278. /*
  279.  * Null out old tags that we ignore.
  280.  */
  281. if (tif->tif_fieldinfo[fix]->field_bit == FIELD_IGNORE) {
  282. ignore:
  283. dp->tdir_tag = IGNORE;
  284. continue;
  285. }
  286. /*
  287.  * Check data type.
  288.  */
  289. fip = tif->tif_fieldinfo[fix];
  290. while (dp->tdir_type != (unsigned short) fip->field_type
  291.                        && fix < tif->tif_nfields) {
  292. if (fip->field_type == TIFF_ANY) /* wildcard */
  293. break;
  294.                         fip = tif->tif_fieldinfo[++fix];
  295. if (fix >= tif->tif_nfields ||
  296.     fip->field_tag != dp->tdir_tag) {
  297. TIFFWarningExt(tif->tif_clientdata, module,
  298. "%s: wrong data type %d for "%s"; tag ignored",
  299.     tif->tif_name, dp->tdir_type,
  300.     tif->tif_fieldinfo[fix-1]->field_name);
  301. goto ignore;
  302. }
  303. }
  304. /*
  305.  * Check count if known in advance.
  306.  */
  307. if (fip->field_readcount != TIFF_VARIABLE
  308.     && fip->field_readcount != TIFF_VARIABLE2) {
  309. uint32 expected = (fip->field_readcount == TIFF_SPP) ?
  310.     (uint32) td->td_samplesperpixel :
  311.     (uint32) fip->field_readcount;
  312. if (!CheckDirCount(tif, dp, expected))
  313. goto ignore;
  314. }
  316. switch (dp->tdir_tag) {
  317. case TIFFTAG_COMPRESSION:
  318. /*
  319.  * The 5.0 spec says the Compression tag has
  320.  * one value, while earlier specs say it has
  321.  * one value per sample.  Because of this, we
  322.  * accept the tag if one value is supplied.
  323.  */
  324. if (dp->tdir_count == 1) {
  325. v = TIFFExtractData(tif,
  326.     dp->tdir_type, dp->tdir_offset);
  327. if (!TIFFSetField(tif, dp->tdir_tag, (uint16)v))
  328. goto bad;
  329. break;
  330. /* XXX: workaround for broken TIFFs */
  331. } else if (dp->tdir_type == TIFF_LONG) {
  332. if (!TIFFFetchPerSampleLongs(tif, dp, &v) ||
  333.     !TIFFSetField(tif, dp->tdir_tag, (uint16)v))
  334. goto bad;
  335. } else {
  336. if (!TIFFFetchPerSampleShorts(tif, dp, &iv)
  337.     || !TIFFSetField(tif, dp->tdir_tag, iv))
  338. goto bad;
  339. }
  340. dp->tdir_tag = IGNORE;
  341. break;
  342. case TIFFTAG_STRIPOFFSETS:
  343. case TIFFTAG_STRIPBYTECOUNTS:
  344. case TIFFTAG_TILEOFFSETS:
  345. case TIFFTAG_TILEBYTECOUNTS:
  346. TIFFSetFieldBit(tif, fip->field_bit);
  347. break;
  348. case TIFFTAG_IMAGEWIDTH:
  349. case TIFFTAG_IMAGELENGTH:
  350. case TIFFTAG_IMAGEDEPTH:
  351. case TIFFTAG_TILELENGTH:
  352. case TIFFTAG_TILEWIDTH:
  353. case TIFFTAG_TILEDEPTH:
  354. case TIFFTAG_PLANARCONFIG:
  355. case TIFFTAG_ROWSPERSTRIP:
  356. case TIFFTAG_EXTRASAMPLES:
  357. if (!TIFFFetchNormalTag(tif, dp))
  358. goto bad;
  359. dp->tdir_tag = IGNORE;
  360. break;
  361. }
  362. }
  364. /*
  365.  * Allocate directory structure and setup defaults.
  366.  */
  367. if (!TIFFFieldSet(tif, FIELD_IMAGEDIMENSIONS)) {
  368. MissingRequired(tif, "ImageLength");
  369. goto bad;
  370. }
  371. /* 
  372.    * Setup appropriate structures (by strip or by tile)
  373.  */
  374. if (!TIFFFieldSet(tif, FIELD_TILEDIMENSIONS)) {
  375. td->td_nstrips = TIFFNumberOfStrips(tif);
  376. td->td_tilewidth = td->td_imagewidth;
  377. td->td_tilelength = td->td_rowsperstrip;
  378. td->td_tiledepth = td->td_imagedepth;
  379. tif->tif_flags &= ~TIFF_ISTILED;
  380. } else {
  381. td->td_nstrips = TIFFNumberOfTiles(tif);
  382. tif->tif_flags |= TIFF_ISTILED;
  383. }
  384. if (!td->td_nstrips) {
  385. TIFFErrorExt(tif->tif_clientdata, module,
  386.      "%s: cannot handle zero number of %s",
  387.      tif->tif_name, isTiled(tif) ? "tiles" : "strips");
  388. goto bad;
  389. }
  390. td->td_stripsperimage = td->td_nstrips;
  391. if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
  392. td->td_stripsperimage /= td->td_samplesperpixel;
  393. if (!TIFFFieldSet(tif, FIELD_STRIPOFFSETS)) {
  394. MissingRequired(tif,
  395. isTiled(tif) ? "TileOffsets" : "StripOffsets");
  396. goto bad;
  397. }
  399. /*
  400.  * Second pass: extract other information.
  401.  */
  402. for (dp = dir, n = dircount; n > 0; n--, dp++) {
  403. if (dp->tdir_tag == IGNORE)
  404. continue;
  405. switch (dp->tdir_tag) {
  406. case TIFFTAG_MINSAMPLEVALUE:
  407. case TIFFTAG_MAXSAMPLEVALUE:
  408. case TIFFTAG_BITSPERSAMPLE:
  409. case TIFFTAG_DATATYPE:
  410. case TIFFTAG_SAMPLEFORMAT:
  411. /*
  412.  * The 5.0 spec says the Compression tag has
  413.  * one value, while earlier specs say it has
  414.  * one value per sample.  Because of this, we
  415.  * accept the tag if one value is supplied.
  416.  *
  417.                          * The MinSampleValue, MaxSampleValue, BitsPerSample
  418.                          * DataType and SampleFormat tags are supposed to be
  419.                          * written as one value/sample, but some vendors
  420.                          * incorrectly write one value only -- so we accept
  421.                          * that as well (yech). Other vendors write correct
  422.  * value for NumberOfSamples, but incorrect one for
  423.  * BitsPerSample and friends, and we will read this
  424.  * too.
  425.  */
  426. if (dp->tdir_count == 1) {
  427. v = TIFFExtractData(tif,
  428.     dp->tdir_type, dp->tdir_offset);
  429. if (!TIFFSetField(tif, dp->tdir_tag, (uint16)v))
  430. goto bad;
  431. /* XXX: workaround for broken TIFFs */
  432. } else if (dp->tdir_tag == TIFFTAG_BITSPERSAMPLE
  433.    && dp->tdir_type == TIFF_LONG) {
  434. if (!TIFFFetchPerSampleLongs(tif, dp, &v) ||
  435.     !TIFFSetField(tif, dp->tdir_tag, (uint16)v))
  436. goto bad;
  437. } else {
  438. if (!TIFFFetchPerSampleShorts(tif, dp, &iv) ||
  439.     !TIFFSetField(tif, dp->tdir_tag, iv))
  440. goto bad;
  441. }
  442. break;
  443. case TIFFTAG_SMINSAMPLEVALUE:
  444. case TIFFTAG_SMAXSAMPLEVALUE:
  445. {
  446. double dv = 0.0;
  447. if (!TIFFFetchPerSampleAnys(tif, dp, &dv) ||
  448.     !TIFFSetField(tif, dp->tdir_tag, dv))
  449. goto bad;
  450. }
  451. break;
  452. case TIFFTAG_STRIPOFFSETS:
  453. case TIFFTAG_TILEOFFSETS:
  454. if (!TIFFFetchStripThing(tif, dp,
  455.     td->td_nstrips, &td->td_stripoffset))
  456. goto bad;
  457. break;
  458. case TIFFTAG_STRIPBYTECOUNTS:
  459. case TIFFTAG_TILEBYTECOUNTS:
  460. if (!TIFFFetchStripThing(tif, dp,
  461.     td->td_nstrips, &td->td_stripbytecount))
  462. goto bad;
  463. break;
  464. case TIFFTAG_COLORMAP:
  465. case TIFFTAG_TRANSFERFUNCTION:
  466. {
  467. char* cp;
  468. /*
  469.  * TransferFunction can have either 1x or 3x
  470.  * data values; Colormap can have only 3x
  471.  * items.
  472.  */
  473. v = 1L<<td->td_bitspersample;
  474. if (dp->tdir_tag == TIFFTAG_COLORMAP ||
  475.     dp->tdir_count != v) {
  476. if (!CheckDirCount(tif, dp, 3 * v))
  477. break;
  478. }
  479. v *= sizeof(uint16);
  480. cp = (char *)_TIFFCheckMalloc(tif,
  481.       dp->tdir_count,
  482.       sizeof (uint16),
  483. "to read "TransferFunction" tag");
  484. if (cp != NULL) {
  485. if (TIFFFetchData(tif, dp, cp)) {
  486. /*
  487.  * This deals with there being
  488.  * only one array to apply to
  489.  * all samples.
  490.  */
  491. uint32 c = 1L << td->td_bitspersample;
  492. if (dp->tdir_count == c)
  493. v = 0L;
  494. TIFFSetField(tif, dp->tdir_tag,
  495.     cp, cp+v, cp+2*v);
  496. }
  497. _TIFFfree(cp);
  498. }
  499. break;
  500. }
  501. case TIFFTAG_PAGENUMBER:
  502. case TIFFTAG_HALFTONEHINTS:
  503. case TIFFTAG_YCBCRSUBSAMPLING:
  504. case TIFFTAG_DOTRANGE:
  505. (void) TIFFFetchShortPair(tif, dp);
  506. break;
  507. case TIFFTAG_REFERENCEBLACKWHITE:
  508. (void) TIFFFetchRefBlackWhite(tif, dp);
  509. break;
  510. /* BEGIN REV 4.0 COMPATIBILITY */
  511. case TIFFTAG_OSUBFILETYPE:
  512. v = 0L;
  513. switch (TIFFExtractData(tif, dp->tdir_type,
  514.     dp->tdir_offset)) {
  515. case OFILETYPE_REDUCEDIMAGE:
  516. v = FILETYPE_REDUCEDIMAGE;
  517. break;
  518. case OFILETYPE_PAGE:
  519. v = FILETYPE_PAGE;
  520. break;
  521. }
  522. if (v)
  523. TIFFSetField(tif, TIFFTAG_SUBFILETYPE, v);
  524. break;
  525. /* END REV 4.0 COMPATIBILITY */
  526. default:
  527. (void) TIFFFetchNormalTag(tif, dp);
  528. break;
  529. }
  530. }
  531. /*
  532.  * Verify Palette image has a Colormap.
  533.  */
  534. if (td->td_photometric == PHOTOMETRIC_PALETTE &&
  535.     !TIFFFieldSet(tif, FIELD_COLORMAP)) {
  536. MissingRequired(tif, "Colormap");
  537. goto bad;
  538. }
  539. /*
  540.  * Attempt to deal with a missing StripByteCounts tag.
  541.  */
  542. if (!TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS)) {
  543. /*
  544.  * Some manufacturers violate the spec by not giving
  545.  * the size of the strips.  In this case, assume there
  546.  * is one uncompressed strip of data.
  547.  */
  548. if ((td->td_planarconfig == PLANARCONFIG_CONTIG &&
  549.     td->td_nstrips > 1) ||
  550.     (td->td_planarconfig == PLANARCONFIG_SEPARATE &&
  551.      td->td_nstrips != td->td_samplesperpixel)) {
  552.     MissingRequired(tif, "StripByteCounts");
  553.     goto bad;
  554. }
  555. TIFFWarningExt(tif->tif_clientdata, module,
  556. "%s: TIFF directory is missing required "
  557. ""%s" field, calculating from imagelength",
  558. tif->tif_name,
  559.         _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
  560. if (EstimateStripByteCounts(tif, dir, dircount) < 0)
  561.     goto bad;
  562. /* 
  563.  * Assume we have wrong StripByteCount value (in case of single strip) in
  564.  * following cases:
  565.  *   - it is equal to zero along with StripOffset;
  566.  *   - it is larger than file itself (in case of uncompressed image);
  567.  *   - it is smaller than the size of the bytes per row multiplied on the
  568.  *     number of rows.  The last case should not be checked in the case of
  569.  *     writing new image, because we may do not know the exact strip size
  570.  *     until the whole image will be written and directory dumped out.
  571.  */
  572. #define BYTECOUNTLOOKSBAD 
  573.     ( (td->td_stripbytecount[0] == 0 && td->td_stripoffset[0] != 0) || 
  574.       (td->td_compression == COMPRESSION_NONE && 
  575.        td->td_stripbytecount[0] > TIFFGetFileSize(tif) - td->td_stripoffset[0]) || 
  576.       (tif->tif_mode == O_RDONLY && 
  577.        td->td_compression == COMPRESSION_NONE && 
  578.        td->td_stripbytecount[0] < TIFFScanlineSize(tif) * td->td_imagelength) )
  580. } else if (td->td_nstrips == 1 
  581.                    && td->td_stripoffset[0] != 0 
  582.                    && BYTECOUNTLOOKSBAD) {
  583. /*
  584.  * XXX: Plexus (and others) sometimes give a value of zero for
  585.  * a tag when they don't know what the correct value is!  Try
  586.  * and handle the simple case of estimating the size of a one
  587.  * strip image.
  588.  */
  589. TIFFWarningExt(tif->tif_clientdata, module,
  590. "%s: Bogus "%s" field, ignoring and calculating from imagelength",
  591.                             tif->tif_name,
  592.             _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
  593. if(EstimateStripByteCounts(tif, dir, dircount) < 0)
  594.     goto bad;
  595. } else if (td->td_planarconfig == PLANARCONFIG_CONTIG
  596.    && td->td_nstrips > 2
  597.    && td->td_compression == COMPRESSION_NONE
  598.    && td->td_stripbytecount[0] != td->td_stripbytecount[1]) {
  599. /*
  600.  * XXX: Some vendors fill StripByteCount array with absolutely
  601.  * wrong values (it can be equal to StripOffset array, for
  602.  * example). Catch this case here.
  603.  */
  604. TIFFWarningExt(tif->tif_clientdata, module,
  605. "%s: Wrong "%s" field, ignoring and calculating from imagelength",
  606.                             tif->tif_name,
  607.             _TIFFFieldWithTag(tif,TIFFTAG_STRIPBYTECOUNTS)->field_name);
  608. if (EstimateStripByteCounts(tif, dir, dircount) < 0)
  609.     goto bad;
  610. }
  611. if (dir) {
  612. _TIFFfree((char *)dir);
  613. dir = NULL;
  614. }
  615. if (!TIFFFieldSet(tif, FIELD_MAXSAMPLEVALUE))
  616. td->td_maxsamplevalue = (uint16)((1L<<td->td_bitspersample)-1);
  617. /*
  618.  * Setup default compression scheme.
  619.  */
  621. /*
  622.  * XXX: We can optimize checking for the strip bounds using the sorted
  623.  * bytecounts array. See also comments for TIFFAppendToStrip()
  624.  * function in tif_write.c.
  625.  */
  626. if (td->td_nstrips > 1) {
  627. tstrip_t strip;
  629. td->td_stripbytecountsorted = 1;
  630. for (strip = 1; strip < td->td_nstrips; strip++) {
  631. if (td->td_stripoffset[strip - 1] >
  632.     td->td_stripoffset[strip]) {
  633. td->td_stripbytecountsorted = 0;
  634. break;
  635. }
  636. }
  637. }
  639. if (!TIFFFieldSet(tif, FIELD_COMPRESSION))
  640. TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
  641.         /*
  642.          * Some manufacturers make life difficult by writing
  643.  * large amounts of uncompressed data as a single strip.
  644.  * This is contrary to the recommendations of the spec.
  645.          * The following makes an attempt at breaking such images
  646.  * into strips closer to the recommended 8k bytes.  A
  647.  * side effect, however, is that the RowsPerStrip tag
  648.  * value may be changed.
  649.          */
  650. if (td->td_nstrips == 1 && td->td_compression == COMPRESSION_NONE &&
  651.     (tif->tif_flags & (TIFF_STRIPCHOP|TIFF_ISTILED)) == TIFF_STRIPCHOP)
  652. ChopUpSingleUncompressedStrip(tif);
  654. /*
  655.  * Reinitialize i/o since we are starting on a new directory.
  656.  */
  657. tif->tif_row = (uint32) -1;
  658. tif->tif_curstrip = (tstrip_t) -1;
  659. tif->tif_col = (uint32) -1;
  660. tif->tif_curtile = (ttile_t) -1;
  661. tif->tif_tilesize = (tsize_t) -1;
  663. tif->tif_scanlinesize = TIFFScanlineSize(tif);
  664. if (!tif->tif_scanlinesize) {
  665. TIFFErrorExt(tif->tif_clientdata, module, "%s: cannot handle zero scanline size",
  666.   tif->tif_name);
  667. return (0);
  668. }
  670. if (isTiled(tif)) {
  671. tif->tif_tilesize = TIFFTileSize(tif);
  672. if (!tif->tif_tilesize) {
  673. TIFFErrorExt(tif->tif_clientdata, module, "%s: cannot handle zero tile size",
  674.   tif->tif_name);
  675. return (0);
  676. }
  677. } else {
  678. if (!TIFFStripSize(tif)) {
  679. TIFFErrorExt(tif->tif_clientdata, module, "%s: cannot handle zero strip size",
  680.   tif->tif_name);
  681. return (0);
  682. }
  683. }
  684. return (1);
  685. bad:
  686. if (dir)
  687. _TIFFfree(dir);
  688. return (0);
  689. }
  691. /* 
  692.  * Read custom directory from the arbitarry offset.
  693.  * The code is very similar to TIFFReadDirectory().
  694.  */
  695. int
  696. TIFFReadCustomDirectory(TIFF* tif, toff_t diroff,
  697. const TIFFFieldInfo info[], size_t n)
  698. {
  699. static const char module[] = "TIFFReadCustomDirectory";
  701. TIFFDirectory* td = &tif->tif_dir;
  702. TIFFDirEntry *dp, *dir = NULL;
  703. const TIFFFieldInfo* fip;
  704. size_t fix;
  705. uint16 i, dircount;
  707. _TIFFSetupFieldInfo(tif, info, n);
  709. tif->tif_diroff = diroff;
  711. if (!isMapped(tif)) {
  712. if (!SeekOK(tif, diroff)) {
  713. TIFFErrorExt(tif->tif_clientdata, module,
  714.     "%s: Seek error accessing TIFF directory",
  715.                             tif->tif_name);
  716. return (0);
  717. }
  718. if (!ReadOK(tif, &dircount, sizeof (uint16))) {
  719. TIFFErrorExt(tif->tif_clientdata, module,
  720.     "%s: Can not read TIFF directory count",
  721.                             tif->tif_name);
  722. return (0);
  723. }
  724. if (tif->tif_flags & TIFF_SWAB)
  725. TIFFSwabShort(&dircount);
  726. dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
  727.        sizeof (TIFFDirEntry),
  728. "to read TIFF custom directory");
  729. if (dir == NULL)
  730. return (0);
  731. if (!ReadOK(tif, dir, dircount * sizeof (TIFFDirEntry))) {
  732. TIFFErrorExt(tif->tif_clientdata, module,
  733.                                   "%.100s: Can not read TIFF directory",
  734.                                   tif->tif_name);
  735. goto bad;
  736. }
  737. } else {
  738. toff_t off = diroff;
  740. if (off + sizeof (uint16) > tif->tif_size) {
  741. TIFFErrorExt(tif->tif_clientdata, module,
  742.     "%s: Can not read TIFF directory count",
  743.                             tif->tif_name);
  744. return (0);
  745. } else
  746. _TIFFmemcpy(&dircount, tif->tif_base + off, sizeof (uint16));
  747. off += sizeof (uint16);
  748. if (tif->tif_flags & TIFF_SWAB)
  749. TIFFSwabShort(&dircount);
  750. dir = (TIFFDirEntry *)_TIFFCheckMalloc(tif, dircount,
  751.        sizeof (TIFFDirEntry),
  752. "to read TIFF custom directory");
  753. if (dir == NULL)
  754. return (0);
  755. if (off + dircount * sizeof (TIFFDirEntry) > tif->tif_size) {
  756. TIFFErrorExt(tif->tif_clientdata, module,
  757.                                   "%s: Can not read TIFF directory",
  758.                                   tif->tif_name);
  759. goto bad;
  760. } else {
  761. _TIFFmemcpy(dir, tif->tif_base + off,
  762.     dircount * sizeof (TIFFDirEntry));
  763. }
  764. }
  766. TIFFFreeDirectory(tif);
  768. fix = 0;
  769. for (dp = dir, i = dircount; i > 0; i--, dp++) {
  770. if (tif->tif_flags & TIFF_SWAB) {
  771. TIFFSwabArrayOfShort(&dp->tdir_tag, 2);
  772. TIFFSwabArrayOfLong(&dp->tdir_count, 2);
  773. }
  775. if (fix >= tif->tif_nfields || dp->tdir_tag == IGNORE)
  776. continue;
  778. while (fix < tif->tif_nfields &&
  779.        tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
  780. fix++;
  782. if (fix >= tif->tif_nfields ||
  783.     tif->tif_fieldinfo[fix]->field_tag != dp->tdir_tag) {
  785. TIFFWarningExt(tif->tif_clientdata, module,
  786.                         "%s: unknown field with tag %d (0x%x) encountered",
  787.     tif->tif_name, dp->tdir_tag, dp->tdir_tag,
  788.     dp->tdir_type);
  790. TIFFMergeFieldInfo(tif,
  791.    _TIFFCreateAnonFieldInfo(tif,
  792. dp->tdir_tag,
  793. (TIFFDataType)dp->tdir_type),
  794.    1);
  796. fix = 0;
  797. while (fix < tif->tif_nfields &&
  798.        tif->tif_fieldinfo[fix]->field_tag < dp->tdir_tag)
  799. fix++;
  800. }
  801. /*
  802.  * Null out old tags that we ignore.
  803.  */
  804. if (tif->tif_fieldinfo[fix]->field_bit == FIELD_IGNORE) {
  805. ignore:
  806. dp->tdir_tag = IGNORE;
  807. continue;
  808. }
  809. /*
  810.  * Check data type.
  811.  */
  812. fip = tif->tif_fieldinfo[fix];
  813. while (dp->tdir_type != (unsigned short) fip->field_type
  814.                        && fix < tif->tif_nfields) {
  815. if (fip->field_type == TIFF_ANY) /* wildcard */
  816. break;
  817.                         fip = tif->tif_fieldinfo[++fix];
  818. if (fix >= tif->tif_nfields ||
  819.     fip->field_tag != dp->tdir_tag) {
  820. TIFFWarningExt(tif->tif_clientdata, module,
  821. "%s: wrong data type %d for "%s"; tag ignored",
  822.     tif->tif_name, dp->tdir_type,
  823.     tif->tif_fieldinfo[fix-1]->field_name);
  824. goto ignore;
  825. }
  826. }
  827. /*
  828.  * Check count if known in advance.
  829.  */
  830. if (fip->field_readcount != TIFF_VARIABLE
  831.     && fip->field_readcount != TIFF_VARIABLE2) {
  832. uint32 expected = (fip->field_readcount == TIFF_SPP) ?
  833.     (uint32) td->td_samplesperpixel :
  834.     (uint32) fip->field_readcount;
  835. if (!CheckDirCount(tif, dp, expected))
  836. goto ignore;
  837. }
  839. (void) TIFFFetchNormalTag(tif, dp);
  840. }
  842. if (dir)
  843. _TIFFfree(dir);
  844. return 1;
  846. bad:
  847. if (dir)
  848. _TIFFfree(dir);
  849. return 0;
  850. }
  852. /*
  853.  * EXIF is important special case of custom IFD, so we have a special
  854.  * function to read it.
  855.  */
  856. int
  857. TIFFReadEXIFDirectory(TIFF* tif, toff_t diroff)
  858. {
  859. size_t exifFieldInfoCount;
  860. const TIFFFieldInfo *exifFieldInfo =
  861. _TIFFGetExifFieldInfo(&exifFieldInfoCount);
  862. return TIFFReadCustomDirectory(tif, diroff, exifFieldInfo,
  863.        exifFieldInfoCount);
  864. }
  866. static int
  867. EstimateStripByteCounts(TIFF* tif, TIFFDirEntry* dir, uint16 dircount)
  868. {
  869. static const char module[] = "EstimateStripByteCounts";
  871. register TIFFDirEntry *dp;
  872. register TIFFDirectory *td = &tif->tif_dir;
  873. uint16 i;
  875. if (td->td_stripbytecount)
  876. _TIFFfree(td->td_stripbytecount);
  877. td->td_stripbytecount = (uint32*)
  878.     _TIFFCheckMalloc(tif, td->td_nstrips, sizeof (uint32),
  879. "for "StripByteCounts" array");
  880. if (td->td_compression != COMPRESSION_NONE) {
  881. uint32 space = (uint32)(sizeof (TIFFHeader)
  882.     + sizeof (uint16)
  883.     + (dircount * sizeof (TIFFDirEntry))
  884.     + sizeof (uint32));
  885. toff_t filesize = TIFFGetFileSize(tif);
  886. uint16 n;
  888. /* calculate amount of space used by indirect values */
  889. for (dp = dir, n = dircount; n > 0; n--, dp++)
  890. {
  891. uint32 cc = TIFFDataWidth((TIFFDataType) dp->tdir_type);
  892. if (cc == 0) {
  893. TIFFErrorExt(tif->tif_clientdata, module,
  894. "%s: Cannot determine size of unknown tag type %d",
  895.   tif->tif_name, dp->tdir_type);
  896. return -1;
  897. }
  898. cc = cc * dp->tdir_count;
  899. if (cc > sizeof (uint32))
  900. space += cc;
  901. }
  902. space = filesize - space;
  903. if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
  904. space /= td->td_samplesperpixel;
  905. for (i = 0; i < td->td_nstrips; i++)
  906. td->td_stripbytecount[i] = space;
  907. /*
  908.  * This gross hack handles the case were the offset to
  909.  * the last strip is past the place where we think the strip
  910.  * should begin.  Since a strip of data must be contiguous,
  911.  * it's safe to assume that we've overestimated the amount
  912.  * of data in the strip and trim this number back accordingly.
  913.  */ 
  914. i--;
  915. if (((toff_t)(td->td_stripoffset[i]+td->td_stripbytecount[i]))
  916.                                                                > filesize)
  917. td->td_stripbytecount[i] =
  918.     filesize - td->td_stripoffset[i];
  919. } else {
  920. uint32 rowbytes = TIFFScanlineSize(tif);
  921. uint32 rowsperstrip = td->td_imagelength/td->td_stripsperimage;
  922. for (i = 0; i < td->td_nstrips; i++)
  923. td->td_stripbytecount[i] = rowbytes*rowsperstrip;
  924. }
  925. TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
  926. if (!TIFFFieldSet(tif, FIELD_ROWSPERSTRIP))
  927. td->td_rowsperstrip = td->td_imagelength;
  928. return 1;
  929. }
  931. static void
  932. MissingRequired(TIFF* tif, const char* tagname)
  933. {
  934. static const char module[] = "MissingRequired";
  936. TIFFErrorExt(tif->tif_clientdata, module,
  937.   "%s: TIFF directory is missing required "%s" field",
  938.   tif->tif_name, tagname);
  939. }
  941. /*
  942.  * Check the count field of a directory
  943.  * entry against a known value.  The caller
  944.  * is expected to skip/ignore the tag if
  945.  * there is a mismatch.
  946.  */
  947. static int
  948. CheckDirCount(TIFF* tif, TIFFDirEntry* dir, uint32 count)
  949. {
  950. if (count > dir->tdir_count) {
  951. TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
  952. "incorrect count for field "%s" (%lu, expecting %lu); tag ignored",
  953.     _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
  954.     dir->tdir_count, count);
  955. return (0);
  956. } else if (count < dir->tdir_count) {
  957. TIFFWarningExt(tif->tif_clientdata, tif->tif_name,
  958. "incorrect count for field "%s" (%lu, expecting %lu); tag trimmed",
  959.     _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name,
  960.     dir->tdir_count, count);
  961. return (1);
  962. }
  963. return (1);
  964. }
  966. /*
  967.  * Fetch a contiguous directory item.
  968.  */
  969. static tsize_t
  970. TIFFFetchData(TIFF* tif, TIFFDirEntry* dir, char* cp)
  971. {
  972. int w = TIFFDataWidth((TIFFDataType) dir->tdir_type);
  973. tsize_t cc = dir->tdir_count * w;
  975. /* Check for overflow. */
  976. if (!dir->tdir_count || !w || cc / w != (tsize_t)dir->tdir_count)
  977. goto bad;
  979. if (!isMapped(tif)) {
  980. if (!SeekOK(tif, dir->tdir_offset))
  981. goto bad;
  982. if (!ReadOK(tif, cp, cc))
  983. goto bad;
  984. } else {
  985. /* Check for overflow. */
  986. if ((tsize_t)dir->tdir_offset + cc < (tsize_t)dir->tdir_offset
  987.     || (tsize_t)dir->tdir_offset + cc < cc
  988.     || (tsize_t)dir->tdir_offset + cc > (tsize_t)tif->tif_size)
  989. goto bad;
  990. _TIFFmemcpy(cp, tif->tif_base + dir->tdir_offset, cc);
  991. }
  992. if (tif->tif_flags & TIFF_SWAB) {
  993. switch (dir->tdir_type) {
  994. case TIFF_SHORT:
  995. case TIFF_SSHORT:
  996. TIFFSwabArrayOfShort((uint16*) cp, dir->tdir_count);
  997. break;
  998. case TIFF_LONG:
  999. case TIFF_SLONG:
  1000. case TIFF_FLOAT:
  1001. TIFFSwabArrayOfLong((uint32*) cp, dir->tdir_count);
  1002. break;
  1003. case TIFF_RATIONAL:
  1004. case TIFF_SRATIONAL:
  1005. TIFFSwabArrayOfLong((uint32*) cp, 2*dir->tdir_count);
  1006. break;
  1007. case TIFF_DOUBLE:
  1008. TIFFSwabArrayOfDouble((double*) cp, dir->tdir_count);
  1009. break;
  1010. }
  1011. }
  1012. return (cc);
  1013. bad:
  1014. TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  1015.      "Error fetching data for field "%s"",
  1016.      _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
  1017. return (tsize_t) 0;
  1018. }
  1020. /*
  1021.  * Fetch an ASCII item from the file.
  1022.  */
  1023. static tsize_t
  1024. TIFFFetchString(TIFF* tif, TIFFDirEntry* dir, char* cp)
  1025. {
  1026. if (dir->tdir_count <= 4) {
  1027. uint32 l = dir->tdir_offset;
  1028. if (tif->tif_flags & TIFF_SWAB)
  1029. TIFFSwabLong(&l);
  1030. _TIFFmemcpy(cp, &l, dir->tdir_count);
  1031. return (1);
  1032. }
  1033. return (TIFFFetchData(tif, dir, cp));
  1034. }
  1036. /*
  1037.  * Convert numerator+denominator to float.
  1038.  */
  1039. static int
  1040. cvtRational(TIFF* tif, TIFFDirEntry* dir, uint32 num, uint32 denom, float* rv)
  1041. {
  1042. if (denom == 0) {
  1043. TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  1044.     "%s: Rational with zero denominator (num = %lu)",
  1045.     _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name, num);
  1046. return (0);
  1047. } else {
  1048. if (dir->tdir_type == TIFF_RATIONAL)
  1049. *rv = ((float)num / (float)denom);
  1050. else
  1051. *rv = ((float)(int32)num / (float)(int32)denom);
  1052. return (1);
  1053. }
  1054. }
  1056. /*
  1057.  * Fetch a rational item from the file
  1058.  * at offset off and return the value
  1059.  * as a floating point number.
  1060.  */
  1061. static float
  1062. TIFFFetchRational(TIFF* tif, TIFFDirEntry* dir)
  1063. {
  1064. uint32 l[2];
  1065. float v;
  1067. return (!TIFFFetchData(tif, dir, (char *)l) ||
  1068.     !cvtRational(tif, dir, l[0], l[1], &v) ? 1.0f : v);
  1069. }
  1071. /*
  1072.  * Fetch a single floating point value
  1073.  * from the offset field and return it
  1074.  * as a native float.
  1075.  */
  1076. static float
  1077. TIFFFetchFloat(TIFF* tif, TIFFDirEntry* dir)
  1078. {
  1079. float v;
  1080. int32 l = TIFFExtractData(tif, dir->tdir_type, dir->tdir_offset);
  1081.         _TIFFmemcpy(&v, &l, sizeof(float));
  1082. TIFFCvtIEEEFloatToNative(tif, 1, &v);
  1083. return (v);
  1084. }
  1086. /*
  1087.  * Fetch an array of BYTE or SBYTE values.
  1088.  */
  1089. static int
  1090. TIFFFetchByteArray(TIFF* tif, TIFFDirEntry* dir, uint8* v)
  1091. {
  1092.     if (dir->tdir_count <= 4) {
  1093.         /*
  1094.          * Extract data from offset field.
  1095.          */
  1096.         if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
  1097.     if (dir->tdir_type == TIFF_SBYTE)
  1098.                 switch (dir->tdir_count) {
  1099.                     case 4: v[3] = dir->tdir_offset & 0xff;
  1100.                     case 3: v[2] = (dir->tdir_offset >> 8) & 0xff;
  1101.                     case 2: v[1] = (dir->tdir_offset >> 16) & 0xff;
  1102.     case 1: v[0] = dir->tdir_offset >> 24;
  1103.                 }
  1104.     else
  1105.                 switch (dir->tdir_count) {
  1106.                     case 4: v[3] = dir->tdir_offset & 0xff;
  1107.                     case 3: v[2] = (dir->tdir_offset >> 8) & 0xff;
  1108.                     case 2: v[1] = (dir->tdir_offset >> 16) & 0xff;
  1109.     case 1: v[0] = dir->tdir_offset >> 24;
  1110.                 }
  1111. } else {
  1112.     if (dir->tdir_type == TIFF_SBYTE)
  1113.                 switch (dir->tdir_count) {
  1114.                     case 4: v[3] = dir->tdir_offset >> 24;
  1115.                     case 3: v[2] = (dir->tdir_offset >> 16) & 0xff;
  1116.                     case 2: v[1] = (dir->tdir_offset >> 8) & 0xff;
  1117.                     case 1: v[0] = dir->tdir_offset & 0xff;
  1118. }
  1119.     else
  1120.                 switch (dir->tdir_count) {
  1121.                     case 4: v[3] = dir->tdir_offset >> 24;
  1122.                     case 3: v[2] = (dir->tdir_offset >> 16) & 0xff;
  1123.                     case 2: v[1] = (dir->tdir_offset >> 8) & 0xff;
  1124.                     case 1: v[0] = dir->tdir_offset & 0xff;
  1125. }
  1126. }
  1127.         return (1);
  1128.     } else
  1129.         return (TIFFFetchData(tif, dir, (char*) v) != 0); /* XXX */
  1130. }
  1132. /*
  1133.  * Fetch an array of SHORT or SSHORT values.
  1134.  */
  1135. static int
  1136. TIFFFetchShortArray(TIFF* tif, TIFFDirEntry* dir, uint16* v)
  1137. {
  1138. if (dir->tdir_count <= 2) {
  1139. if (tif->tif_header.tiff_magic == TIFF_BIGENDIAN) {
  1140. switch (dir->tdir_count) {
  1141. case 2: v[1] = (uint16) (dir->tdir_offset & 0xffff);
  1142. case 1: v[0] = (uint16) (dir->tdir_offset >> 16);
  1143. }
  1144. } else {
  1145. switch (dir->tdir_count) {
  1146. case 2: v[1] = (uint16) (dir->tdir_offset >> 16);
  1147. case 1: v[0] = (uint16) (dir->tdir_offset & 0xffff);
  1148. }
  1149. }
  1150. return (1);
  1151. } else
  1152. return (TIFFFetchData(tif, dir, (char *)v) != 0);
  1153. }
  1155. /*
  1156.  * Fetch a pair of SHORT or BYTE values. Some tags may have either BYTE
  1157.  * or SHORT type and this function works with both ones.
  1158.  */
  1159. static int
  1160. TIFFFetchShortPair(TIFF* tif, TIFFDirEntry* dir)
  1161. {
  1162. switch (dir->tdir_type) {
  1163. case TIFF_BYTE:
  1164. case TIFF_SBYTE:
  1165. {
  1166. uint8 v[4];
  1167. return TIFFFetchByteArray(tif, dir, v)
  1168. && TIFFSetField(tif, dir->tdir_tag, v[0], v[1]);
  1169. }
  1170. case TIFF_SHORT:
  1171. case TIFF_SSHORT:
  1172. {
  1173. uint16 v[2];
  1174. return TIFFFetchShortArray(tif, dir, v)
  1175. && TIFFSetField(tif, dir->tdir_tag, v[0], v[1]);
  1176. }
  1177. default:
  1178. return 0;
  1179. }
  1180. }
  1182. /*
  1183.  * Fetch an array of LONG or SLONG values.
  1184.  */
  1185. static int
  1186. TIFFFetchLongArray(TIFF* tif, TIFFDirEntry* dir, uint32* v)
  1187. {
  1188. if (dir->tdir_count == 1) {
  1189. v[0] = dir->tdir_offset;
  1190. return (1);
  1191. } else
  1192. return (TIFFFetchData(tif, dir, (char*) v) != 0);
  1193. }
  1195. /*
  1196.  * Fetch an array of RATIONAL or SRATIONAL values.
  1197.  */
  1198. static int
  1199. TIFFFetchRationalArray(TIFF* tif, TIFFDirEntry* dir, float* v)
  1200. {
  1201. int ok = 0;
  1202. uint32* l;
  1204. l = (uint32*)_TIFFCheckMalloc(tif,
  1205.     dir->tdir_count, TIFFDataWidth((TIFFDataType) dir->tdir_type),
  1206.     "to fetch array of rationals");
  1207. if (l) {
  1208. if (TIFFFetchData(tif, dir, (char *)l)) {
  1209. uint32 i;
  1210. for (i = 0; i < dir->tdir_count; i++) {
  1211. ok = cvtRational(tif, dir,
  1212.     l[2*i+0], l[2*i+1], &v[i]);
  1213. if (!ok)
  1214. break;
  1215. }
  1216. }
  1217. _TIFFfree((char *)l);
  1218. }
  1219. return (ok);
  1220. }
  1222. /*
  1223.  * Fetch an array of FLOAT values.
  1224.  */
  1225. static int
  1226. TIFFFetchFloatArray(TIFF* tif, TIFFDirEntry* dir, float* v)
  1227. {
  1229. if (dir->tdir_count == 1) {
  1230. v[0] = *(float*) &dir->tdir_offset;
  1231. TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v);
  1232. return (1);
  1233. } else if (TIFFFetchData(tif, dir, (char*) v)) {
  1234. TIFFCvtIEEEFloatToNative(tif, dir->tdir_count, v);
  1235. return (1);
  1236. } else
  1237. return (0);
  1238. }
  1240. /*
  1241.  * Fetch an array of DOUBLE values.
  1242.  */
  1243. static int
  1244. TIFFFetchDoubleArray(TIFF* tif, TIFFDirEntry* dir, double* v)
  1245. {
  1246. if (TIFFFetchData(tif, dir, (char*) v)) {
  1247. TIFFCvtIEEEDoubleToNative(tif, dir->tdir_count, v);
  1248. return (1);
  1249. } else
  1250. return (0);
  1251. }
  1253. /*
  1254.  * Fetch an array of ANY values.  The actual values are
  1255.  * returned as doubles which should be able hold all the
  1256.  * types.  Yes, there really should be an tany_t to avoid
  1257.  * this potential non-portability ...  Note in particular
  1258.  * that we assume that the double return value vector is
  1259.  * large enough to read in any fundamental type.  We use
  1260.  * that vector as a buffer to read in the base type vector
  1261.  * and then convert it in place to double (from end
  1262.  * to front of course).
  1263.  */
  1264. static int
  1265. TIFFFetchAnyArray(TIFF* tif, TIFFDirEntry* dir, double* v)
  1266. {
  1267. int i;
  1269. switch (dir->tdir_type) {
  1270. case TIFF_BYTE:
  1271. case TIFF_SBYTE:
  1272. if (!TIFFFetchByteArray(tif, dir, (uint8*) v))
  1273. return (0);
  1274. if (dir->tdir_type == TIFF_BYTE) {
  1275. uint8* vp = (uint8*) v;
  1276. for (i = dir->tdir_count-1; i >= 0; i--)
  1277. v[i] = vp[i];
  1278. } else {
  1279. int8* vp = (int8*) v;
  1280. for (i = dir->tdir_count-1; i >= 0; i--)
  1281. v[i] = vp[i];
  1282. }
  1283. break;
  1284. case TIFF_SHORT:
  1285. case TIFF_SSHORT:
  1286. if (!TIFFFetchShortArray(tif, dir, (uint16*) v))
  1287. return (0);
  1288. if (dir->tdir_type == TIFF_SHORT) {
  1289. uint16* vp = (uint16*) v;
  1290. for (i = dir->tdir_count-1; i >= 0; i--)
  1291. v[i] = vp[i];
  1292. } else {
  1293. int16* vp = (int16*) v;
  1294. for (i = dir->tdir_count-1; i >= 0; i--)
  1295. v[i] = vp[i];
  1296. }
  1297. break;
  1298. case TIFF_LONG:
  1299. case TIFF_SLONG:
  1300. if (!TIFFFetchLongArray(tif, dir, (uint32*) v))
  1301. return (0);
  1302. if (dir->tdir_type == TIFF_LONG) {
  1303. uint32* vp = (uint32*) v;
  1304. for (i = dir->tdir_count-1; i >= 0; i--)
  1305. v[i] = vp[i];
  1306. } else {
  1307. int32* vp = (int32*) v;
  1308. for (i = dir->tdir_count-1; i >= 0; i--)
  1309. v[i] = vp[i];
  1310. }
  1311. break;
  1312. case TIFF_RATIONAL:
  1313. case TIFF_SRATIONAL:
  1314. if (!TIFFFetchRationalArray(tif, dir, (float*) v))
  1315. return (0);
  1316. { float* vp = (float*) v;
  1317.   for (i = dir->tdir_count-1; i >= 0; i--)
  1318. v[i] = vp[i];
  1319. }
  1320. break;
  1321. case TIFF_FLOAT:
  1322. if (!TIFFFetchFloatArray(tif, dir, (float*) v))
  1323. return (0);
  1324. { float* vp = (float*) v;
  1325.   for (i = dir->tdir_count-1; i >= 0; i--)
  1326. v[i] = vp[i];
  1327. }
  1328. break;
  1329. case TIFF_DOUBLE:
  1330. return (TIFFFetchDoubleArray(tif, dir, (double*) v));
  1331. default:
  1332. /* TIFF_NOTYPE */
  1333. /* TIFF_ASCII */
  1334. /* TIFF_UNDEFINED */
  1335. TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  1336.      "cannot read TIFF_ANY type %d for field "%s"",
  1337.      dir->tdir_type,
  1338.      _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
  1339. return (0);
  1340. }
  1341. return (1);
  1342. }
  1344. /*
  1345.  * Fetch a tag that is not handled by special case code.
  1346.  */
  1347. static int
  1348. TIFFFetchNormalTag(TIFF* tif, TIFFDirEntry* dp)
  1349. {
  1350. static const char mesg[] = "to fetch tag value";
  1351. int ok = 0;
  1352. const TIFFFieldInfo* fip = _TIFFFieldWithTag(tif, dp->tdir_tag);
  1354. if (dp->tdir_count > 1) { /* array of values */
  1355. char* cp = NULL;
  1357. switch (dp->tdir_type) {
  1358. case TIFF_BYTE:
  1359. case TIFF_SBYTE:
  1360. cp = (char *)_TIFFCheckMalloc(tif,
  1361.     dp->tdir_count, sizeof (uint8), mesg);
  1362. ok = cp && TIFFFetchByteArray(tif, dp, (uint8*) cp);
  1363. break;
  1364. case TIFF_SHORT:
  1365. case TIFF_SSHORT:
  1366. cp = (char *)_TIFFCheckMalloc(tif,
  1367.     dp->tdir_count, sizeof (uint16), mesg);
  1368. ok = cp && TIFFFetchShortArray(tif, dp, (uint16*) cp);
  1369. break;
  1370. case TIFF_LONG:
  1371. case TIFF_SLONG:
  1372. cp = (char *)_TIFFCheckMalloc(tif,
  1373.     dp->tdir_count, sizeof (uint32), mesg);
  1374. ok = cp && TIFFFetchLongArray(tif, dp, (uint32*) cp);
  1375. break;
  1376. case TIFF_RATIONAL:
  1377. case TIFF_SRATIONAL:
  1378. cp = (char *)_TIFFCheckMalloc(tif,
  1379.     dp->tdir_count, sizeof (float), mesg);
  1380. ok = cp && TIFFFetchRationalArray(tif, dp, (float*) cp);
  1381. break;
  1382. case TIFF_FLOAT:
  1383. cp = (char *)_TIFFCheckMalloc(tif,
  1384.     dp->tdir_count, sizeof (float), mesg);
  1385. ok = cp && TIFFFetchFloatArray(tif, dp, (float*) cp);
  1386. break;
  1387. case TIFF_DOUBLE:
  1388. cp = (char *)_TIFFCheckMalloc(tif,
  1389.     dp->tdir_count, sizeof (double), mesg);
  1390. ok = cp && TIFFFetchDoubleArray(tif, dp, (double*) cp);
  1391. break;
  1392. case TIFF_ASCII:
  1393. case TIFF_UNDEFINED: /* bit of a cheat... */
  1394. /*
  1395.  * Some vendors write strings w/o the trailing
  1396.  * NULL byte, so always append one just in case.
  1397.  */
  1398. cp = (char *)_TIFFCheckMalloc(tif, dp->tdir_count + 1,
  1399.       1, mesg);
  1400. if( (ok = (cp && TIFFFetchString(tif, dp, cp))) != 0 )
  1401. cp[dp->tdir_count] = ''; /* XXX */
  1402. break;
  1403. }
  1404. if (ok) {
  1405. ok = (fip->field_passcount ?
  1406.     TIFFSetField(tif, dp->tdir_tag, dp->tdir_count, cp)
  1407.   : TIFFSetField(tif, dp->tdir_tag, cp));
  1408. }
  1409. if (cp != NULL)
  1410. _TIFFfree(cp);
  1411. } else if (CheckDirCount(tif, dp, 1)) { /* singleton value */
  1412. switch (dp->tdir_type) {
  1413. case TIFF_BYTE:
  1414. case TIFF_SBYTE:
  1415. case TIFF_SHORT:
  1416. case TIFF_SSHORT:
  1417. /*
  1418.  * If the tag is also acceptable as a LONG or SLONG
  1419.  * then TIFFSetField will expect an uint32 parameter
  1420.  * passed to it (through varargs).  Thus, for machines
  1421.  * where sizeof (int) != sizeof (uint32) we must do
  1422.  * a careful check here.  It's hard to say if this
  1423.  * is worth optimizing.
  1424.  *
  1425.  * NB: We use TIFFFieldWithTag here knowing that
  1426.  *     it returns us the first entry in the table
  1427.  *     for the tag and that that entry is for the
  1428.  *     widest potential data type the tag may have.
  1429.  */
  1430. { TIFFDataType type = fip->field_type;
  1431.   if (type != TIFF_LONG && type != TIFF_SLONG) {
  1432. uint16 v = (uint16)
  1433.    TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset);
  1434. ok = (fip->field_passcount ?
  1435.     TIFFSetField(tif, dp->tdir_tag, 1, &v)
  1436.   : TIFFSetField(tif, dp->tdir_tag, v));
  1437. break;
  1438.   }
  1439. }
  1440. /* fall thru... */
  1441. case TIFF_LONG:
  1442. case TIFF_SLONG:
  1443. { uint32 v32 =
  1444.     TIFFExtractData(tif, dp->tdir_type, dp->tdir_offset);
  1445.   ok = (fip->field_passcount ? 
  1446.       TIFFSetField(tif, dp->tdir_tag, 1, &v32)
  1447.     : TIFFSetField(tif, dp->tdir_tag, v32));
  1448. }
  1449. break;
  1450. case TIFF_RATIONAL:
  1451. case TIFF_SRATIONAL:
  1452. case TIFF_FLOAT:
  1453. { float v = (dp->tdir_type == TIFF_FLOAT ? 
  1454.       TIFFFetchFloat(tif, dp)
  1455.     : TIFFFetchRational(tif, dp));
  1456.   ok = (fip->field_passcount ?
  1457.       TIFFSetField(tif, dp->tdir_tag, 1, &v)
  1458.     : TIFFSetField(tif, dp->tdir_tag, v));
  1459. }
  1460. break;
  1461. case TIFF_DOUBLE:
  1462. { double v;
  1463.   ok = (TIFFFetchDoubleArray(tif, dp, &v) &&
  1464.     (fip->field_passcount ?
  1465.       TIFFSetField(tif, dp->tdir_tag, 1, &v)
  1466.     : TIFFSetField(tif, dp->tdir_tag, v))
  1467.   );
  1468. }
  1469. break;
  1470. case TIFF_ASCII:
  1471. case TIFF_UNDEFINED: /* bit of a cheat... */
  1472. { char c[2];
  1473.   if( (ok = (TIFFFetchString(tif, dp, c) != 0)) != 0 ) {
  1474. c[1] = ''; /* XXX paranoid */
  1475. ok = (fip->field_passcount ?
  1476. TIFFSetField(tif, dp->tdir_tag, 1, c)
  1477.       : TIFFSetField(tif, dp->tdir_tag, c));
  1478.   }
  1479. }
  1480. break;
  1481. }
  1482. }
  1483. return (ok);
  1484. }
  1486. #define NITEMS(x) (sizeof (x) / sizeof (x[0]))
  1487. /*
  1488.  * Fetch samples/pixel short values for 
  1489.  * the specified tag and verify that
  1490.  * all values are the same.
  1491.  */
  1492. static int
  1493. TIFFFetchPerSampleShorts(TIFF* tif, TIFFDirEntry* dir, uint16* pl)
  1494. {
  1495.     uint16 samples = tif->tif_dir.td_samplesperpixel;
  1496.     int status = 0;
  1498.     if (CheckDirCount(tif, dir, (uint32) samples)) {
  1499.         uint16 buf[10];
  1500.         uint16* v = buf;
  1502.         if (dir->tdir_count > NITEMS(buf))
  1503.             v = (uint16*) _TIFFCheckMalloc(tif, dir->tdir_count, sizeof(uint16),
  1504.                                       "to fetch per-sample values");
  1505.         if (v && TIFFFetchShortArray(tif, dir, v)) {
  1506.             uint16 i;
  1507.             int check_count = dir->tdir_count;
  1508.             if( samples < check_count )
  1509.                 check_count = samples;
  1511.             for (i = 1; i < check_count; i++)
  1512.                 if (v[i] != v[0]) {
  1513. TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  1514.                               "Cannot handle different per-sample values for field "%s"",
  1515.                               _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
  1516.                     goto bad;
  1517.                 }
  1518.             *pl = v[0];
  1519.             status = 1;
  1520.         }
  1521.       bad:
  1522.         if (v && v != buf)
  1523.             _TIFFfree(v);
  1524.     }
  1525.     return (status);
  1526. }
  1528. /*
  1529.  * Fetch samples/pixel long values for 
  1530.  * the specified tag and verify that
  1531.  * all values are the same.
  1532.  */
  1533. static int
  1534. TIFFFetchPerSampleLongs(TIFF* tif, TIFFDirEntry* dir, uint32* pl)
  1535. {
  1536.     uint16 samples = tif->tif_dir.td_samplesperpixel;
  1537.     int status = 0;
  1539.     if (CheckDirCount(tif, dir, (uint32) samples)) {
  1540.         uint32 buf[10];
  1541.         uint32* v = buf;
  1543.         if (dir->tdir_count > NITEMS(buf))
  1544.             v = (uint32*) _TIFFCheckMalloc(tif, dir->tdir_count, sizeof(uint32),
  1545.                                       "to fetch per-sample values");
  1546.         if (v && TIFFFetchLongArray(tif, dir, v)) {
  1547.             uint16 i;
  1548.             int check_count = dir->tdir_count;
  1550.             if( samples < check_count )
  1551.                 check_count = samples;
  1552.             for (i = 1; i < check_count; i++)
  1553.                 if (v[i] != v[0]) {
  1554. TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  1555.                               "Cannot handle different per-sample values for field "%s"",
  1556.                               _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
  1557.                     goto bad;
  1558.                 }
  1559.             *pl = v[0];
  1560.             status = 1;
  1561.         }
  1562.       bad:
  1563.         if (v && v != buf)
  1564.             _TIFFfree(v);
  1565.     }
  1566.     return (status);
  1567. }
  1569. /*
  1570.  * Fetch samples/pixel ANY values for the specified tag and verify that all
  1571.  * values are the same.
  1572.  */
  1573. static int
  1574. TIFFFetchPerSampleAnys(TIFF* tif, TIFFDirEntry* dir, double* pl)
  1575. {
  1576.     uint16 samples = tif->tif_dir.td_samplesperpixel;
  1577.     int status = 0;
  1579.     if (CheckDirCount(tif, dir, (uint32) samples)) {
  1580.         double buf[10];
  1581.         double* v = buf;
  1583.         if (dir->tdir_count > NITEMS(buf))
  1584.             v = (double*) _TIFFCheckMalloc(tif, dir->tdir_count, sizeof (double),
  1585.                                       "to fetch per-sample values");
  1586.         if (v && TIFFFetchAnyArray(tif, dir, v)) {
  1587.             uint16 i;
  1588.             int check_count = dir->tdir_count;
  1589.             if( samples < check_count )
  1590.                 check_count = samples;
  1592.             for (i = 1; i < check_count; i++)
  1593.                 if (v[i] != v[0]) {
  1594.                     TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
  1595.                               "Cannot handle different per-sample values for field "%s"",
  1596.                               _TIFFFieldWithTag(tif, dir->tdir_tag)->field_name);
  1597.                     goto bad;
  1598.                 }
  1599.             *pl = v[0];
  1600.             status = 1;
  1601.         }
  1602.       bad:
  1603.         if (v && v != buf)
  1604.             _TIFFfree(v);
  1605.     }
  1606.     return (status);
  1607. }
  1608. #undef NITEMS
  1610. /*
  1611.  * Fetch a set of offsets or lengths.
  1612.  * While this routine says "strips", in fact it's also used for tiles.
  1613.  */
  1614. static int
  1615. TIFFFetchStripThing(TIFF* tif, TIFFDirEntry* dir, long nstrips, uint32** lpp)
  1616. {
  1617. register uint32* lp;
  1618. int status;
  1620.         CheckDirCount(tif, dir, (uint32) nstrips);
  1622. /*
  1623.  * Allocate space for strip information.
  1624.  */
  1625. if (*lpp == NULL &&
  1626.     (*lpp = (uint32 *)_TIFFCheckMalloc(tif,
  1627.       nstrips, sizeof (uint32), "for strip array")) == NULL)
  1628. return (0);
  1629. lp = *lpp;
  1630.         _TIFFmemset( lp, 0, sizeof(uint32) * nstrips );
  1632. if (dir->tdir_type == (int)TIFF_SHORT) {
  1633. /*
  1634.  * Handle uint16->uint32 expansion.
  1635.  */
  1636. uint16* dp = (uint16*) _TIFFCheckMalloc(tif,
  1637.     dir->tdir_count, sizeof (uint16), "to fetch strip tag");
  1638. if (dp == NULL)
  1639. return (0);
  1640. if( (status = TIFFFetchShortArray(tif, dir, dp)) != 0 ) {
  1641.                     int i;
  1642.                     
  1643.                     for( i = 0; i < nstrips && i < (int) dir->tdir_count; i++ )
  1644.                     {
  1645.                         lp[i] = dp[i];
  1646.                     }
  1647. }
  1648. _TIFFfree((char*) dp);
  1650.         } else if( nstrips != (int) dir->tdir_count ) {
  1651.             /* Special case to correct length */
  1653.             uint32* dp = (uint32*) _TIFFCheckMalloc(tif,
  1654.     dir->tdir_count, sizeof (uint32), "to fetch strip tag");
  1655.             if (dp == NULL)
  1656.                 return (0);
  1658.             status = TIFFFetchLongArray(tif, dir, dp);
  1659.             if( status != 0 ) {
  1660.                 int i;
  1662.                 for( i = 0; i < nstrips && i < (int) dir->tdir_count; i++ )
  1663.                 {
  1664.                     lp[i] = dp[i];
  1665.                 }
  1666.             }
  1668.             _TIFFfree( (char *) dp );
  1669. } else
  1670.             status = TIFFFetchLongArray(tif, dir, lp);
  1671.         
  1672. return (status);
  1673. }
  1675. /*
  1676.  * Fetch and set the RefBlackWhite tag.
  1677.  */
  1678. static int
  1679. TIFFFetchRefBlackWhite(TIFF* tif, TIFFDirEntry* dir)
  1680. {
  1681. static const char mesg[] = "for "ReferenceBlackWhite" array";
  1682. char* cp;
  1683. int ok;
  1685. if (dir->tdir_type == TIFF_RATIONAL)
  1686. return (TIFFFetchNormalTag(tif, dir));
  1687. /*
  1688.  * Handle LONG's for backward compatibility.
  1689.  */
  1690. cp = (char *)_TIFFCheckMalloc(tif, dir->tdir_count,
  1691.       sizeof (uint32), mesg);
  1692. if( (ok = (cp && TIFFFetchLongArray(tif, dir, (uint32*) cp))) != 0) {
  1693. float* fp = (float*)
  1694.     _TIFFCheckMalloc(tif, dir->tdir_count, sizeof (float), mesg);
  1695. if( (ok = (fp != NULL)) != 0 ) {
  1696. uint32 i;
  1697. for (i = 0; i < dir->tdir_count; i++)
  1698. fp[i] = (float)((uint32*) cp)[i];
  1699. ok = TIFFSetField(tif, dir->tdir_tag, fp);
  1700. _TIFFfree((char*) fp);
  1701. }
  1702. }
  1703. if (cp)
  1704. _TIFFfree(cp);
  1705. return (ok);
  1706. }
  1708. /*
  1709.  * Replace a single strip (tile) of uncompressed data by
  1710.  * multiple strips (tiles), each approximately 8Kbytes.
  1711.  * This is useful for dealing with large images or
  1712.  * for dealing with machines with a limited amount
  1713.  * memory.
  1714.  */
  1715. static void
  1716. ChopUpSingleUncompressedStrip(TIFF* tif)
  1717. {
  1718. register TIFFDirectory *td = &tif->tif_dir;
  1719. uint32 bytecount = td->td_stripbytecount[0];
  1720. uint32 offset = td->td_stripoffset[0];
  1721. tsize_t rowbytes = TIFFVTileSize(tif, 1), stripbytes;
  1722. tstrip_t strip, nstrips, rowsperstrip;
  1723. uint32* newcounts;
  1724. uint32* newoffsets;
  1726. /*
  1727.  * Make the rows hold at least one scanline, but fill specified amount
  1728.  * of data if possible.
  1729.  */
  1730. if (rowbytes > STRIP_SIZE_DEFAULT) {
  1731. stripbytes = rowbytes;
  1732. rowsperstrip = 1;
  1733. } else if (rowbytes > 0 ) {
  1734. rowsperstrip = STRIP_SIZE_DEFAULT / rowbytes;
  1735. stripbytes = rowbytes * rowsperstrip;
  1736. }
  1737.         else
  1738.             return;
  1740. /* 
  1741.  * never increase the number of strips in an image
  1742.  */
  1743. if (rowsperstrip >= td->td_rowsperstrip)
  1744. return;
  1745. nstrips = (tstrip_t) TIFFhowmany(bytecount, stripbytes);
  1746.         if( nstrips == 0 ) /* something is wonky, do nothing. */
  1747.             return;
  1749. newcounts = (uint32*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint32),
  1750. "for chopped "StripByteCounts" array");
  1751. newoffsets = (uint32*) _TIFFCheckMalloc(tif, nstrips, sizeof (uint32),
  1752. "for chopped "StripOffsets" array");
  1753. if (newcounts == NULL || newoffsets == NULL) {
  1754.         /*
  1755.  * Unable to allocate new strip information, give
  1756.  * up and use the original one strip information.
  1757.  */
  1758. if (newcounts != NULL)
  1759. _TIFFfree(newcounts);
  1760. if (newoffsets != NULL)
  1761. _TIFFfree(newoffsets);
  1762. return;
  1763. }
  1764. /*
  1765.  * Fill the strip information arrays with new bytecounts and offsets
  1766.  * that reflect the broken-up format.
  1767.  */
  1768. for (strip = 0; strip < nstrips; strip++) {
  1769. if (stripbytes > (tsize_t) bytecount)
  1770. stripbytes = bytecount;
  1771. newcounts[strip] = stripbytes;
  1772. newoffsets[strip] = offset;
  1773. offset += stripbytes;
  1774. bytecount -= stripbytes;
  1775. }
  1776. /*
  1777.  * Replace old single strip info with multi-strip info.
  1778.  */
  1779. td->td_stripsperimage = td->td_nstrips = nstrips;
  1780. TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, rowsperstrip);
  1782. _TIFFfree(td->td_stripbytecount);
  1783. _TIFFfree(td->td_stripoffset);
  1784. td->td_stripbytecount = newcounts;
  1785. td->td_stripoffset = newoffsets;
  1786. td->td_stripbytecountsorted = 1;
  1787. }
  1789. /* vim: set ts=8 sts=8 sw=8 noet: */