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

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

传真(Fax)编程

开发平台：

C/C++

imgtofax.c：源码内容
  1. /* $Id: imgtofax.c,v 1.2 2006/06/22 04:11:37 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1990-1996 Sam Leffler
  4.  * Copyright (c) 1991-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.  * Prepare SGI image files for transmission as facsimile.
  28.  * Each image is scaled to fit a standard page, sharpened
  29.  * with a hipass filter, gamma warp'd, and then dithered
  30.  * to a bilevel image.
  31.  *
  32.  * Output is a single TIFF Class F file with each image as
  33.  * a separate page/directory.
  34.  *
  35.  * Derived from Paul Haeberli's imgtofax program.
  36.  */
  37. #include <stdio.h>
  38. #include <math.h>
  39. #include <image.h>
  40. #include "hipass.h"
  41. #include "izoom.h"
  42. #include "lut.h"
  43. #include "lum.h"
  44. #include "tiffio.h"
  45. #include <stdarg.h>
  46. #include "PageSize.h"
  48. #define GAMMAVAL        0.8
  50. #define DEF_MARGIN 14
  51. #define DEF_TOPMARGIN 0
  52. #define DEF_BOTMARGIN 0
  54. static short sbuf[4096];
  55. static IMAGE* iimage;
  56. static highpass *hp;
  57. static zoom* zm;
  58. static TIFF* tif;
  59. static lut* lookup;
  60. static int npages;
  62. static int pixelWidth;
  63. static int pixelHeight;
  64. static int leftMargin = DEF_MARGIN;
  65. static int rightMargin = DEF_MARGIN;
  66. static int topMargin = DEF_TOPMARGIN;
  67. static int bottomMargin = DEF_BOTMARGIN;
  68. static int pageWidth;
  69. static int pageHeight;
  70. static float pageres = 196.; /* default is medium res */
  71. static long g3opts = GROUP3OPT_FILLBITS;
  73. static void
  74. fatal(char* va_alist, ...)
  75. #define fmt va_alist
  76. {
  77.     va_list ap;
  78.     va_start(ap, fmt);
  79.     fprintf(stderr, "sgi2fax: ");
  80.     vfprintf(stderr, fmt, ap);
  81.     fprintf(stderr, ".n");
  82.     va_end(ap);
  83.     exit(-1);
  84. }
  85. #undef fmt
  87. static void
  88. getimgrow(buf,y)
  89. short *buf;
  90. int y;
  91. {
  92.     getbwrow(iimage,buf,iimage->ysize-1-y);
  93. }
  95. static void
  96. getzrow(buf,y)
  97. short *buf;
  98. int y;
  99. {
  100.     getzoomrow(zm,buf,y);
  101. }
  103. static void
  104. tofax(short* wp, int n)
  105. {
  106. #define MAXXSIZE 2432
  107.     unsigned char row[(MAXXSIZE+7) &~ 7], *rp = row;
  108.     int bit = 0x80;
  110.     memset(row, 0, sizeof (row));
  111.     while (n-- > 0) {
  112. if (*wp++ < 128)
  113.     *rp |= bit;
  114. if ((bit >>= 1) == 0) {
  115.     rp++;
  116.     bit = 0x80;
  117. }
  118.     }
  119.     (void) TIFFWriteScanline(tif, row,
  120. TIFFCurrentRow(tif) == (uint32) -1 ? 0 : TIFFCurrentRow(tif), 0);
  121. }
  123. static float transfunc(f)
  124. float f;
  125. {
  126.     return pow(f,GAMMAVAL);
  127. }
  129. /* 
  130.  *      dithering stuff follows
  131.  *
  132.  */
  133. #define MATSIZE88
  135. #define XSIZE   8
  136. #define YSIZE   8
  138. #ifdef notdef
  139. static short Xdithmat[YSIZE][XSIZE] = {         /* 8x8 floyd-steinberg */
  140.         0,      8,      36,     44,     2,      10,     38,     46,
  141.         16,     24,     52,     60,     18,     26,     54,     62,
  142.         32,     40,     4,      12,     34,     42,     6,      14,
  143.         48,     56,     20,     28,     50,     58,     22,     30,
  144.         3,      11,     39,     47,     1,      9,      37,     45,
  145.         19,     27,     55,     63,     17,     25,     53,     61,
  146.         35,     43,     7,      15,     33,     41,     5,      13,
  147.         51,     59,     23,     31,     49,     57,     21,     29,
  148. };
  149. #endif
  150. static short dithmat[YSIZE][XSIZE] = {          /* halftone dots */
  151.         3,      17,     55,     63,     61,     47,     9,      1,
  152.         15,     29,     39,     51,     49,     35,     25,     13,
  153.         40,     32,     26,     20,     22,     30,     36,     42,
  154.         56,     44,     10,     4,      6,      18,     52,     58,
  155.         60,     46,     8,      0,      2,      16,     54,     62,
  156.         48,     34,     24,     12,     14,     28,     38,     50,
  157.         23,     31,     37,     43,     41,     33,     27,     21,
  158.         7,      19,     53,     59,     57,     45,     11,     5,
  159. };
  161. #define TOTAL           (XSIZE*YSIZE)
  163. static ditherrow(buf,y,n)
  164. short *buf;
  165. int y, n;
  166. {
  167.     int r, val;
  168.     int rshades, rmaxbits;
  169.     short *rdith;
  171.     rdith = &dithmat[y%YSIZE][0];
  172.     rshades = TOTAL+1;
  173.     rmaxbits = ((rshades-1)/TOTAL);
  174.     while(n--) {
  175.         r = *buf;
  176.         val = (rshades*r)/255;
  177.         if(val>=TOTAL) 
  178.             *buf++ = 255;
  179.         else if(val>rdith[n%XSIZE])
  180.             *buf++ = 255;
  181.         else
  182.             *buf++ = 0;
  183.     }
  184. }
  186. static void
  187. blankSpace(int nrows)
  188. {
  189.     setrow(sbuf,255,pixelWidth);
  190.     while (nrows-- > 0)
  191.         tofax(sbuf,pixelWidth);
  192. }
  194. static void
  195. imgtofax(char* input, int pn)
  196. {
  197.     int ixsize, iysize;
  198.     int oxsize, oysize;
  199.     int ymargin;
  200.     int y;
  202.     TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, (long) pixelWidth);
  203.     TIFFSetField(tif, TIFFTAG_IMAGELENGTH, (long) pixelHeight);
  204.     TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, -1L);
  205.     TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 1);
  206.     TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
  207.     TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
  208.     TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX3);
  209.     TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE);
  210.     TIFFSetField(tif, TIFFTAG_FILLORDER, FILLORDER_LSB2MSB);
  211.     TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
  212.     TIFFSetField(tif, TIFFTAG_XRESOLUTION, 204.);
  213.     TIFFSetField(tif, TIFFTAG_YRESOLUTION, pageres);
  214.     TIFFSetField(tif, TIFFTAG_PAGENUMBER, pn, npages);
  215.     TIFFSetField(tif, TIFFTAG_CLEANFAXDATA, CLEANFAXDATA_CLEAN);
  216.     { char buf[1024];
  217.       snprintf(buf, sizeof(buf) - 1, "Ditherered B&W version of %s", input);
  218.       TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, buf);
  219.     }
  220.     TIFFSetField(tif, TIFFTAG_SOFTWARE, "sgi2fax");
  221.     TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_BOTLEFT);
  222.     TIFFSetField(tif, TIFFTAG_GROUP3OPTIONS, g3opts);
  224. /* calculate the zoom factor */
  225.     ixsize = iimage->xsize;
  226.     iysize = iimage->ysize;
  227.     oxsize = pageWidth;
  228.     oysize = (iysize*pageWidth)/ixsize; /* maintain aspect ratio */
  229.     if (pageres == 98.)
  230. oysize /= 2;
  232. /* set up the filters */
  233.     zm = newzoom(getimgrow, ixsize, iysize, oxsize, oysize, TRIANGLE, 1.0);
  234.     hp = newhp(getzrow, oxsize, oysize, 2.0);
  236.     ymargin = (pageHeight-oysize)/2;
  237.     if(ymargin<0)
  238.         ymargin = 0;
  239.     blankSpace(topMargin + ymargin);
  240.     for(y=0; y<oysize; y++) {
  241.         hpgetrow(hp, sbuf, y); 
  242.         applylut(lookup, sbuf, oxsize);
  243.         ditherrow(sbuf, y, oxsize);
  244.         tofax(sbuf, pixelWidth);
  245.     }
  246.     blankSpace(bottomMargin + ymargin);
  248.     freezoom(zm);
  249.     freehp(hp);
  251.     TIFFWriteDirectory(tif);
  252. }
  254. static void
  255. usage()
  256. {
  257.     fprintf(stderr, "usage: sgi2fax %s %s %s %s %s %s %s [-12] file ...n",
  258. "[-h height]",
  259. "[-w width]",
  260. "[-v vres]",
  261. "[-o output]",
  262. "[-r %red]",
  263. "[-g %green]",
  264. "[-b %blue]",
  265. ""
  266.     );
  267.     exit(-1);
  268. }
  270. #define CVT(x) (((x)*255)/100)
  272. main(argc, argv)
  273.     int argc;
  274.     char **argv;
  275. {
  276.     extern int optind;
  277.     extern char* optarg;
  278.     char* output = "sgi.fax";
  279.     int c;
  280.     float w, h;
  281.     struct pageSizeInfo* info;
  283.     info = getPageSize("default");
  284.     w = getPageWidth(info);
  285.     h = getPageHeight(info);
  286.     delPageSize(info);
  287.     while ((c = Sys::getopt(argc, argv, "o:r:g:b:h:s:v:w:12")) != -1)
  288. switch (c) {
  289. case '1':
  290.     g3opts &= ~GROUP3OPT_2DENCODING;
  291.     break;
  292. case '2':
  293.     g3opts |= GROUP3OPT_2DENCODING;
  294.     break;
  295. case 'r': /* %red illumination */
  296.     _RILUM = CVT(atoi(optarg));
  297.     break;
  298. case 'g': /* %green illumination */
  299.     _GILUM = CVT(atoi(optarg));
  300.     break;
  301. case 'b': /* %blue illumination */
  302.     _BILUM = CVT(atoi(optarg));
  303.     break;
  304. case 'o': /* output file */
  305.     output = optarg;
  306.     break;
  307. case 's': /* page size */
  308.     info = getPageSize(optarg);
  309.     if (!info) {
  310. fprintf(stderr, "%s: Unknown page size "%s".n",
  311.     argv[0], optarg);
  312. exit(-1);
  313.     }
  314.     w = getPageWidth(info);
  315.     h = getPageHeight(info);
  316.     delPageSize(info);
  317.     break;
  318. case 'v': /* vertical resolution (lines/inch) */
  319.     pageres = atof(optarg);
  320.     /* XXX force acceptable resolutions */
  321.     if (pageres < 120.)
  322. pageres = 98.;
  323.     else
  324. pageres = 196.;
  325.     break;
  326. case 'w': /* page width (mm) */
  327.     w = atof(optarg);
  328.     break;
  329. case 'h': /* page height (mm) */
  330.     h = atof(optarg);
  331.     break;
  332. case '?':
  333.     usage();
  334. }
  335.     if (argc - optind < 1)
  336. usage();
  338.     /* XXX force known sizes */
  339.     if (w > 280)
  340. pixelWidth = 2432;
  341.     else if (w > 230)
  342. pixelWidth = 2048;
  343.     else
  344. pixelWidth = 1728;
  345.     if (h > 350)
  346. pixelHeight = 2810;
  347.     else if (h > 280)
  348. pixelHeight = 2292;
  349.     else
  350. pixelHeight = 2166;
  352.     if (pageres == 98.) {
  353. pixelHeight /= 2;
  354. topMargin /= 2;
  355. bottomMargin /= 2;
  356.     }
  357.     pageWidth = pixelWidth - (leftMargin + rightMargin);
  358.     pageHeight = pixelHeight - (topMargin + bottomMargin);
  360. /* open the output file */
  361.     tif = TIFFOpen(output, "w");
  362.     if (!tif)
  363. fatal("%s: Can not create output file", output);
  365.     lookup = makelut(transfunc,256,256,0);
  367.     npages = argc - optind;
  368.     for (c = 0; optind < argc; c++, optind++) {
  369. iimage = iopen(argv[optind], "r");
  370. if (!iimage) {
  371.     fprintf(stderr, "sgi2fax: %s: Can not openn", argv[optind]);
  372.     continue;
  373. }
  374. imgtofax(argv[optind], c);
  375.     }
  376.     TIFFClose(tif);
  377.     freelut(lookup);
  378.     exit(0);
  379. }