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

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

传真(Fax)编程

开发平台：

C/C++

CopyQuality.c++：源码内容
  1. /* $Id: CopyQuality.c++,v 1.17 2008/11/24 06:17:59 faxguy Exp $ */ /*
  2.  * Copyright (c) 1994-1996 Sam Leffler
  3.  * Copyright (c) 1994-1996 Silicon Graphics, Inc.
  4.  * HylaFAX is a trademark of Silicon Graphics
  5.  *
  6.  * Permission to use, copy, modify, distribute, and sell this software and 
  7.  * its documentation for any purpose is hereby granted without fee, provided
  8.  * that (i) the above copyright notices and this permission notice appear in
  9.  * all copies of the software and related documentation, and (ii) the names of
  10.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  11.  * publicity relating to the software without the specific, prior written
  12.  * permission of Sam Leffler and Silicon Graphics.
  13.  * 
  14.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  15.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  16.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  17.  * 
  18.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  19.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  20.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  21.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  22.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  23.  * OF THIS SOFTWARE.
  24.  */
  26. /*
  27.  * Page Data Receive and Copy Quality Support for Modem Drivers.
  28.  */
  29. #include "config.h"
  30. #include "Sys.h"
  31. #include "FaxModem.h"
  32. #include "FaxTrace.h"
  33. #include "ModemConfig.h"
  34. #include "StackBuffer.h"
  35. #include "FaxServer.h"
  37. #include <ctype.h>
  39. #define RCVBUFSIZ (32*1024) // XXX
  41. static void setupCompression(TIFF*, u_int, u_int, uint32);
  43. void
  44. FaxModem::setupStartPage(TIFF* tif, const Class2Params& params)
  45. {
  46.     /*
  47.      * Not doing copy quality checking so compression and
  48.      * Group3Options must reflect the negotiated session
  49.      * parameters for the forthcoming page data.
  50.      */
  51.     setupCompression(tif, params.df, params.jp, group3opts);
  52.     /*
  53.      * Do magic at page start to collect the file offset
  54.      * to the start of the page data--this is used in case
  55.      * of an error to overwrite unacceptable page data.
  56.      *
  57.      * NB: This must be done *after* setting the compression
  58.      *     scheme, otherwise the TIFF library will disallow
  59.      *     setting the Compression tag.
  60.      */
  61.     recvStartPage(tif);
  62. }
  64. void
  65. FaxModem::recvEndPage(TIFF* tif, const Class2Params& params)
  66. {
  67.     /*
  68.      * FAXRECVPARAMS is limited to a 32-bit value, and as that is quite
  69.      * limited in comparison to all possible fax parameters, FAXDCS is
  70.      * intended to be used to discern most fax parameters.  The DCS
  71.      * signal, however, does not contain bitrate information when V.34-Fax
  72.      * is used, so tiffinfo, for example, will use FAXDCS for all fax
  73.      * parameters except for bitrate which comes from FAXRECVPARAMS.
  74.      *
  75.      * As FAXDCS is more recent in libtiff than is FAXRECVPARAMS some
  76.      * installations may not be able to use FAXDCS, in which case those
  77.      * installations will be limited to the 32-bit restraints.
  78.      */
  79.     // NB: must set these after compression tag
  80. #ifdef TIFFTAG_FAXRECVPARAMS
  81.     TIFFSetField(tif, TIFFTAG_FAXRECVPARAMS, (uint32) params.encode());
  82. #endif
  83. #ifdef TIFFTAG_FAXDCS
  84.     FaxParams pageparams = FaxParams(params);
  85.     fxStr faxdcs = "";
  86.     pageparams.asciiEncode(faxdcs);
  87.     TIFFSetField(tif, TIFFTAG_FAXDCS, (const char*) faxdcs);
  88. #endif
  89. #ifdef TIFFTAG_FAXSUBADDRESS
  90.     if (sub != "")
  91. TIFFSetField(tif, TIFFTAG_FAXSUBADDRESS, (const char*) sub);
  92. #endif
  93. #ifdef TIFFTAG_FAXRECVTIME
  94.     TIFFSetField(tif, TIFFTAG_FAXRECVTIME,
  95. (uint32) server.setPageTransferTime());
  96. #endif
  97. }
  99. void
  100. FaxModem::resetLineCounts()
  101. {
  102.     recvEOLCount = 0; // count of EOL codes
  103.     recvBadLineCount = 0; // rows with a decoding error
  104.     recvConsecutiveBadLineCount = 0; // max consecutive bad rows
  105.     linesWereA4Width = 0; // rows that measured 1728 pels
  106. }
  108. void
  109. FaxModem::initializeDecoder(const Class2Params& params)
  110. {
  111.     setupDecoder(recvFillOrder, params.is2D(), (params.df == DF_2DMMR));
  113.     u_int rowpixels = params.pageWidth(); // NB: assume rowpixels <= 4864
  114.     tiff_runlen_t runs[2*4864]; // run arrays for cur+ref rows
  115.     setRuns(runs, runs+4864, rowpixels);
  116.     setIsECM(false);
  117.     resetLineCounts();
  118. }
  120. /*
  121.  * Receive Phase C data with or without copy
  122.  * quality checking and erroneous row fixup.
  123.  */
  124. bool
  125. FaxModem::recvPageDLEData(TIFF* tif, bool checkQuality,
  126.     const Class2Params& params, fxStr& emsg)
  127. {
  128.     /* For debugging purposes we may want to write the image-data to file. */
  129.     if (conf.saverawimage) imagefd = Sys::open("/tmp/in.fax", O_RDWR|O_CREAT|O_EXCL);
  131.     initializeDecoder(params);
  132.     u_int rowpixels = params.pageWidth(); // NB: assume rowpixels <= 4864
  133.     /*
  134.      * Data destined for the TIFF file is buffered in buf.
  135.      * recvRow points to the next place in buf where data
  136.      * (decoded or undecoded) is to be placed.  Beware
  137.      * that this is not an automatic variable because our
  138.      * use of setjmp/longjmp to deal with EOF and RTC detection
  139.      * does not guarantee correct values being restored to
  140.      * automatic variables when the stack is unwound.
  141.      */
  142.     u_char buf[RCVBUFSIZ]; // output buffer
  143.     recvRow = buf; // current decoded row
  144.     recvStrip = 0; // TIFF strip number
  145.     bytePending = 0;
  146.     if (EOFraised()) {
  147. abortPageRecv();
  148. emsg = "Missing EOL after 5 seconds {E050}";
  149. recvTrace("%s", (const char*) emsg);
  150. return (false);
  151.     }
  152.     if (checkQuality && params.ec == EC_DISABLE) {
  153. /*
  154.  * Receive a page of data w/ copy quality checking.
  155.  * Note that since we decode and re-encode we can
  156.  * trivially do transcoding by just changing the
  157.  * TIFF tag values setup for each received page.  This
  158.  * may however be too much work for some CPUs.
  159.  *
  160.  * Copy quality checking is superfluous when using ECM.
  161.  */
  162. tsize_t rowSize = TIFFScanlineSize(tif);// scanline buffer size
  163. /*
  164.  * When copy quality checking is done we generate multi-strip
  165.  * images where the strip size is dependent on the size of the
  166.  * receive buffer used to buffer decoded image data.  There is
  167.  * a balance here between reducing i/o, minimizing encoding
  168.  * overhead, and minimizing delays that occur in the middle of
  169.  * page data receive operations.  If the receive buffer is made
  170.  * too large then a modem with little buffering may have a
  171.  * data underrun occur.  On the other hand encoding each row of
  172.  * data adds to the overhead both in setup time for the encoder
  173.  * and in various accounting work done by the TIFF library when
  174.  * images are grown row-by-row.  All this is also dependent on
  175.  * the speed of the host CPU and i/o performance.
  176.  */
  177. TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, RCVBUFSIZ / rowSize);
  178. /*
  179.  * Since we decode and re-encode we can choose any
  180.  * compression scheme we want for the data that's
  181.  * eventually written to the file.
  182.  */
  183. u_int df = (conf.recvDataFormat == DF_ALL ?
  184.     params.df : conf.recvDataFormat);
  185. setupCompression(tif, df, 0, 0); // XXX maybe zero-fill EOLs?
  186. /*
  187.  * Do magic at page start to collect the file offset
  188.  * to the start of the page data--this is used in case
  189.  * of an error to overwrite unacceptable page data.
  190.  *
  191.  * NB: This must be done *after* setting the compression
  192.  *     scheme, otherwise the TIFF library will disallow
  193.  *     setting the Compression tag.
  194.  */
  195. recvStartPage(tif);
  197. u_char* curGood = (u_char*) malloc((size_t) rowSize);
  198. memset(curGood, 0, (size_t) rowSize); // clear to white
  199. recvBuf = NULL; // don't need raw data
  200. lastRowBad = false; // no previous row
  201. cblc = 0; // current bad line run
  202. if (!RTCraised()) {
  203.     for (;;) {
  204. /*
  205.  * Decode the next row of data into the raster.  If
  206.  * an error is encountered, replicate the last good
  207.  * row and continue.  We track statistics on bad
  208.  * lines and consecutive bad lines; these are used
  209.  * later for deciding whether or not the page quality
  210.  * is acceptable.
  211.  */
  212. decodedPixels = rowpixels; // assume no error
  213. bool decodeOK = decodeRow(recvRow, rowpixels);
  214. if (seenRTC()) // seen RTC, flush everything
  215.     continue;
  216. if (decodeOK) {
  217.     if (lastRowBad) { // reset run statistics
  218. lastRowBad = false;
  219. if (cblc > recvConsecutiveBadLineCount)
  220.     recvConsecutiveBadLineCount = cblc;
  221. cblc = 0;
  222.     }
  223. } else {
  224.     /*
  225.      * Our copy-quality correction mechanism involves decoding
  226.      * and re-encoding each line (as is being done), and if a
  227.      * line is decoded with error (short pixel count) then the
  228.      * remaining pixels are carried-over from the row above.
  229.      * This is done instead of replacing the corrupt row with
  230.      * the last good row to avoid severe data loss where the
  231.      * decoded data is still valid (only incomplete), and this
  232.      * is done instead of replacing the missing data with white
  233.      * to avoid visual disconnect of blackened areas.
  234.      */
  235.     if ((u_int) decodedPixels < rowpixels) {
  236. u_int filledchars = (decodedPixels + 7) / 8;
  237. u_short rembits = decodedPixels % 8;
  238. memcpy(recvRow + filledchars, curGood + filledchars, rowSize - filledchars);
  239. if (rembits) {
  240.     // now deal with the transitional character
  241.     u_char remmask = 0;
  242.     for (u_short bit = 0; bit < 8; bit++) {
  243. remmask<<=1;
  244. if (bit < rembits) remmask |= 1;
  245.     }
  246.     recvRow[filledchars-1] = (recvRow[filledchars-1] & remmask) | (curGood[filledchars-1] & ~remmask);
  247. }
  248.     } else if ((u_int) decodedPixels >= rowpixels) {
  249. /*
  250.  * If we get a long pixel count, then our correction mechanism
  251.  * involves trimming horizontal "streaks" at the end of the
  252.  * scanline and replacing that data with the corresponding data
  253.  * from the preceding scanline.  If the streak doesn't exceed
  254.  * rowpixels, then copy quality checking won't catch it, so
  255.  * streaks can still appear, but this does well at getting most
  256.  * of them in practice.
  257.  */
  258. u_int pos = rowSize - 1;
  259. u_char streak = recvRow[pos];
  260. if (streak == 0xFF || streak == 0x00) {
  261.     while (pos && recvRow[pos] == streak) {
  262. recvRow[pos] = curGood[pos];
  263. pos--;
  264.     }
  265. }
  266.     }
  267.     /*
  268.      * Some senders signal the wrong page width in DCS, such as A3,
  269.      * and then proceed to deliver A4 page image data.  The copy
  270.      * quality correction mechanism will allow the image data to get
  271.      * through, with white space on the right, but it's better to
  272.      * avoid sending RTN, as it will only cause more of the same or
  273.      * will cause the sender to disconnect.  So if the we seem to
  274.      * be getting A4 page data when something else was negotiated
  275.      * we don't count those lines as bad.
  276.      */
  277.     linesWereA4Width += decodedPixels == 1728 ? 1 : 0;
  278.     if (decodedPixels != 1728 || linesWereA4Width < ((recvEOLCount + 1) * 95 / 100)) {
  279. recvBadLineCount++;
  280. cblc++;
  281. lastRowBad = true;
  282.     }
  283. }
  284. if (decodedPixels) memcpy(curGood, recvRow, (size_t) rowSize);
  285. /*
  286.  * Advance forward a scanline and if necessary
  287.  * flush the buffer.  Note that we leave the
  288.  * pointer to the last good row of data at the
  289.  * last decoded line near the end of the buffer.
  290.  * We assume the buffer is large enough that we
  291.  * don't have to worry about overlapping with the
  292.  * next decoded scanline.
  293.  */
  294. recvRow += rowSize;
  295. recvEOLCount++;
  296. if (recvRow + rowSize > &buf[RCVBUFSIZ]) {
  297.     flushEncodedData(tif, recvStrip++, buf, recvRow - buf, emsg);
  298.     recvRow = buf;
  299. }
  300.     }
  301. }
  302. free(curGood);
  303. if (seenRTC()) { // RTC found in data stream
  304.     /*
  305.      * Adjust everything to reflect the location
  306.      * at which RTC was found in the data stream.
  307.      */
  308.     copyQualityTrace("Adjusting for RTC found at row %u", getRTCRow());
  309. // # EOL's in recognized RTC
  310.     u_int n = (u_int)(recvEOLCount - getRTCRow());
  311.     if (cblc - n  > recvConsecutiveBadLineCount)
  312. recvConsecutiveBadLineCount = cblc - n;
  313.     if ((recvRow -= n*rowSize) < buf)
  314. recvRow = buf;
  315.     if (n > recvBadLineCount) // deduct RTC
  316. recvBadLineCount = 0;
  317.     else
  318. recvBadLineCount -= n;
  319.     recvEOLCount = getRTCRow(); // adjust row count
  320. } else if (lastRowBad) {
  321.     /*
  322.      * Adjust the received line count to deduce the last
  323.      * consecutive bad line run since the RTC is often not
  324.      * readable and/or is followed by line noise or random
  325.      * junk from the sender.
  326.      */
  327.     copyQualityTrace("Adjusting for trailing noise (%lu run)", cblc);
  328.     if (cblc > recvConsecutiveBadLineCount)
  329. recvConsecutiveBadLineCount = cblc;
  330.     recvEOLCount -= cblc;
  331.     recvBadLineCount -= cblc;
  332.     if ((recvRow -= cblc*rowSize) < buf)
  333. recvRow = buf;
  334. }
  335. recvTrace("%lu total lines, %lu bad lines, %lu consecutive bad lines"
  336.     , recvEOLCount
  337.     , recvBadLineCount
  338.     , recvConsecutiveBadLineCount
  339. );
  340. if (recvRow > &buf[0])
  341.     flushEncodedData(tif, recvStrip, buf, recvRow - buf, emsg);
  342.     } else {
  343. /*
  344.  * Receive a page of data w/o doing copy quality analysis.
  345.  *
  346.  * NB: the image is written as a single strip of data.
  347.  */
  348. setupStartPage(tif, params);
  349. if (params.df == DF_JBIG || params.jp == JP_GREY || params.jp == JP_COLOR) {
  350.     if (params.df != DF_JBIG) {
  351. /*
  352.  * In the case of JPEG we have to buffer it all, alter SOF 
  353.  * after seeing DNL, and then write it to disk... because
  354.  * most JPEG parsers won't know how to handle DNL as it's
  355.  * rather fax-specific.
  356.  */
  357. recvEOLCount = 0;
  358. recvRow = (u_char*) malloc(1024*1000);    // 1M should do it?
  359. fxAssert(recvRow != NULL, "page buffering error (JPEG page).");
  360. recvPageStart = recvRow;
  361.     }
  362.     parserCount[0] = 0;
  363.     parserCount[1] = 0;
  364.     parserCount[2] = 0;
  365.     memset(parserBuf, 0, 16);
  366.     int cc = 0, c;
  367.     bool fin = false;
  368.     if (params.df == DF_JBIG) {
  369. for (; cc < 20; cc++) {
  370.     c = getModemChar(30000);
  371.     if (c == EOF || wasTimeout()) {
  372. fin = true;
  373. break;
  374.     }
  375.     if (c == DLE) {
  376. c = getModemChar(30000);
  377. if (c == EOF || c == ETX || wasTimeout()) {
  378.     fin = true;
  379.     break;
  380. }
  381.     }
  382.     buf[cc] = c;
  383. }
  384. parseJBIGBIH(buf);
  385. flushRawData(tif, 0, (const u_char*) buf, cc, emsg);
  386.     }
  387.     if (!fin) {
  388. do {
  389.     cc = 0;
  390.     do {
  391. c = getModemChar(30000);
  392. if (c == EOF || wasTimeout()) {
  393.     fin = true;
  394.     break;
  395. }
  396. if (c == DLE) {
  397.     c = getModemChar(30000);
  398.     if (c == EOF || c == ETX || wasTimeout()) {
  399. fin = true;
  400. break;
  401.     }
  402. }
  403. if (params.df == DF_JBIG) parseJBIGStream(c);
  404. else parseJPEGStream(c);
  405. buf[cc++] = c;
  406.     } while (cc < RCVBUFSIZ && !fin);
  407.     if (params.df == DF_JBIG) {
  408. flushRawData(tif, 0, (const u_char*) buf, cc, emsg);
  409.     } else {
  410. memcpy(recvRow, (const char*) buf, cc);
  411. recvRow += cc;
  412.     }
  413. } while (!fin);
  414. if (params.df == DF_JBIG) clearSDNORMCount();
  415. else fixupJPEG(tif, emsg);
  416.     }
  417.     if (imagefd > 0) Sys::close(imagefd);
  418.     recvEndPage(tif, params);
  419.     return (true);
  420. }
  421. /*
  422.  * NB: There is a potential memory leak here if the
  423.  * stack buffer gets expanded, such that memory gets
  424.  * malloc'd, and EOF is raised.  In that case the destructor
  425.  * may not be invoked (in fact it almost certainly won't).
  426.  * This is an unlikely scenario so for now we'll leave
  427.  * the code the way it is.
  428.  */
  429. fxStackBuffer raw; // XXX may leak
  430. recvBuf = &raw;
  431. if (!RTCraised()) {
  432.     for (;;) {
  433. raw.reset();
  434. (void) decodeRow(NULL, rowpixels);
  435. if (seenRTC())
  436.     continue;
  437. u_int n = raw.getLength();
  438. if (recvRow + n >= &buf[RCVBUFSIZ]) {
  439.     flushRawData(tif, 0, buf, recvRow - buf, emsg);
  440.     recvRow = buf;
  441. }
  442. if (n >= RCVBUFSIZ)
  443.     flushRawData(tif, 0, (const u_char*) raw, n, emsg);
  444. else {
  445.     memcpy(recvRow, (const char*) raw, n);
  446.     recvRow += n;
  447. }
  448. recvEOLCount++;
  449.     }
  450. }
  451. if (recvRow > &buf[0])
  452.     flushRawData(tif, 0, buf, recvRow - buf, emsg);
  453. if (seenRTC()) { // RTC found in data stream
  454.     /*
  455.      * Adjust the received line count to reflect the
  456.      * location at which RTC was found in the data stream.
  457.      */
  458.     if (params.df == DF_2DMMR) {
  459. copyQualityTrace("Adjusting for EOFB at row %u", getRTCRow());
  460.     } else {
  461. copyQualityTrace("Adjusting for RTC found at row %u", getRTCRow());
  462.     }
  463.     recvEOLCount = getRTCRow();
  464. }
  465.     }
  466.     if (imagefd > 0) Sys::close(imagefd);
  467.     recvEndPage(tif, params);
  468.     return (true);
  469. }
  471. /*
  472.  * Setup "stock TIFF tags" in preparation for receiving a page of data.
  473.  */
  474. void
  475. FaxModem::recvSetupTIFF(TIFF* tif, long, int fillOrder, const fxStr& id)
  476. {
  477.     TIFFSetField(tif, TIFFTAG_SUBFILETYPE, FILETYPE_PAGE);
  478.     TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, (uint32) params.pageWidth());
  479.     if (params.jp == JP_COLOR || params.jp == JP_GREY) {
  480. TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
  481. #ifdef PHOTOMETRIC_ITULAB
  482. /* If PHOTOMETRIC_ITULAB is not available the admin cannot enable color fax anyway.
  483.    This is done so that older libtiffs without it can build fine. */
  484. TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_ITULAB);
  485. #endif
  486. TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
  487. // libtiff requires IMAGELENGTH to be set before SAMPLESPERPIXEL, 
  488. // or StripOffsets and StripByteCounts will have SAMPLESPERPIXEL values
  489. TIFFSetField(tif, TIFFTAG_IMAGELENGTH, 2000); // we adjust this later
  490. TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, params.jp == JP_GREY ? 1 : 3);
  491.     } else {
  492. TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 1);
  493. TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISWHITE);
  494. TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
  495. TIFFSetField(tif, TIFFTAG_FILLORDER, (uint16) fillOrder);
  496.     }
  497.     TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
  498.     TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, (uint32) -1);
  499.     TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
  500.     TIFFSetField(tif, TIFFTAG_XRESOLUTION, (float) params.horizontalRes());
  501.     TIFFSetField(tif, TIFFTAG_YRESOLUTION, (float) params.verticalRes());
  502.     TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);
  503.     TIFFSetField(tif, TIFFTAG_SOFTWARE, HYLAFAX_VERSION);
  504.     TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, (const char*) id);
  505.     char dateTime[24];
  506.     time_t now = Sys::now();
  507.     strftime(dateTime, sizeof (dateTime), "%Y:%m:%d %H:%M:%S", localtime(&now));
  508.     TIFFSetField(tif, TIFFTAG_DATETIME,     dateTime);
  509.     TIFFSetField(tif, TIFFTAG_MAKE,     (const char*) getManufacturer());
  510.     TIFFSetField(tif, TIFFTAG_MODEL,     (const char*) getModel());
  511.     TIFFSetField(tif, TIFFTAG_HOSTCOMPUTER, (const char*) server.hostname);
  512. }
  514. /*
  515.  * Setup the compression scheme and related tags.
  516.  */
  517. static void
  518. setupCompression(TIFF* tif, u_int df, u_int jp, uint32 opts)
  519. {
  520.     u_int dataform = df + (jp ? jp + 4 : 0);
  521.     switch (dataform) {
  522. case JP_GREY+4:
  523. case JP_COLOR+4:
  524.     TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_JPEG);
  525.     break;
  526. case DF_JBIG:
  527.     TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_JBIG);
  528.     break;
  529. case DF_2DMMR:
  530.     TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX4);
  531.     TIFFSetField(tif, TIFFTAG_GROUP4OPTIONS, opts);
  532.     break;
  533. case DF_2DMRUNCOMP:
  534.     TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX3);
  535.     TIFFSetField(tif, TIFFTAG_GROUP3OPTIONS,
  536. opts | GROUP3OPT_2DENCODING|GROUP3OPT_UNCOMPRESSED);
  537.     break;
  538. case DF_2DMR:
  539.     TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX3);
  540.     TIFFSetField(tif, TIFFTAG_GROUP3OPTIONS, opts | GROUP3OPT_2DENCODING);
  541.     break;
  542. case DF_1DMH:
  543.     TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_CCITTFAX3);
  544.     TIFFSetField(tif, TIFFTAG_GROUP3OPTIONS, opts &~ GROUP3OPT_2DENCODING);
  545.     break;
  546.     }
  547. }
  549. /*
  550.  * Write a strip of decoded data to the receive file.
  551.  */
  552. void
  553. FaxModem::flushEncodedData(TIFF* tif, tstrip_t strip, const u_char* buf, u_int cc, fxStr& emsg)
  554. {
  555.     if (imagefd > 0) Sys::write(imagefd, (const char*) buf, cc);
  556.     // NB: must update ImageLength for each new strip
  557.     TIFFSetField(tif, TIFFTAG_IMAGELENGTH, recvEOLCount);
  558.     if (TIFFWriteEncodedStrip(tif, strip, (tdata_t)buf, cc) == -1) {
  559. serverTrace("RECV: %s: write error", TIFFFileName(tif));
  560.         abortPageRecv();
  561.         emsg = "Write error to TIFF file {E052}";
  562.     }
  563. }
  565. /*
  566.  * Write a strip of raw data to the receive file.
  567.  */
  568. void
  569. FaxModem::flushRawData(TIFF* tif, tstrip_t strip, const u_char* buf, u_int cc, fxStr& emsg)
  570. {
  571.     if (imagefd > 0) Sys::write(imagefd, (const char*) buf, cc);
  572.     recvTrace("%u bytes of data, %lu total lines", cc, recvEOLCount);
  573.     if (TIFFWriteRawStrip(tif, strip, (tdata_t)buf, cc) == -1) {
  574. serverTrace("RECV: %s: write error", TIFFFileName(tif));
  575.         abortPageRecv();
  576.         emsg = "Write error to TIFF file {E052}";
  577.     }
  578. }
  580. void
  581. FaxModem::clearSDNORMCount()
  582. {
  583.     if (parserCount[1]) {
  584. copyQualityTrace("Found %d SDNORM Marker Segments in BID", parserCount[1]);
  585. parserCount[1] = 0;
  586.     }
  587. }
  589. void
  590. FaxModem::parseJBIGStream(u_char c)
  591. {
  592.     /*
  593.      * parserCount[n]
  594.      *   n = 0, bytes since last marker
  595.      *   n = 1, SDNORM marker counter
  596.      *   n = 2, framelength bypass countdown
  597.      */
  598.     parserCount[0]++;
  599.     if (parserCount[2]) {
  600. // just skipping bytes
  601. parserCount[2]--;
  602. return;
  603.     }
  604.     for (u_short i = 15; i > 0; i--) parserBuf[i] = parserBuf[i-1];
  605.     parserBuf[0] = c;
  606.     u_long framelength = 0;
  608.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] == 0x04) {
  609. clearSDNORMCount();
  610. copyQualityTrace("Found ABORT Marker Segment in BID");
  611. parserCount[0] = 0;
  612. return;
  613.     }
  614.     if (parserCount[0] >= 8 && parserBuf[7] == 0xFF && parserBuf[6] == 0x06) {
  615. clearSDNORMCount();
  616. copyQualityTrace("Found ATMOVE Marker Segment in BID, Yat %d, tx %d, ty %d", 
  617.     256*256*256*parserBuf[5]+256*256*parserBuf[4]+256*parserBuf[3]+parserBuf[2], parserBuf[1], parserBuf[0]);
  618. parserCount[0] = 0;
  619. return;
  620.     }
  621.     if (parserCount[0] >= 6 && parserBuf[5] == 0xFF && parserBuf[4] == 0x07) {
  622. clearSDNORMCount();
  623. parserCount[2] = 256*256*256*parserBuf[3]+256*256*parserBuf[2]+256*parserBuf[1]+parserBuf[0];
  624. copyQualityTrace("Found COMMENT Marker Segment in BID");
  625. parserCount[0] = 0;
  626. return;
  627.     }
  628.     if (parserCount[0] >= 6 && parserBuf[5] == 0xFF && parserBuf[4] == 0x05) {
  629. clearSDNORMCount();
  630. framelength = 256*256*256*parserBuf[3];
  631. framelength += 256*256*parserBuf[2];
  632. framelength += 256*parserBuf[1];
  633. framelength += parserBuf[0];
  634. copyQualityTrace("Found NEWLEN Marker Segment in BID, Yd = %d", framelength);
  635. // T.82: "The new Yd shall never be greater than the original"
  636. if (framelength < 65535 && (!recvEOLCount || framelength < recvEOLCount)) recvEOLCount = framelength;
  637. parserCount[0] = 0;
  638. return;
  639.     }
  640.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] == 0x01) {
  641. clearSDNORMCount();
  642. copyQualityTrace("Found RESERVE Marker Segment in BID");
  643. parserCount[0] = 0;
  644. return;
  645.     }
  646.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] == 0x02) {
  647. parserCount[1]++; // SDNORM
  648. parserCount[0] = 0;
  649. return;
  650.     }
  651.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] == 0x03) {
  652. clearSDNORMCount();
  653. copyQualityTrace("Found SDRST Marker Segment in BID");
  654. parserCount[0] = 0;
  655. return;
  656.     }
  657. }
  659. void
  660. FaxModem::parseJBIGBIH(u_char* buf)
  661. {
  662.     copyQualityTrace("BIH: Dl %d, D %d, P %d, fill %d", buf[0], buf[1], buf[2], buf[3]);
  663.     /*
  664.      * Parse JBIG BIH to get the image length.
  665.      *
  666.      * See T.82 6.6.2
  667.      * These three integers are coded most significant byte first. In
  668.      * other words, XD is the sum of 256^3 times the fifth byte in BIH, 256^2
  669.      * times the sixth byte, 256 times the seventh byte, and the eighth byte.
  670.      */
  671.     u_long framelength = 0;
  672.     framelength = 256*256*256*buf[8];
  673.     framelength += 256*256*buf[9];
  674.     framelength += 256*buf[10];
  675.     framelength += buf[11];
  676.     /*
  677.      * Senders commonly use 0xFFFF and 0xFFFFFFFF as "maximum Yd".  We ignore such large 
  678.      * values because if we use them and no NEWLEN marker is received, then the page
  679.      * length causes problems for viewers (specifically libtiff).
  680.      */
  681.     if (framelength < 65535 && framelength > recvEOLCount) recvEOLCount = framelength;
  682.     copyQualityTrace("BIH: Xd %d, Yd %d, L0 %d, Mx %d, My %d",
  683. 256*256*256*buf[4]+256*256*buf[5]+256*buf[6]+buf[7],
  684. framelength,
  685. 256*256*256*buf[12]+256*256*buf[13]+256*buf[14]+buf[15],
  686. buf[16], buf[17]);
  687.     copyQualityTrace("BIH: fill %d, HITOLO %d, SEQ %d, ILEAVE %d, SMID %d", 
  688. (buf[18]&0xF0)>>4, (buf[18]&0x8)>>3, (buf[18]&0x4)>>2, (buf[18]&0x2)>>1, buf[18]&0x1);
  689.     copyQualityTrace("BIH: fill %d, LRLTWO %d, VLENGTH %d, TPDON %d, TPBON %d, DPON %d, DPPRIV %u, DPLAST %u", 
  690. (buf[19]&0x80)>>7, (buf[19]&0x40)>>6, (buf[19]&0x20)>>5, (buf[19]&0x10)>>4, (buf[19]&0x8)>>3, 
  691. (buf[19]&0x4)>>2, (buf[19]&0x2)>>1, buf[19]&0x1);
  692. }
  694. void
  695. FaxModem::parseJPEGStream(u_char c)
  696. {
  697.     /*
  698.      * parserCount[n]
  699.      *   n = 0, bytes since last marker
  700.      *   n = 1, framelength bypass countdown
  701.      */
  702.     parserCount[0]++;
  703.     if (parserCount[1]) {
  704. // just skipping bytes
  705. parserCount[1]--;
  706. return;
  707.     }
  708.     for (u_short i = 15; i > 0; i--) parserBuf[i] = parserBuf[i-1];
  709.     parserBuf[0] = c;
  710.     u_long framelength = 0, framewidth = 0, fsize = 0;
  712.     if (parserCount[0] >= 9 && parserBuf[8] == 0xFF && parserBuf[7] >= 0xC0 && parserBuf[7] <= 0xCF 
  713. && parserBuf[7] != 0xC4 && parserBuf[7] != 0xC8 && parserBuf[7] != 0xCC) {
  714. u_short type = parserBuf[7] - 0xC0;
  715. fsize = 256*parserBuf[6];
  716. fsize += parserBuf[5];
  717. framelength = 256*parserBuf[3];
  718. framelength += parserBuf[2];
  719. framewidth = 256*parserBuf[1];
  720. framewidth += parserBuf[0];
  721. copyQualityTrace("Found Start of Frame (SOF%u) Marker, size: %lu x %lu", type, framewidth, framelength);
  722. if (framelength < 65535 && framelength > recvEOLCount) recvEOLCount = framelength;
  723. parserCount[1] = fsize - 9;
  724. parserCount[0] = 0;
  725. return;
  726.     }
  727.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] == 0xC8) {
  728. copyQualityTrace("Found JPEG Extensions (JPG) Marker");
  729. parserCount[0] = 0;
  730. return;
  731.     }
  732.     if (parserCount[0] >= 4 && parserBuf[3] == 0xFF && parserBuf[2] == 0xC4) {
  733. fsize = 256*parserBuf[1];
  734. fsize += parserBuf[0];
  735. copyQualityTrace("Found Define Huffman Tables (DHT) Marker");
  736. parserCount[1] = fsize - 4;
  737. parserCount[0] = 0;
  738. return;
  739.     }
  740.     if (parserCount[0] >= 4 && parserBuf[3] == 0xFF && parserBuf[2] == 0xCC) {
  741. fsize = 256*parserBuf[1];
  742. fsize += parserBuf[0];
  743. copyQualityTrace("Found Define Arithmatic Coding Conditionings (DAC) Marker");
  744. parserCount[1] = fsize - 4;
  745. parserCount[0] = 0;
  746. return;
  747.     }
  748.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] >= 0xD0 && parserBuf[0] <= 0xD7) {
  749. copyQualityTrace("Found Restart (RST) Marker");
  750. parserCount[0] = 0;
  751. return;
  752.     }
  753.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] == 0xD8) {
  754. copyQualityTrace("Found Start of Image (SOI) Marker");
  755. parserCount[0] = 0;
  756. return;
  757.     }
  758.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] == 0xD9) {
  759. copyQualityTrace("Found End of Image (EOI) Marker");
  760. parserCount[0] = 0;
  761. return;
  762.     }
  763.     if (parserCount[0] >= 4 && parserBuf[3] == 0xFF && parserBuf[2] == 0xDA) {
  764. fsize = 256*parserBuf[1];
  765. fsize += parserBuf[0];
  766. copyQualityTrace("Found Start of Scan (SOS) Marker");
  767. parserCount[1] = fsize - 4;
  768. parserCount[0] = 0;
  769. return;
  770.     }
  771.     if (parserCount[0] >= 4 && parserBuf[3] == 0xFF && parserBuf[2] == 0xDB) {
  772. fsize = 256*parserBuf[1];
  773. fsize += parserBuf[0];
  774. copyQualityTrace("Found Define Quantization Tables (DQT) Marker");
  775. parserCount[1] = fsize - 4;
  776. parserCount[0] = 0;
  777. return;
  778.     }
  779.     if (parserCount[0] >= 6 && parserBuf[5] == 0xFF && parserBuf[4] == 0xDC) {
  780. fsize = 256*parserBuf[3];
  781. fsize += parserBuf[2];
  782. framelength = 256*parserBuf[1];
  783. framelength += parserBuf[0];
  784. copyQualityTrace("Found Define Number of Lines (DNL) Marker, lines: %lu", framelength);
  785. if (framelength < 65535) recvEOLCount = framelength;
  786. parserCount[1] = fsize - 6;
  787. parserCount[0] = 0;
  788. return;
  789.     }
  790.     if (parserCount[0] >= 4 && parserBuf[3] == 0xFF && parserBuf[2] == 0xDD) {
  791. fsize = 256*parserBuf[1];
  792. fsize += parserBuf[0];
  793. copyQualityTrace("Found Define Restart Interval (DRI) Marker");
  794. parserCount[1] = fsize - 4;
  795. parserCount[0] = 0;
  796. return;
  797.     }
  798.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] == 0xDE) {
  799. copyQualityTrace("Found Define Hierarchial Progression (DHP) Marker");
  800. parserCount[0] = 0;
  801. return;
  802.     }
  803.     if (parserCount[0] >= 4 && parserBuf[3] == 0xFF && parserBuf[2] == 0xDF) {
  804. fsize = 256*parserBuf[1];
  805. fsize += parserBuf[0];
  806. copyQualityTrace("Found Expand Reference Components (EXP) Marker");
  807. parserCount[1] = fsize - 4;
  808. parserCount[0] = 0;
  809. return;
  810.     }
  811.     if (parserCount[0] >= 4 && parserBuf[3] == 0xFF && parserBuf[2] >= 0xE0 && parserBuf[2] <= 0xEF) {
  812. u_short type = parserBuf[2] - 0xE0;
  813. fsize = 256*parserBuf[1];
  814. fsize += parserBuf[0];
  815. copyQualityTrace("Found Application Segment (APP%u) Marker", type);
  816. parserCount[1] = fsize - 4;
  817. parserCount[0] = 0;
  818. return;
  819.     }
  820.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] >= 0xF0 && parserBuf[0] <= 0xFD) {
  821. u_short type = parserBuf[0] - 0xF0;
  822. copyQualityTrace("Found JPEG Extension (JPG%u) Marker", type);
  823. parserCount[0] = 0;
  824. return;
  825.     }
  826.     if (parserCount[0] >= 4 && parserBuf[3] == 0xFF && parserBuf[2] == 0xFE) {
  827. fsize = 256*parserBuf[1];
  828. fsize += parserBuf[0];
  829. copyQualityTrace("Found Comment (COM) Marker");
  830. parserCount[1] = fsize - 4;
  831. parserCount[0] = 0;
  832. return;
  833.     }
  834.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] == 0x01) {
  835. copyQualityTrace("Found Temporary Private Use (TEM) Marker");
  836. parserCount[0] = 0;
  837. return;
  838.     }
  839.     if (parserCount[0] >= 2 && parserBuf[1] == 0xFF && parserBuf[0] >= 0x02 && parserBuf[0] <= 0xBF) {
  840. copyQualityTrace("Found Reserved (RES) Marker 0x%X", parserBuf[0]);
  841. parserCount[0] = 0;
  842. return;
  843.     }
  844. }
  846. void
  847. FaxModem::fixupJPEG(TIFF* tif, fxStr& emsg)
  848. {
  849.     if (!recvEOLCount) {
  850. /*
  851.  * We didn't detect an image length marker (DNL/NEWLEN).  So
  852.  * we use the session parameters to guess at one, and we hope that
  853.  * the eventual viewing decoder can cope with things if the data
  854.  * is short.
  855.  *
  856.  * This approach doesn't seem to work with JBIG, so for now we only do it with JPEG.
  857.  */
  858. u_int len, res;
  859. switch (params.ln) {
  860.     case LN_A4: len = 297; break;
  861.     default: len = 364; break; // LN_INF, LN_B4
  862. }
  863. switch (params.vr) { // values in mm/100 to avoid floats
  864.     case VR_NORMAL: res = 385; break;
  865.     case VR_FINE: res = 770; break;
  866.     case VR_200X100: res = 394; break;
  867.     case VR_200X200: res = 787; break;
  868.     case VR_200X400: res = 1575; break;
  869.     case VR_300X300: res = 1181; break;
  870.     default: res = 1540; break; // VR_R16, VR_R8
  871. }
  872. recvEOLCount = (u_long) ((len * res) / 100);
  873. protoTrace("RECV: assumed image length of %lu lines", recvEOLCount);
  874.     }
  875.     /*
  876.      * DNL markers generally are not usable in TIFF files.  Furthermore,
  877.      * many TIFF viewers cannot use them, either.  So, we go back 
  878.      * through the strip and replace any "zero" image length attributes
  879.      * of any SOF markers with recvEOLCount.  Perhaps we should strip
  880.      * out the DNL marker entirely, but leaving it in seems harmless.
  881.      */
  882.     u_long pagesize = recvRow - recvPageStart;
  883.     recvRow = recvPageStart;
  884.     for (uint32 i = 0; i < (pagesize - 6); i++) {
  885. if (recvRow[i] == 0xFF && recvRow[i+1] == 0xC0 && recvRow[i+5] == 0x00 && recvRow[i+6] == 0x00) {
  886.     recvRow[i+5] = recvEOLCount >> 8;
  887.     recvRow[i+6] = recvEOLCount & 0xFF;
  888.     protoTrace("RECV: fixing zero image frame length in SOF marker at byte %lu to %lu", i, recvEOLCount);
  889. }
  890.     }
  891.     if (TIFFWriteRawStrip(tif, 0, (tdata_t) recvRow, pagesize) == -1) {
  892. serverTrace("RECV: %s: write error", TIFFFileName(tif));
  893.         abortPageRecv();
  894.         emsg = "Write error to TIFF file {E052}";
  895.     }
  896.     free(recvRow);
  897. }
  899. /*
  900.  * In ECM mode the ECM module provides the line-counter.
  901.  */
  902. void
  903. FaxModem::writeECMData(TIFF* tif, u_char* buf, u_int cc, const Class2Params& params, u_short seq, fxStr& emsg)
  904. {
  905.     /*
  906.      * Start a decoding child process to which the parent pipes the image data 
  907.      * through a decoding pipe.  The child will return the line count back 
  908.      * through a second counting pipe.  The fork is only executed on the first 
  909.      * block, and the child exits after returning the line count after the last
  910.      * block.  In-between blocks merely dump data into the pipe.
  911.      */
  913.     u_int dataform = params.df + (params.jp ? params.jp + 4 : 0);
  915.     char cbuf[4]; // size of the page count signal
  916.     if (seq & 1) { // first block
  917. switch (dataform) {
  918.     case DF_1DMH:
  919.     case DF_2DMR:
  920.     case DF_2DMMR:
  921. {
  922.     decoderFd[1] = -1;
  923.     initializeDecoder(params);
  924.     setupStartPage(tif, params);
  925.     u_int rowpixels = params.pageWidth(); // NB: assume rowpixels <= 4864
  926.     recvBuf = NULL; // just count lines, don't save it
  927.     if (pipe(decoderFd) >= 0 && pipe(counterFd) >= 0) {
  928. setDecoderFd(decoderFd[0]);
  929. decoderPid = fork();
  930. switch (decoderPid) {
  931.     case -1: // error
  932. recvTrace("Could not fork decoding.");
  933. Sys::close(decoderFd[0]);
  934. Sys::close(decoderFd[1]);
  935. Sys::close(counterFd[0]);
  936. Sys::close(counterFd[1]);
  937. break;
  938.     case 0: // child
  939. Sys::close(decoderFd[1]);
  940. Sys::close(counterFd[0]);
  941. setIsECM(true); // point decoder to the pipe rather than the modem for data
  942. if (!EOFraised() && !RTCraised()) {
  943.     for (;;) {
  944. (void) decodeRow(NULL, rowpixels);
  945. if (seenRTC()) {
  946.     break;
  947. }
  948. recvEOLCount++;
  949.     }
  950. }
  951. if (seenRTC()) { // RTC found in data stream
  952.     if (params.df == DF_2DMMR) {
  953. /*
  954.  * In the case of MMR, it's not really RTC, but EOFB.
  955.  * However, we don't actually *find* EOFB, but rather we
  956.  * wait for the first line decoding error and assume it
  957.  * to be EOFB.  This is safe because MMR data after a
  958.  * corrupted line is useless anyway.
  959.  */
  960. copyQualityTrace("Adjusting for EOFB at row %u", getRTCRow());
  961.     } else
  962. copyQualityTrace("Adjusting for RTC found at row %u", getRTCRow());
  963.     recvEOLCount = getRTCRow();
  964. }
  965. // write the line count to the pipe
  966. Sys::write(counterFd[1], (const char*) &recvEOLCount, sizeof(recvEOLCount));
  967. _exit(0);
  968.     default: // parent
  969. Sys::close(decoderFd[0]);
  970. Sys::close(counterFd[1]);
  971. break;
  972. }
  973.     } else {
  974. recvTrace("Could not open decoding pipe.");
  975.     }
  976. }
  977. break;
  979.     case DF_JBIG:
  980. {
  981.     setupStartPage(tif, params);
  982.     parseJBIGBIH(buf);
  983.     parserCount[0] = 0;
  984.     parserCount[1] = 0;
  985.     parserCount[2] = 0;
  986.     memset(parserBuf, 0, 16);
  987. }
  988. break;
  990.     case JP_GREY+4:
  991.     case JP_COLOR+4:
  992. recvEOLCount = 0;
  993. recvRow = (u_char*) malloc(1024*1000);    // 1M should do it?
  994. fxAssert(recvRow != NULL, "page buffering error (JPEG page).");
  995. recvPageStart = recvRow;
  996. setupStartPage(tif, params);
  997. parserCount[0] = 0;
  998. parserCount[1] = 0;
  999. parserCount[2] = 0;
  1000. memset(parserBuf, 0, 16);
  1001. break;
  1002. }
  1003.     }
  1004.     switch (dataform) {
  1005. case DF_1DMH:
  1006. case DF_2DMR:
  1007. case DF_2DMMR:
  1008.     {
  1009. if (decoderFd[1] != -1) { // only if pipe succeeded
  1010.     for (u_int i = 0; i < cc; i++) {
  1011. cbuf[0] = 0x00; // data marker
  1012. cbuf[1] = buf[i];
  1013. Sys::write(decoderFd[1], cbuf, 2);
  1014.     }
  1015. }
  1016. if (decoderFd[1] != -1 && seq & 2) { // last block
  1017.     cbuf[0] = 0xFF; // this signals...
  1018.     cbuf[1] = 0xFF; // ... end of data
  1019.     Sys::write(decoderFd[1], cbuf, 2);
  1021.     // read the page count from the counter pipe
  1022.     Sys::read(counterFd[0], (char*) &recvEOLCount, sizeof(recvEOLCount));
  1023.     (void) Sys::waitpid(decoderPid);
  1024.     Sys::close(decoderFd[1]);
  1025.     Sys::close(counterFd[0]);
  1026. }
  1027.     }
  1028.     break;
  1030. case DF_JBIG:
  1031. case JP_GREY+4:
  1032. case JP_COLOR+4:
  1033.     // search for Marker Segments in Image Data
  1034.     {
  1035. u_int i = 0;
  1036. if ((dataform == DF_JBIG) && (seq & 1)) i += 20; // skip BIH
  1037. for (; i < cc; i++) {
  1038.     if (dataform == DF_JBIG) parseJBIGStream(buf[i]);
  1039.     else parseJPEGStream(buf[i]);
  1040. }
  1041. if (dataform == DF_JBIG) clearSDNORMCount();
  1042.     }
  1043.     break;
  1044.     }
  1045.     if (params.jp != JP_GREY && params.jp != JP_COLOR) {
  1046. flushRawData(tif, 0, (const u_char*) buf, cc, emsg);
  1047.     } else {
  1048. memcpy(recvRow, (const char*) buf, cc);
  1049. recvRow += cc;
  1050.     }
  1051.     if (seq & 2 && (params.jp == JP_GREY || params.jp == JP_COLOR)) {
  1052. fixupJPEG(tif, emsg);
  1053.     }
  1054. }
  1056. /*
  1057.  * Check if the configuration parameters indicate if
  1058.  * copy quality checking should be done on recvd pages.
  1059.  */
  1060. bool
  1061. FaxModem::checkQuality()
  1062. {
  1063.     return (conf.percentGoodLines != 0 && conf.maxConsecutiveBadLines != 0);
  1064. }
  1066. /*
  1067.  * Check the statistics accumulated during a page recived
  1068.  * against the configuration parameters and return an
  1069.  * indication of whether or not the page quality is acceptable.
  1070.  */
  1071. bool
  1072. FaxModem::isQualityOK(const Class2Params& params)
  1073. {
  1074.     if (conf.percentGoodLines != 0 && recvEOLCount != 0) {
  1075. u_long percent = 100 * (recvEOLCount - recvBadLineCount) / recvEOLCount;
  1076. if (percent < conf.percentGoodLines) {
  1077.     serverTrace("RECV: REJECT page quality, %u%% good lines (%u%% required)",
  1078. percent, conf.percentGoodLines);
  1079.     return (false);
  1080. }
  1081.     }
  1082.     u_int cblc = conf.maxConsecutiveBadLines;
  1083.     if (cblc != 0) {
  1084. if (params.vr == VR_FINE)
  1085.     cblc *= 2;
  1086. if (recvConsecutiveBadLineCount > cblc) {
  1087.     serverTrace("RECV: REJECT page quality, %u-line run (max %u)",
  1088. recvConsecutiveBadLineCount, cblc);
  1089.     return (false);
  1090. }
  1091.     }
  1092.     if (recvEOLCount == 0 || recvEOLCount < conf.minAcceptedLineCount) {
  1093. serverTrace("RECV: REJECT page quality, too few scanlines: %u",
  1094.     recvEOLCount);
  1095. return (false);
  1096.     }
  1097.     return (true);
  1098. }
  1100. /*
  1101.  * Return the next decoded byte of page data.
  1102.  */
  1103. int
  1104. FaxModem::nextByte()
  1105. {
  1106.     int b;
  1107.     if (getIsECM()) {
  1108. char buf[2];
  1109. decoderFd[0] = getDecoderFd();
  1110. while (Sys::read(decoderFd[0], buf, 2) < 1);
  1111. if (((unsigned) buf[0] & 0xFF) == 0xFF) raiseEOF();
  1112. b = (unsigned) buf[1] & 0xFF;
  1113.     } else {
  1114. if (bytePending & 0x100) {
  1115.     b = bytePending & 0xff;
  1116.     bytePending = 0;
  1117. } else {
  1118.     b = getModemDataChar();
  1119.     if (b == EOF) {
  1120. raiseEOF();
  1121.     }
  1122. }
  1123. if (b == DLE) {
  1124.     switch (b = getModemDataChar()) {
  1125.     case EOF: raiseEOF();
  1126.     case ETX: raiseRTC();
  1127.     case DLE: break; // <DLE><DLE> -> <DLE>
  1128.     default:
  1129. bytePending = b | 0x100;
  1130. b = DLE;
  1131. break;
  1132.     }
  1133. }
  1134.     }
  1135.     b = getBitmap()[b];
  1136.     if (recvBuf) // record raw data
  1137. recvBuf->put(b);
  1138.     return (b);
  1139. }
  1141. u_long FaxModem::getRecvEOLCount() const
  1142.     { return recvEOLCount; }
  1143. u_long FaxModem::getRecvBadLineCount() const
  1144.     { return recvBadLineCount; }
  1145. u_long FaxModem::getRecvConsecutiveBadLineCount() const
  1146.     { return recvConsecutiveBadLineCount; }
  1148. /*
  1149.  * Trace a protocol-receive related activity.
  1150.  */
  1151. void
  1152. FaxModem::recvTrace(const char* fmt ...)
  1153. {
  1154.     va_list ap;
  1155.     va_start(ap, fmt);
  1156.     static const fxStr recv("RECV: ");
  1157.     server.vtraceStatus(FAXTRACE_PROTOCOL, recv | fmt, ap);
  1158.     va_end(ap);
  1159. }
  1161. /*
  1162.  * Note an invalid G3 code word.
  1163.  */
  1164. void
  1165. FaxModem::invalidCode(const char* type, int x)
  1166. {
  1167.     if (!seenRTC())
  1168. copyQualityTrace("Invalid %s code word, row %u, x %d",
  1169.     type, getReferenceRow(), x);
  1170. }
  1172. /*
  1173.  * Note a row decode that gives the wrong pixel count.
  1174.  */
  1175. void
  1176. FaxModem::badPixelCount(const char* type, int got, int expected)
  1177. {
  1178.     if (!seenRTC()) {
  1179. copyQualityTrace("Bad %s pixel count, row %u, got %d, expected %d",
  1180.     type, getReferenceRow(), got, expected);
  1181. decodedPixels = got;
  1182.     }
  1183. }
  1185. void
  1186. FaxModem::badDecodingState(const char* type, int x)
  1187. {
  1188.     copyQualityTrace("Panic, bad %s decoding state, row %u, x %d",
  1189. type, getReferenceRow(), x);
  1190. }
  1192. /*
  1193.  * Trace a copy quality-reated activity.
  1194.  */
  1195. void
  1196. FaxModem::copyQualityTrace(const char* fmt ...)
  1197. {
  1198.     va_list ap;
  1199.     va_start(ap, fmt);
  1200.     static const fxStr cq("RECV/CQ: ");
  1201.     server.vtraceStatus(FAXTRACE_COPYQUALITY, cq | fmt, ap);
  1202.     va_end(ap);
  1203. }