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

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

打印编程

开发平台：

Visual C++

tif_print.c：源码内容
  1. /* $Id: tif_print.c,v 1.35 2006/03/13 07:53:28 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 Printing Support
  31.  */
  32. #include "tiffiop.h"
  33. #include <stdio.h>
  35. #include <ctype.h>
  37. static const char *photoNames[] = {
  38.     "min-is-white", /* PHOTOMETRIC_MINISWHITE */
  39.     "min-is-black", /* PHOTOMETRIC_MINISBLACK */
  40.     "RGB color", /* PHOTOMETRIC_RGB */
  41.     "palette color (RGB from colormap)", /* PHOTOMETRIC_PALETTE */
  42.     "transparency mask", /* PHOTOMETRIC_MASK */
  43.     "separated", /* PHOTOMETRIC_SEPARATED */
  44.     "YCbCr", /* PHOTOMETRIC_YCBCR */
  45.     "7 (0x7)",
  46.     "CIE L*a*b*", /* PHOTOMETRIC_CIELAB */
  47. };
  48. #define NPHOTONAMES (sizeof (photoNames) / sizeof (photoNames[0]))
  50. static const char *orientNames[] = {
  51.     "0 (0x0)",
  52.     "row 0 top, col 0 lhs", /* ORIENTATION_TOPLEFT */
  53.     "row 0 top, col 0 rhs", /* ORIENTATION_TOPRIGHT */
  54.     "row 0 bottom, col 0 rhs", /* ORIENTATION_BOTRIGHT */
  55.     "row 0 bottom, col 0 lhs", /* ORIENTATION_BOTLEFT */
  56.     "row 0 lhs, col 0 top", /* ORIENTATION_LEFTTOP */
  57.     "row 0 rhs, col 0 top", /* ORIENTATION_RIGHTTOP */
  58.     "row 0 rhs, col 0 bottom", /* ORIENTATION_RIGHTBOT */
  59.     "row 0 lhs, col 0 bottom", /* ORIENTATION_LEFTBOT */
  60. };
  61. #define NORIENTNAMES (sizeof (orientNames) / sizeof (orientNames[0]))
  63. static void
  64. _TIFFPrintField(FILE* fd, const TIFFFieldInfo *fip,
  65. uint32 value_count, void *raw_data)
  66. {
  67. uint32 j;
  69. fprintf(fd, "  %s: ", fip->field_name);
  71. for(j = 0; j < value_count; j++) {
  72. if(fip->field_type == TIFF_BYTE)
  73. fprintf(fd, "%u", ((uint8 *) raw_data)[j]);
  74. else if(fip->field_type == TIFF_UNDEFINED)
  75. fprintf(fd, "0x%x",
  76. (unsigned int) ((unsigned char *) raw_data)[j]);
  77. else if(fip->field_type == TIFF_SBYTE)
  78. fprintf(fd, "%d", ((int8 *) raw_data)[j]);
  79. else if(fip->field_type == TIFF_SHORT)
  80. fprintf(fd, "%u", ((uint16 *) raw_data)[j]);
  81. else if(fip->field_type == TIFF_SSHORT)
  82. fprintf(fd, "%d", ((int16 *) raw_data)[j]);
  83. else if(fip->field_type == TIFF_LONG)
  84. fprintf(fd, "%lu",
  85. (unsigned long)((uint32 *) raw_data)[j]);
  86. else if(fip->field_type == TIFF_SLONG)
  87. fprintf(fd, "%ld", (long)((int32 *) raw_data)[j]);
  88. else if(fip->field_type == TIFF_RATIONAL
  89. || fip->field_type == TIFF_SRATIONAL
  90. || fip->field_type == TIFF_FLOAT)
  91. fprintf(fd, "%f", ((float *) raw_data)[j]);
  92. else if(fip->field_type == TIFF_IFD)
  93. fprintf(fd, "0x%ulx", ((uint32 *) raw_data)[j]);
  94. else if(fip->field_type == TIFF_ASCII) {
  95. fprintf(fd, "%s", (char *) raw_data);
  96. break;
  97. }
  98. else if(fip->field_type == TIFF_DOUBLE)
  99. fprintf(fd, "%f", ((double *) raw_data)[j]);
  100. else if(fip->field_type == TIFF_FLOAT)
  101. fprintf(fd, "%f", ((float *)raw_data)[j]);
  102. else {
  103. fprintf(fd, "<unsupported data type in TIFFPrint>");
  104. break;
  105. }
  107. if(j < value_count - 1)
  108. fprintf(fd, ",");
  109. }
  111. fprintf(fd, "n");
  112. }
  114. static int
  115. _TIFFPrettyPrintField(TIFF* tif, FILE* fd, ttag_t tag,
  116.       uint32 value_count, void *raw_data)
  117. {
  118. TIFFDirectory *td = &tif->tif_dir;
  120. switch (tag)
  121. {
  122. case TIFFTAG_INKSET:
  123. fprintf(fd, "  Ink Set: ");
  124. switch (*((uint16*)raw_data)) {
  125. case INKSET_CMYK:
  126. fprintf(fd, "CMYKn");
  127. break;
  128. default:
  129. fprintf(fd, "%u (0x%x)n",
  130. *((uint16*)raw_data),
  131. *((uint16*)raw_data));
  132. break;
  133. }
  134. return 1;
  135. case TIFFTAG_DOTRANGE:
  136. fprintf(fd, "  Dot Range: %u-%un",
  137. ((uint16*)raw_data)[0], ((uint16*)raw_data)[1]);
  138. return 1;
  139. case TIFFTAG_WHITEPOINT:
  140. fprintf(fd, "  White Point: %g-%gn",
  141. ((float *)raw_data)[0], ((float *)raw_data)[1]); return 1;
  142. case TIFFTAG_REFERENCEBLACKWHITE:
  143. {
  144. uint16 i;
  146. fprintf(fd, "  Reference Black/White:n");
  147. for (i = 0; i < td->td_samplesperpixel; i++)
  148. fprintf(fd, "    %2d: %5g %5gn", i,
  149. ((float *)raw_data)[2*i+0],
  150. ((float *)raw_data)[2*i+1]);
  151. return 1;
  152. }
  153. case TIFFTAG_XMLPACKET:
  154. {
  155. uint32 i;
  157. fprintf(fd, "  XMLPacket (XMP Metadata):n" );
  158. for(i = 0; i < value_count; i++)
  159. fputc(((char *)raw_data)[i], fd);
  160. fprintf( fd, "n" );
  161. return 1;
  162. }
  163. case TIFFTAG_RICHTIFFIPTC:
  164. /*
  165.  * XXX: for some weird reason RichTIFFIPTC tag
  166.  * defined as array of LONG values.
  167.  */
  168. fprintf(fd,
  169. "  RichTIFFIPTC Data: <present>, %lu bytesn",
  170. (unsigned long) value_count * 4);
  171. return 1;
  172. case TIFFTAG_PHOTOSHOP:
  173. fprintf(fd, "  Photoshop Data: <present>, %lu bytesn",
  174. (unsigned long) value_count);
  175. return 1;
  176. case TIFFTAG_ICCPROFILE:
  177. fprintf(fd, "  ICC Profile: <present>, %lu bytesn",
  178. (unsigned long) value_count);
  179. return 1;
  180. case TIFFTAG_STONITS:
  181. fprintf(fd,
  182. "  Sample to Nits conversion factor: %.4en",
  183. *((double*)raw_data));
  184. return 1;
  185.         }
  187. return 0;
  188. }
  190. /*
  191.  * Print the contents of the current directory
  192.  * to the specified stdio file stream.
  193.  */
  194. void
  195. TIFFPrintDirectory(TIFF* tif, FILE* fd, long flags)
  196. {
  197. TIFFDirectory *td = &tif->tif_dir;
  198. char *sep;
  199. uint16 i;
  200. long l, n;
  202. fprintf(fd, "TIFF Directory at offset 0x%lx (%lu)n",
  203. (unsigned long)tif->tif_diroff, (unsigned long)tif->tif_diroff);
  204. if (TIFFFieldSet(tif,FIELD_SUBFILETYPE)) {
  205. fprintf(fd, "  Subfile Type:");
  206. sep = " ";
  207. if (td->td_subfiletype & FILETYPE_REDUCEDIMAGE) {
  208. fprintf(fd, "%sreduced-resolution image", sep);
  209. sep = "/";
  210. }
  211. if (td->td_subfiletype & FILETYPE_PAGE) {
  212. fprintf(fd, "%smulti-page document", sep);
  213. sep = "/";
  214. }
  215. if (td->td_subfiletype & FILETYPE_MASK)
  216. fprintf(fd, "%stransparency mask", sep);
  217. fprintf(fd, " (%lu = 0x%lx)n",
  218.     (long) td->td_subfiletype, (long) td->td_subfiletype);
  219. }
  220. if (TIFFFieldSet(tif,FIELD_IMAGEDIMENSIONS)) {
  221. fprintf(fd, "  Image Width: %lu Image Length: %lu",
  222.     (unsigned long) td->td_imagewidth, (unsigned long) td->td_imagelength);
  223. if (TIFFFieldSet(tif,FIELD_IMAGEDEPTH))
  224. fprintf(fd, " Image Depth: %lu",
  225.     (unsigned long) td->td_imagedepth);
  226. fprintf(fd, "n");
  227. }
  228. if (TIFFFieldSet(tif,FIELD_TILEDIMENSIONS)) {
  229. fprintf(fd, "  Tile Width: %lu Tile Length: %lu",
  230.     (unsigned long) td->td_tilewidth, (unsigned long) td->td_tilelength);
  231. if (TIFFFieldSet(tif,FIELD_TILEDEPTH))
  232. fprintf(fd, " Tile Depth: %lu",
  233.     (unsigned long) td->td_tiledepth);
  234. fprintf(fd, "n");
  235. }
  236. if (TIFFFieldSet(tif,FIELD_RESOLUTION)) {
  237. fprintf(fd, "  Resolution: %g, %g",
  238.     td->td_xresolution, td->td_yresolution);
  239. if (TIFFFieldSet(tif,FIELD_RESOLUTIONUNIT)) {
  240. switch (td->td_resolutionunit) {
  241. case RESUNIT_NONE:
  242. fprintf(fd, " (unitless)");
  243. break;
  244. case RESUNIT_INCH:
  245. fprintf(fd, " pixels/inch");
  246. break;
  247. case RESUNIT_CENTIMETER:
  248. fprintf(fd, " pixels/cm");
  249. break;
  250. default:
  251. fprintf(fd, " (unit %u = 0x%x)",
  252.     td->td_resolutionunit,
  253.     td->td_resolutionunit);
  254. break;
  255. }
  256. }
  257. fprintf(fd, "n");
  258. }
  259. if (TIFFFieldSet(tif,FIELD_POSITION))
  260. fprintf(fd, "  Position: %g, %gn",
  261.     td->td_xposition, td->td_yposition);
  262. if (TIFFFieldSet(tif,FIELD_BITSPERSAMPLE))
  263. fprintf(fd, "  Bits/Sample: %un", td->td_bitspersample);
  264. if (TIFFFieldSet(tif,FIELD_SAMPLEFORMAT)) {
  265. fprintf(fd, "  Sample Format: ");
  266. switch (td->td_sampleformat) {
  267. case SAMPLEFORMAT_VOID:
  268. fprintf(fd, "voidn");
  269. break;
  270. case SAMPLEFORMAT_INT:
  271. fprintf(fd, "signed integern");
  272. break;
  273. case SAMPLEFORMAT_UINT:
  274. fprintf(fd, "unsigned integern");
  275. break;
  276. case SAMPLEFORMAT_IEEEFP:
  277. fprintf(fd, "IEEE floating pointn");
  278. break;
  279. case SAMPLEFORMAT_COMPLEXINT:
  280. fprintf(fd, "complex signed integern");
  281. break;
  282. case SAMPLEFORMAT_COMPLEXIEEEFP:
  283. fprintf(fd, "complex IEEE floating pointn");
  284. break;
  285. default:
  286. fprintf(fd, "%u (0x%x)n",
  287.     td->td_sampleformat, td->td_sampleformat);
  288. break;
  289. }
  290. }
  291. if (TIFFFieldSet(tif,FIELD_COMPRESSION)) {
  292. const TIFFCodec* c = TIFFFindCODEC(td->td_compression);
  293. fprintf(fd, "  Compression Scheme: ");
  294. if (c)
  295. fprintf(fd, "%sn", c->name);
  296. else
  297. fprintf(fd, "%u (0x%x)n",
  298.     td->td_compression, td->td_compression);
  299. }
  300. if (TIFFFieldSet(tif,FIELD_PHOTOMETRIC)) {
  301. fprintf(fd, "  Photometric Interpretation: ");
  302. if (td->td_photometric < NPHOTONAMES)
  303. fprintf(fd, "%sn", photoNames[td->td_photometric]);
  304. else {
  305. switch (td->td_photometric) {
  306. case PHOTOMETRIC_LOGL:
  307. fprintf(fd, "CIE Log2(L)n");
  308. break;
  309. case PHOTOMETRIC_LOGLUV:
  310. fprintf(fd, "CIE Log2(L) (u',v')n");
  311. break;
  312. default:
  313. fprintf(fd, "%u (0x%x)n",
  314.     td->td_photometric, td->td_photometric);
  315. break;
  316. }
  317. }
  318. }
  319. if (TIFFFieldSet(tif,FIELD_EXTRASAMPLES) && td->td_extrasamples) {
  320. fprintf(fd, "  Extra Samples: %u<", td->td_extrasamples);
  321. sep = "";
  322. for (i = 0; i < td->td_extrasamples; i++) {
  323. switch (td->td_sampleinfo[i]) {
  324. case EXTRASAMPLE_UNSPECIFIED:
  325. fprintf(fd, "%sunspecified", sep);
  326. break;
  327. case EXTRASAMPLE_ASSOCALPHA:
  328. fprintf(fd, "%sassoc-alpha", sep);
  329. break;
  330. case EXTRASAMPLE_UNASSALPHA:
  331. fprintf(fd, "%sunassoc-alpha", sep);
  332. break;
  333. default:
  334. fprintf(fd, "%s%u (0x%x)", sep,
  335.     td->td_sampleinfo[i], td->td_sampleinfo[i]);
  336. break;
  337. }
  338. sep = ", ";
  339. }
  340. fprintf(fd, ">n");
  341. }
  342. if (TIFFFieldSet(tif,FIELD_INKNAMES)) {
  343. char* cp;
  344. fprintf(fd, "  Ink Names: ");
  345. i = td->td_samplesperpixel;
  346. sep = "";
  347. for (cp = td->td_inknames; i > 0; cp = strchr(cp,'')+1, i--) {
  348. fputs(sep, fd);
  349. _TIFFprintAscii(fd, cp);
  350. sep = ", ";
  351. }
  352.                 fputs("n", fd);
  353. }
  354. if (TIFFFieldSet(tif,FIELD_THRESHHOLDING)) {
  355. fprintf(fd, "  Thresholding: ");
  356. switch (td->td_threshholding) {
  357. case THRESHHOLD_BILEVEL:
  358. fprintf(fd, "bilevel art scann");
  359. break;
  360. case THRESHHOLD_HALFTONE:
  361. fprintf(fd, "halftone or dithered scann");
  362. break;
  363. case THRESHHOLD_ERRORDIFFUSE:
  364. fprintf(fd, "error diffusedn");
  365. break;
  366. default:
  367. fprintf(fd, "%u (0x%x)n",
  368.     td->td_threshholding, td->td_threshholding);
  369. break;
  370. }
  371. }
  372. if (TIFFFieldSet(tif,FIELD_FILLORDER)) {
  373. fprintf(fd, "  FillOrder: ");
  374. switch (td->td_fillorder) {
  375. case FILLORDER_MSB2LSB:
  376. fprintf(fd, "msb-to-lsbn");
  377. break;
  378. case FILLORDER_LSB2MSB:
  379. fprintf(fd, "lsb-to-msbn");
  380. break;
  381. default:
  382. fprintf(fd, "%u (0x%x)n",
  383.     td->td_fillorder, td->td_fillorder);
  384. break;
  385. }
  386. }
  387. if (TIFFFieldSet(tif,FIELD_YCBCRSUBSAMPLING))
  388.         {
  389.             /*
  390.              * For hacky reasons (see tif_jpeg.c - JPEGFixupTestSubsampling),
  391.              * we need to fetch this rather than trust what is in our
  392.              * structures.
  393.              */
  394.             uint16 subsampling[2];
  396.             TIFFGetField( tif, TIFFTAG_YCBCRSUBSAMPLING, 
  397.                           subsampling + 0, subsampling + 1 );
  398. fprintf(fd, "  YCbCr Subsampling: %u, %un",
  399.                         subsampling[0], subsampling[1] );
  400.         }
  401. if (TIFFFieldSet(tif,FIELD_YCBCRPOSITIONING)) {
  402. fprintf(fd, "  YCbCr Positioning: ");
  403. switch (td->td_ycbcrpositioning) {
  404. case YCBCRPOSITION_CENTERED:
  405. fprintf(fd, "centeredn");
  406. break;
  407. case YCBCRPOSITION_COSITED:
  408. fprintf(fd, "cositedn");
  409. break;
  410. default:
  411. fprintf(fd, "%u (0x%x)n",
  412.     td->td_ycbcrpositioning, td->td_ycbcrpositioning);
  413. break;
  414. }
  415. }
  416. if (TIFFFieldSet(tif,FIELD_HALFTONEHINTS))
  417. fprintf(fd, "  Halftone Hints: light %u dark %un",
  418.     td->td_halftonehints[0], td->td_halftonehints[1]);
  419. if (TIFFFieldSet(tif,FIELD_ORIENTATION)) {
  420. fprintf(fd, "  Orientation: ");
  421. if (td->td_orientation < NORIENTNAMES)
  422. fprintf(fd, "%sn", orientNames[td->td_orientation]);
  423. else
  424. fprintf(fd, "%u (0x%x)n",
  425.     td->td_orientation, td->td_orientation);
  426. }
  427. if (TIFFFieldSet(tif,FIELD_SAMPLESPERPIXEL))
  428. fprintf(fd, "  Samples/Pixel: %un", td->td_samplesperpixel);
  429. if (TIFFFieldSet(tif,FIELD_ROWSPERSTRIP)) {
  430. fprintf(fd, "  Rows/Strip: ");
  431. if (td->td_rowsperstrip == (uint32) -1)
  432. fprintf(fd, "(infinite)n");
  433. else
  434. fprintf(fd, "%lun", (unsigned long) td->td_rowsperstrip);
  435. }
  436. if (TIFFFieldSet(tif,FIELD_MINSAMPLEVALUE))
  437. fprintf(fd, "  Min Sample Value: %un", td->td_minsamplevalue);
  438. if (TIFFFieldSet(tif,FIELD_MAXSAMPLEVALUE))
  439. fprintf(fd, "  Max Sample Value: %un", td->td_maxsamplevalue);
  440. if (TIFFFieldSet(tif,FIELD_SMINSAMPLEVALUE))
  441. fprintf(fd, "  SMin Sample Value: %gn",
  442.     td->td_sminsamplevalue);
  443. if (TIFFFieldSet(tif,FIELD_SMAXSAMPLEVALUE))
  444. fprintf(fd, "  SMax Sample Value: %gn",
  445.     td->td_smaxsamplevalue);
  446. if (TIFFFieldSet(tif,FIELD_PLANARCONFIG)) {
  447. fprintf(fd, "  Planar Configuration: ");
  448. switch (td->td_planarconfig) {
  449. case PLANARCONFIG_CONTIG:
  450. fprintf(fd, "single image planen");
  451. break;
  452. case PLANARCONFIG_SEPARATE:
  453. fprintf(fd, "separate image planesn");
  454. break;
  455. default:
  456. fprintf(fd, "%u (0x%x)n",
  457.     td->td_planarconfig, td->td_planarconfig);
  458. break;
  459. }
  460. }
  461. if (TIFFFieldSet(tif,FIELD_PAGENUMBER))
  462. fprintf(fd, "  Page Number: %u-%un",
  463.     td->td_pagenumber[0], td->td_pagenumber[1]);
  464. if (TIFFFieldSet(tif,FIELD_COLORMAP)) {
  465. fprintf(fd, "  Color Map: ");
  466. if (flags & TIFFPRINT_COLORMAP) {
  467. fprintf(fd, "n");
  468. n = 1L<<td->td_bitspersample;
  469. for (l = 0; l < n; l++)
  470. fprintf(fd, "   %5lu: %5u %5u %5un",
  471.     l,
  472.     td->td_colormap[0][l],
  473.     td->td_colormap[1][l],
  474.     td->td_colormap[2][l]);
  475. } else
  476. fprintf(fd, "(present)n");
  477. }
  478. if (TIFFFieldSet(tif,FIELD_TRANSFERFUNCTION)) {
  479. fprintf(fd, "  Transfer Function: ");
  480. if (flags & TIFFPRINT_CURVES) {
  481. fprintf(fd, "n");
  482. n = 1L<<td->td_bitspersample;
  483. for (l = 0; l < n; l++) {
  484. fprintf(fd, "    %2lu: %5u",
  485.     l, td->td_transferfunction[0][l]);
  486. for (i = 1; i < td->td_samplesperpixel; i++)
  487. fprintf(fd, " %5u",
  488.     td->td_transferfunction[i][l]);
  489. fputc('n', fd);
  490. }
  491. } else
  492. fprintf(fd, "(present)n");
  493. }
  494. if (TIFFFieldSet(tif, FIELD_SUBIFD)) {
  495. fprintf(fd, "  SubIFD Offsets:");
  496. for (i = 0; i < td->td_nsubifd; i++)
  497. fprintf(fd, " %5lu", (long) td->td_subifd[i]);
  498. fputc('n', fd);
  499. }
  501.         /*
  502.         ** Custom tag support.
  503.         */
  504.         {
  505.             int  i;
  506.             short count;
  508.             count = (short) TIFFGetTagListCount(tif);
  509.             for(i = 0; i < count; i++) {
  510.                 ttag_t  tag = TIFFGetTagListEntry(tif, i);
  511.                 const TIFFFieldInfo *fip;
  512.                 uint16 value_count;
  513.                 int mem_alloc = 0;
  514.                 void *raw_data;
  516.                 fip = TIFFFieldWithTag(tif, tag);
  517.                 if(fip == NULL)
  518. continue;
  520. if(fip->field_passcount) {
  521. if(TIFFGetField(tif, tag, &value_count, &raw_data) != 1)
  522. continue;
  523. } else {
  524. if (fip->field_readcount == TIFF_VARIABLE
  525.     || fip->field_readcount == TIFF_VARIABLE2)
  526. value_count = 1;
  527. else if (fip->field_readcount == TIFF_SPP)
  528. value_count = td->td_samplesperpixel;
  529. else
  530. value_count = fip->field_readcount;
  531. if ((fip->field_type == TIFF_ASCII
  532.      || fip->field_readcount == TIFF_VARIABLE
  533.      || fip->field_readcount == TIFF_VARIABLE2
  534.      || fip->field_readcount == TIFF_SPP
  535.      || value_count > 1)
  536.     && fip->field_tag != TIFFTAG_PAGENUMBER
  537.     && fip->field_tag != TIFFTAG_HALFTONEHINTS
  538.     && fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
  539.     && fip->field_tag != TIFFTAG_DOTRANGE) {
  540. if(TIFFGetField(tif, tag, &raw_data) != 1)
  541. continue;
  542. } else if (fip->field_tag != TIFFTAG_PAGENUMBER
  543.    && fip->field_tag != TIFFTAG_HALFTONEHINTS
  544.    && fip->field_tag != TIFFTAG_YCBCRSUBSAMPLING
  545.    && fip->field_tag != TIFFTAG_DOTRANGE) {
  546. raw_data = _TIFFmalloc(
  547. _TIFFDataSize(fip->field_type)
  548. * value_count);
  549. mem_alloc = 1;
  550. if(TIFFGetField(tif, tag, raw_data) != 1) {
  551. _TIFFfree(raw_data);
  552. continue;
  553. }
  554. } else {
  555. /* 
  556.  * XXX: Should be fixed and removed, see the
  557.  * notes related to TIFFTAG_PAGENUMBER,
  558.  * TIFFTAG_HALFTONEHINTS,
  559.  * TIFFTAG_YCBCRSUBSAMPLING and
  560.  * TIFFTAG_DOTRANGE tags in tif_dir.c. */
  561. char *tmp;
  562. raw_data = _TIFFmalloc(
  563. _TIFFDataSize(fip->field_type)
  564. * value_count);
  565. tmp =(char *) raw_data;
  566. mem_alloc = 1;
  567. if(TIFFGetField(tif, tag, tmp,
  568. tmp + _TIFFDataSize(fip->field_type)) != 1) {
  569. _TIFFfree(raw_data);
  570. continue;
  571. }
  572. }
  573. }
  575. /*
  576.  * Catch the tags which needs to be specially handled and
  577.  * pretty print them. If tag not handled in
  578.  * _TIFFPrettyPrintField() fall down and print it as any other
  579.  * tag.
  580.  */
  581. if (_TIFFPrettyPrintField(tif, fd, tag, value_count, raw_data)) {
  582. if(mem_alloc)
  583. _TIFFfree(raw_data);
  584. continue;
  585. }
  586. else
  587. _TIFFPrintField(fd, fip, value_count, raw_data);
  589. if(mem_alloc)
  590. _TIFFfree(raw_data);
  591.             }
  592.         }
  593.         
  594. if (tif->tif_tagmethods.printdir)
  595. (*tif->tif_tagmethods.printdir)(tif, fd, flags);
  596. if ((flags & TIFFPRINT_STRIPS) &&
  597.     TIFFFieldSet(tif,FIELD_STRIPOFFSETS)) {
  598. tstrip_t s;
  600. fprintf(fd, "  %lu %s:n",
  601.     (long) td->td_nstrips,
  602.     isTiled(tif) ? "Tiles" : "Strips");
  603. for (s = 0; s < td->td_nstrips; s++)
  604. fprintf(fd, "    %3lu: [%8lu, %8lu]n",
  605.     (unsigned long) s,
  606.     (unsigned long) td->td_stripoffset[s],
  607.     (unsigned long) td->td_stripbytecount[s]);
  608. }
  609. }
  611. void
  612. _TIFFprintAscii(FILE* fd, const char* cp)
  613. {
  614. for (; *cp != ''; cp++) {
  615. const char* tp;
  617. if (isprint((int)*cp)) {
  618. fputc(*cp, fd);
  619. continue;
  620. }
  621. for (tp = "ttbbrrnnvv"; *tp; tp++)
  622. if (*tp++ == *cp)
  623. break;
  624. if (*tp)
  625. fprintf(fd, "\%c", *tp);
  626. else
  627. fprintf(fd, "\%03o", *cp & 0xff);
  628. }
  629. }
  631. void
  632. _TIFFprintAsciiTag(FILE* fd, const char* name, const char* value)
  633. {
  634. fprintf(fd, "  %s: "", name);
  635. _TIFFprintAscii(fd, value);
  636. fprintf(fd, ""n");
  637. }
  639. /* vim: set ts=8 sts=8 sw=8 noet: */