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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
tagtest.c++
资源名称：hylafax-5.3.0.tar.gz　[点击查看]
上传用户：weiyuanprp
上传日期：2020-05-20
资源大小：1169k
文件大小：18k
源码类别：

传真(Fax)编程

开发平台：

C/C++

tagtest.c++：源码内容
  1. /* $Id: tagtest.c++,v 1.6 2008/01/01 01:21:42 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1994-1996 Sam Leffler
  4.  * Copyright (c) 1994-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26. /*
  27.  * Program for testing tag line imaging support.
  28.  *
  29.  * Usage: tagtest [-f fontfile] [-m format] [-o output.tif] [-l locale] input.tif
  30.  */
  31. #include "Sys.h"
  33. #include "PCFFont.h"
  34. #include "StackBuffer.h"
  35. #include "FaxFont.h"
  36. #include "tiffio.h"
  37. #include "Class2Params.h"
  38. #if HAS_LOCALE
  39. extern "C" {
  40. #include <locale.h>
  41. }
  42. #endif
  43. #if HAS_LANGINFO
  44. extern "C" {
  45. #ifndef __USE_XOPEN
  46. #define __USE_XOPEN
  47. #endif
  48. #include <langinfo.h>
  49. }
  50. #endif
  52. u_int tagLineSlop;
  53. FaxFont* tagLineFont;
  54. u_int pageNumber = 1;
  55. u_int totalPages;
  56. fxStr tagLineFmt("From %%n|%c|Page %%p of %%t");
  57. fxStr tagLineLocale("");
  58. fxStr tagLineFontFile("fixed.pcf");
  59. fxStr jobid("9733");
  60. fxStr jobtag("sendq/q9733");
  61. fxStr localid("Sam's Bar&Grill");
  62. fxStr modemnumber("+15105268781");
  63. fxStr mailaddr("sam@flake.asd.sgi.com");
  64. fxStr external("+14159657824");
  65. fxStr sender("Sam Leffler");
  66. fxStr tagLine;
  67. u_int tagLineFields;
  69. static void
  70. insert(fxStr& tag, u_int l, const fxStr& s)
  71. {
  72.     tag.remove(l,2);
  73.     tag.insert(s, l);
  74. }
  76. /*
  77.  * Read in the PCF font to use for imaging the tag line and
  78.  * preformat as much of the tag line as possible.
  79.  */
  80. void
  81. setupTagLine()
  82. {
  83.     if (tagLineFont == NULL)
  84. tagLineFont = new PCFFont;
  85.     if (!tagLineFont->isReady() && tagLineFontFile != "")
  86. (void) tagLineFont->read(tagLineFontFile);
  87. #ifdef LC_CTYPE
  88.     setlocale(LC_CTYPE, tagLineLocale); // for <ctype.h> calls
  89. #endif
  90. #ifdef LC_TIME
  91.     setlocale(LC_TIME, tagLineLocale); // for strftime calls
  92. #endif
  93.     bool isutf8 = false;
  94. #if HAS_LANGINFO
  95.     isutf8 = (strcmp(nl_langinfo(CODESET), "UTF-8") == 0);
  96.     tagLine.setUTF8(isutf8);
  97. #endif
  99.     time_t t = Sys::now();
  100.     tm* tm = localtime(&t);
  101.     char line[1024];
  102.     strftime(line, sizeof (line), tagLineFmt, tm);
  103.     tagLine = line;
  104.     u_int l = 0;
  105.     while (l < tagLine.length()) {
  106. l = tagLine.next(l, '%');
  107. if (l >= tagLine.length()-1)
  108.     break;
  109. switch (tagLine[l+1]) {
  110. case 'd': insert(tagLine, l, external); break;
  111. case 'i': insert(tagLine, l, jobid); break;
  112. case 'j': insert(tagLine, l, jobtag); break;
  113. case 'l': insert(tagLine, l, localid); break;
  114. case 'm': insert(tagLine, l, mailaddr); break;
  115. case 'n': insert(tagLine, l, modemnumber); break;
  116. case 's': insert(tagLine, l, sender); break;
  117. /* for the purpose of tagtest %%T is the same of %%t */
  118. case 't':   
  119. case 'T': insert(tagLine, l, fxStr((int) totalPages, "%u")); break;
  120. default:  l += 2; break;
  121. }
  122.     }
  123.     /*
  124.      * Break the tag into fields.
  125.      */
  126.     tagLineFields = 0;
  127.     for (l = 0; l < tagLine.length(); l = tagLine.next(l+1, '|'))
  128. tagLineFields++;
  129. }
  131. #define MARGIN_TOP 2
  132. #define MARGIN_BOT 2
  133. #define MARGIN_LEFT 2
  134. #define MARGIN_RIGHT 2
  135. #define SLOP_LINES 3
  137. bool
  138. setupTagLineSlop(const Class2Params& params)
  139. {
  140.     if (tagLineFont->isReady()) {
  141. tagLineSlop = (tagLineFont->fontHeight()+MARGIN_TOP+MARGIN_BOT+SLOP_LINES) * 
  142.     howmany(params.pageWidth(),8);
  143. return (true);
  144.     } else
  145. return (false);
  146. }
  148. #include "MemoryDecoder.h"
  150. /*
  151.  * Image the tag line in place of the top few lines of the page
  152.  * data and return the encoded tag line at the front of the
  153.  * data buffer.  The buffer that holds the page data is assumed
  154.  * to have tagLineSlop extra space allocated in front of the
  155.  * page data.  The tag line format string is assumed to be
  156.  * preprocessed by setupTagLine above so that we only need to
  157.  * setup the current page number.
  158.  */
  159. u_char*
  160. imageTagLine(u_char* buf, u_int fillorder, const Class2Params& params, u_long& totdata)
  161. {
  162.     u_int l;
  163. #ifdef LC_CTYPE
  164.     setlocale(LC_CTYPE, tagLineLocale); // for <ctype.h> calls
  165. #endif
  166. #ifdef LC_TIME
  167.     setlocale(LC_TIME, tagLineLocale); // for strftime calls
  168. #endif
  169.     bool isutf8 = false;
  170. #if HAS_LANGINFO
  171.     isutf8 = (strcmp(nl_langinfo(CODESET), "UTF-8") == 0);
  172.     tagLine.setUTF8(isutf8);
  173. #endif
  174.     /*
  175.      * Fill in any per-page variables used in the tag line.
  176.      */
  177.     fxStr tag = tagLine;
  178.     l = 0;
  179.     while (l < tag.length()) {
  180. l = tag.next(l, '%');
  181. if (l >= tag.length()-1)
  182.     break;
  183. /* for the purpose of tagtest %%P is the same of %%p */
  184. if (tag[l+1] == 'p' || tag[l+1] == 'P')
  185.     insert(tag, l, fxStr((int) pageNumber, "%d"));
  186. else
  187.     l += 2;
  188.     }
  189.     /*
  190.      * Setup the raster in which the tag line is imaged.
  191.      *
  192.      * The font size information received from the font functions
  193.      * are suitable for VR_FINE.  Thus VR_FINE is used as the reference
  194.      * resolution, and all other resolutions must be scaled.
  195.      */
  196.     u_int w = params.pageWidth();
  197.     u_int h = (tagLineFont->fontHeight()*2)+MARGIN_TOP+MARGIN_BOT; // max height - double VR_FINE
  198.     u_int th = 0; // actual tagline height
  199.     switch(params.vr) {
  200. case VR_NORMAL:
  201. case VR_200X100:
  202.     th = (tagLineFont->fontHeight()/2)+MARGIN_TOP+MARGIN_BOT; // half VR_FINE
  203.     break;
  204. case VR_FINE:
  205. case VR_200X200:
  206.     th = tagLineFont->fontHeight()+MARGIN_TOP+MARGIN_BOT; // reference resolution
  207.     break;
  208. case VR_R8:
  209. case VR_R16:
  210. case VR_200X400:
  211. case VR_300X300:        // not proportionate but legible
  212.     th = (tagLineFont->fontHeight()*2)+MARGIN_TOP+MARGIN_BOT; // double VR_FINE
  213.     break;
  214.     }
  215.     /*
  216.      * imageText assumes that raster is word-aligned; we use
  217.      * longs here to optimize the scaling done below for the
  218.      * low res case.  This should satisfy the word-alignment.
  219.      */
  220.     u_int lpr = howmany(w,sizeof(u_long)*8); // longs/raster row
  221.     u_long* raster = new u_long[(h+SLOP_LINES)*lpr]; // decoded raster
  222.     memset(raster,0,(h+SLOP_LINES)*lpr*sizeof (u_long));// clear raster to white
  223.     /*
  224.      * Break the tag into fields and render each piece of
  225.      * text centered in its field.  Experiments indicate
  226.      * that rendering the text over white is better than,
  227.      * say, rendering it over the original page.
  228.      */
  229.     l = 0;
  230.     /*  
  231.      * imageText produces good dimensioned fonts at 1728 pixels/row. At VR_R16
  232.      * and VR_300X300, both being wider than 1728, text appears shrinked
  233.      * horizontally; while VR_300 is still ok, VR_R16 is too small. To help
  234.      * streching the text horizontally we force text imaging to still use
  235.      * 1728 instead of VR_R16's 3456 (3456 / 2 = 1728); text will be
  236.      * imaged the 1st (left) half of the line, it will be stretched after
  237.      * imaging takes place.
  238.      */
  239.     u_int fieldWidth = params.pageWidth() / (params.vr == VR_R16 ? 2 : 1) / tagLineFields;
  240.     for (u_int f = 0; f < tagLineFields; f++) {
  241. fxStr tagField = tag.token(l, '|');
  242. u_int fw, fh;
  243. tagLineFont->strWidth(tagField, fw, fh);
  244. u_int xoff = f*fieldWidth;
  245. if (fw < fieldWidth)
  246.     xoff += (fieldWidth-fw)/2;
  247. else
  248.     xoff += MARGIN_LEFT;
  249. (void) tagLineFont->imageText(tagField, isutf8, (u_short*) raster, w, h,
  250.     xoff, MARGIN_RIGHT, MARGIN_TOP, MARGIN_BOT);
  251.     }
  253.     /*
  254.      * Scale image data as needed (see notes above).
  255.      */
  257.     if (params.vr == VR_NORMAL || params.vr == VR_200X100) {
  258. /*
  259.  * These resolutions require vertical "shrinking" of the
  260.  * tagline image.  We make 1 line out of 2.
  261.  * (Note the ``or'' used to generate the final samples.)
  262.  *
  263.  * Details:  
  264.  * - image is in lines 1 through y
  265.  * - available lines are 1 through y/2
  266.  * - start at the top of the image
  267.  * - line 1 is ORed with line 2 to get new line 1
  268.  * - line 3 is ORed with line 4 to get new line 2
  269.  * - ...
  270.  * - line y is ORed with line y+1 to get new line (y+1)/2
  271.  */
  272. u_long* l1 = raster+MARGIN_TOP*lpr;
  273. u_long* l2 = l1+lpr;
  274. u_long* l3 = raster+MARGIN_TOP*lpr;
  275. for (u_int nr = th-(MARGIN_TOP+MARGIN_BOT); nr; nr--) {
  276.     for (u_int nl = lpr; nl; nl--)
  277. *l3++ = *l1++ | *l2++;
  278.     l1 += lpr;
  279.     l2 += lpr;
  280. }
  281. memset(l3, 0, MARGIN_BOT*lpr*sizeof (u_long));
  282.     }
  283.     if (params.vr == VR_R8 || params.vr == VR_R16 || params.vr == VR_200X400 || params.vr == VR_300X300) {
  284. /*
  285.  * These resolutions require vertical "stretching" of the
  286.  * tagline image.  We make 2 lines out of 1.
  287.  * Go bottom-to-top since the image resides in the top half and the
  288.  * bottom data can be overwritten since it is unset.
  289.  * 
  290.  * Details:
  291.  * - image is in lines 1 through y/2
  292.  * - available lines are 1 through y
  293.  * - we use 2 pointers, 1st starting at line y/2 the other at line y
  294.  * - line y/2   copied in line y   and y-1
  295.  * - line y/2-1 copied in line y-2 and y-2-1
  296.  * - ...
  297.  */
  298. // bottom of actual image
  299. u_long* l1 = raster - 1 + lpr * (MARGIN_TOP + (th-MARGIN_TOP-MARGIN_BOT)/2 + 2);
  300. // bottom of available image
  301. u_long* l2 = raster - 1 + lpr * (MARGIN_TOP + (th-MARGIN_TOP-MARGIN_BOT) + 1);
  303. /* stretch vertically (going backwards, R->L, B->T) */
  304. for (u_int nr = (th-(MARGIN_TOP+MARGIN_BOT))/2; nr; nr--) {
  305.     for (u_int nl = lpr; nl; nl--) { 
  306. *(l2 - lpr) = *l1; /* y/2 copied into y-1 */
  307. *l2 = *l1; /* y/2 copied into y */ 
  308. l2--; /* left 1 long */
  309. l1--; /* left 1 long */
  310.     }
  311.     /* after previous loop, l1 and l2 are up 1 line; l2 needs 1 more */
  312.     l2 -= lpr; /* 2nd ptr up 1 line */
  313. }
  314. if (params.vr == VR_R16) {
  315.     /*
  316.      * hr is twice the hr in which data is imaged.
  317.      * We need to strech the image horizontally:
  318.      * 1234567890ABCDEFGHIJ -> 11223344556677889900
  319.      * (ABCDEFGHIJ is whitespace)
  320.      */
  322.     /* Reset ptr to begin of image */
  323.     l1 = raster + MARGIN_TOP*lpr;               // begin of 1st line
  324.     l2 = raster + MARGIN_TOP*lpr + lpr - 1;     // end of 1st line
  325.     for (u_int nr = th-(MARGIN_TOP+MARGIN_BOT); nr; nr--) {
  326. /*
  327.  * 0      lpr/2      lpr
  328.  * |        |         |
  329.  * 1234567890__________
  330.  * 1234567890________00  x/2   copied into x   and x-1
  331.  * 1234567890______9900  x/2-1 copied into x-2 and x-3
  332.  * ...
  333.  * 11223344556677889900
  334.  */
  335. u_int bpl = sizeof(u_long) * 8; // bits per u_long
  336. for (u_int nl = lpr/2 - 1; nl ; nl--) {
  337.     // make 2 longs out of 1 (ABCD -> AABB CCDD)
  338.     int pos = 0;
  339.     for (u_int i = 0; i < (bpl/8); i++) {
  340. if (i == 0 || i == bpl/8/2) {
  341.     *l2 = (u_long) 0;
  342.     pos = bpl - 2;
  343. }
  344. // put pairs of bits from l1 into the right places within l2
  345. *l2 |= (u_long)((*(l1+nl) & (1<<(bpl-8*i-5))) >> (bpl-8*i-5) << pos);
  346. *l2 |= ((u_long)((*(l1+nl) & (1<<(bpl-8*i-5))) >> (bpl-8*i-5) << pos)) << 1;
  347. pos -= 2;
  349. *l2 |= (u_long)((*(l1+nl) & (1<<(bpl-8*i-6))) >> (bpl-8*i-6) << pos);
  350. *l2 |= ((u_long)((*(l1+nl) & (1<<(bpl-8*i-6))) >> (bpl-8*i-6) << pos)) << 1;
  351. pos -= 2;
  353. *l2 |= (u_long)((*(l1+nl) & (1<<(bpl-8*i-7))) >> (bpl-8*i-7) << pos);
  354. *l2 |= ((u_long)((*(l1+nl) & (1<<(bpl-8*i-7))) >> (bpl-8*i-7) << pos)) << 1;
  355. pos -= 2;
  357. *l2 |= (u_long)((*(l1+nl) & (1<<(bpl-8*i-8))) >> (bpl-8*i-8) << pos);
  358. *l2 |= ((u_long)((*(l1+nl) & (1<<(bpl-8*i-8))) >> (bpl-8*i-8) << pos)) << 1;
  359. pos -= 2;
  361. *l2 |= (u_long)((*(l1+nl) & (1<<(bpl-8*i-1))) >> (bpl-8*i-1) << pos);
  362. *l2 |= ((u_long)((*(l1+nl) & (1<<(bpl-8*i-1))) >> (bpl-8*i-1) << pos)) << 1;
  363. pos -= 2;
  365. *l2 |= (u_long)((*(l1+nl) & (1<<(bpl-8*i-2))) >> (bpl-8*i-2) << pos);
  366. *l2 |= ((u_long)((*(l1+nl) & (1<<(bpl-8*i-2))) >> (bpl-8*i-2) << pos)) << 1;
  367. pos -= 2;
  369. *l2 |= (u_long)((*(l1+nl) & (1<<(bpl-8*i-3))) >> (bpl-8*i-3) << pos);
  370. *l2 |= ((u_long)((*(l1+nl) & (1<<(bpl-8*i-3))) >> (bpl-8*i-3) << pos)) << 1;
  371. pos -= 2;
  373. *l2 |= (u_long)((*(l1+nl) & (1<<(bpl-8*i-4))) >> (bpl-8*i-4) << pos);
  374. *l2 |= ((u_long)((*(l1+nl) & (1<<(bpl-8*i-4))) >> (bpl-8*i-4) << pos)) << 1;
  375. pos -= 2;
  376. if (pos < 0) *l2--;
  377.     }
  378. }
  379. l1 += lpr;              // begin of next line
  380. l2 = l1 + lpr - 1;      // end of next line
  381.     }
  382. }
  383. memset(l2, 0, MARGIN_BOT*lpr*sizeof (u_long));
  384.     }
  385.     MemoryDecoder dec(buf, w, totdata, fillorder, params.is2D(), (params.df == DF_2DMMR));
  386.     u_char* encbuf = dec.encodeTagLine(raster, th, tagLineSlop);
  387.     totdata = dec.getCC();
  388.     return (encbuf);
  389. }
  391. void
  392. vlogError(const char* fmt, va_list ap)
  393. {
  394.     vfprintf(stderr, fmt, ap);
  395.     fputs(".n", stderr);
  396. }
  398. // NB: must duplicate this to avoid pulling faxApp&co.
  400. extern "C" void
  401. _fxassert(const char* msg, const char* file, int line)
  402. {
  403.     fprintf(stderr, "Assertion failed "%s", file "%s" line %d.n", 
  404. msg, file, line);
  405.     abort();
  406.     /*NOTREACHED*/
  407. }
  409. const char* appName;
  411. void
  412. usage()
  413. {
  414.     fprintf(stderr,
  415. "usage: %s [-m format] [-o t.tif] [-f font.pcf] [-l locale] input.tifn",
  416. appName);
  417.     exit(-1);
  418. }
  420. void
  421. fatal(const char* fmt ...)
  422. {
  423.     fprintf(stderr, "%s: ", appName);
  424.     va_list ap;
  425.     va_start(ap, fmt);
  426.     vfprintf(stderr, fmt, ap);
  427.     va_end(ap);
  428.     fputs(".n", stderr);
  429.     exit(-1);
  430. }
  432. int
  433. main(int argc, char* argv[])
  434. {
  435.     extern int optind;
  436.     extern char* optarg;
  437.     int c;
  438.     const char* output = "t.tif";
  440. #ifdef LC_CTYPE
  441.     setlocale(LC_CTYPE, ""); // for <ctype.h> calls
  442. #endif
  443. #ifdef LC_TIME
  444.     setlocale(LC_TIME, ""); // for strftime calls
  445. #endif
  446.     appName = argv[0];
  447.     while ((c = Sys::getopt(argc, argv, "f:l:m:o:")) != -1)
  448. switch (c) {
  449. case 'f':
  450.     tagLineFontFile = optarg;
  451.     break;
  452. case 'l':
  453.     tagLineLocale = optarg;
  454.     break;
  455. case 'm':
  456.     tagLineFmt = optarg;
  457.     break;
  458. case 'o':
  459.     output = optarg;
  460.     break;
  461. case '?':
  462.     usage();
  463.     /*NOTREACHED*/
  464. }
  465.     if (argc - optind != 1)
  466. usage();
  467.     TIFF* tif = TIFFOpen(argv[optind], "r");
  468.     if (!tif)
  469. fatal("%s: Cannot open, or not a TIFF file", argv[optind]);
  470.     uint16 comp;
  471.     TIFFGetField(tif, TIFFTAG_COMPRESSION, &comp);
  472.     if (comp != COMPRESSION_CCITTFAX3 && comp != COMPRESSION_CCITTFAX4)
  473. fatal("%s: Not a Group 3 or Group 4-encoded TIFF file", argv[optind]);
  474.     setupTagLine();
  475.     if (!tagLineFont->isReady())
  476. fatal("%s: Problem reading font", (const char*) tagLineFontFile);
  478.     TIFF* otif = TIFFOpen(output, "w");
  479.     if (!otif)
  480. fatal("%s: Cannot create output file", output);
  481.     for (totalPages = 1; TIFFReadDirectory(tif); totalPages++)
  482. ;
  483.     TIFFSetDirectory(tif, 0);
  485.     Class2Params params;
  486.     params.vr = VR_NORMAL;
  487.     params.wd = WD_A4;
  488.     params.ln = LN_INF;
  489.     params.df = DF_1DMH;
  491.     pageNumber = 1;
  493.     setupTagLine();
  494.     do {
  495. uint32 l, w;
  496. TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &l);
  497. TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &w);
  499. TIFFSetField(otif, TIFFTAG_SUBFILETYPE, FILETYPE_PAGE);
  500. TIFFSetField(otif, TIFFTAG_IMAGEWIDTH, w);
  501. /* 
  502.  * Values sampled using tiffinfo on tif generated by ps2fax
  503.  * VR_NORMAL     w=1728 l=1169
  504.  * VR_100X200    w=1728 l=?
  505.  * VR_FINE       w=1728 l=2292
  506.  * VR_200X200    w=1728 l=2339
  507.  * VR_R8         w=1728 l=4573
  508.  * VR_200X400    w=1728 l=4578
  509.  * VR_300X300    w=2592 l=3508
  510.  * VR_R16        w=3456 l=4573
  511.  *
  512.  * To simplify the setting of params.vr we use:
  513.  * VR_NORMAL in place of VR_100X200
  514.  * VR_FINE   in place of VR_200X200
  515.  * VR_R8     in place of VR_200X400
  516.  * for the purpose of imaging tagline this shouldn't make a difference 
  517.  *
  518.  */
  519. if (w <= 2000)
  520.     params.vr = (l < 1500 ? VR_NORMAL : l < 3000 ? VR_FINE : VR_R8);
  521. else if (w <= 3000)
  522.     params.vr = VR_300X300;
  523. else
  524.     params.vr = VR_R16;
  525. TIFFSetField(otif, TIFFTAG_XRESOLUTION, (float) params.horizontalRes());
  526. TIFFSetField(otif, TIFFTAG_YRESOLUTION, (float) params.verticalRes());
  527. TIFFSetField(otif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
  528. TIFFSetField(otif, TIFFTAG_IMAGELENGTH, l);
  529. TIFFSetField(otif, TIFFTAG_BITSPERSAMPLE, 1);
  530. TIFFSetField(otif, TIFFTAG_SAMPLESPERPIXEL, 1);
  531. TIFFSetField(otif, TIFFTAG_FILLORDER, FILLORDER_LSB2MSB);
  532. TIFFSetField(otif, TIFFTAG_FILLORDER, FILLORDER_LSB2MSB);
  533. uint32 r;
  534. TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &r);
  535. TIFFSetField(otif, TIFFTAG_ROWSPERSTRIP, r);
  536. TIFFSetField(otif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
  537. TIFFSetField(otif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE);
  539. TIFFSetField(otif, TIFFTAG_COMPRESSION, comp);
  540. uint32 opts = 0;
  541. if (comp != COMPRESSION_CCITTFAX4) {
  542.     TIFFGetField(tif, TIFFTAG_GROUP3OPTIONS, &opts);
  543.     params.df = (opts & GROUP3OPT_2DENCODING) ? DF_2DMR : DF_1DMH;
  544.     TIFFSetField(otif, TIFFTAG_GROUP3OPTIONS, opts);
  545. } else {
  546.     TIFFGetField(tif, TIFFTAG_GROUP4OPTIONS, &opts);
  547.             params.df = DF_2DMMR;
  548.     TIFFSetField(tif, TIFFTAG_GROUP4OPTIONS, opts);
  549. }
  550. uint16 o;
  551. if (TIFFGetField(otif, TIFFTAG_ORIENTATION, &o))
  552.     TIFFSetField(tif, TIFFTAG_ORIENTATION, o);
  554. uint16 fillorder;
  555. TIFFGetFieldDefaulted(tif, TIFFTAG_FILLORDER, &fillorder);
  556. uint32* stripbytecount;
  557. (void) TIFFGetField(tif, TIFFTAG_STRIPBYTECOUNTS, &stripbytecount);
  559. bool firstStrip = setupTagLineSlop(params);
  560. u_int ts = tagLineSlop;
  561. for (u_int strip = 0; strip < TIFFNumberOfStrips(tif); strip++) {
  562.     u_long totbytes = (u_long) stripbytecount[strip];
  563.     if (totbytes > 0) {
  564. u_char* data = new u_char[totbytes+ts];
  565. if (TIFFReadRawStrip(tif, strip, data+ts, totbytes) >= 0) {
  566.     u_char* dp;
  567.     if (firstStrip) {
  568. uint32 rowsperstrip;
  569. TIFFGetFieldDefaulted(tif, TIFFTAG_ROWSPERSTRIP, &rowsperstrip);  
  570. if (rowsperstrip == (uint32) -1)
  571.     TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &rowsperstrip);
  572. /*
  573.  * Generate tag line at the top of the page.
  574.  */
  575. u_long totdata = totbytes;
  576. dp = imageTagLine(data+ts, fillorder, params, totdata);
  577. totbytes = (params.df == DF_2DMMR) ? totdata : totbytes+ts - (dp-data);
  578. firstStrip = false;
  579.     } else
  580. dp = data;
  581.     if (fillorder != FILLORDER_LSB2MSB)
  582. TIFFReverseBits(dp, totbytes);
  583.     if (TIFFWriteRawStrip(otif, strip, dp, totbytes) == -1)
  584. fatal("%s: Write error at strip %u, writing %lu bytes", 
  585.     output, strip, (u_long) totbytes);
  586. }
  587. delete data;
  588.     }
  589. }
  590. pageNumber++;
  591.     } while (TIFFReadDirectory(tif) && TIFFWriteDirectory(otif));
  592.     TIFFClose(otif);
  593.     return (0);
  594. }