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

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

传真(Fax)编程

开发平台：

C/C++

FaxModem.c++：源码内容
  1. /* $Id: FaxModem.c++,v 1.20 2007/11/24 00:45:47 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. #include <ctype.h>
  27. #include <stdlib.h>
  29. #include "ClassModem.h"
  30. #include "FaxServer.h"
  31. #include "FaxTrace.h"
  32. #include "FaxFont.h"
  33. #include "t.30.h"
  34. #include "Sys.h"
  36. FaxModem::FaxModem(FaxServer& s, const ModemConfig& c)
  37.     : ClassModem(s,c)
  38.     , server(s)
  39. {
  40.     tagLineFont = NULL;
  41.     minsp = BR_2400;
  42.     curreq = NULL;
  43.     group3opts = 0;
  44.     imagefd = 0;
  45.     // fill order settings may be overwritten in derived class
  46.     recvFillOrder = (conf.recvFillOrder != 0)? conf.recvFillOrder : FILLORDER_LSB2MSB;
  47.     sendFillOrder = (conf.sendFillOrder != 0)? conf.sendFillOrder : FILLORDER_LSB2MSB;
  48.     rtcRev        = TIFFGetBitRevTable(sendFillOrder != FILLORDER_LSB2MSB);
  49.     pageNumberOfCall = 1;
  50. }
  52. FaxModem::~FaxModem()
  53. {
  54.     delete tagLineFont;
  55. }
  57. /*
  58.  * Default methods for modem driver interface.
  59.  */
  61. u_int FaxModem::getTagLineSlop() const { return tagLineSlop; }
  63. u_int FaxModem::getNoCountCoverPages()  { return noCountCoverPages; }
  65. /*
  66.  * Do setup work prior to placing the call.
  67.  */
  68. bool
  69. FaxModem::sendSetup(FaxRequest& req, const Class2Params&, fxStr&)
  70. {
  71.     minsp = fxmax((u_int) req.minbr, fxmax((u_int) conf.minSpeed, modemParams.getMinSpeed()));
  72.     pageNumber = 1;
  73.     pageNumberOfJob = req.npages + req.skippedpages - req.nocountcover + 1;
  74.     noCountCoverPages = req.nocountcover;
  75.     if (conf.useJobTagLine && req.desiredtl != 0)
  76. setupTagLine(req, req.tagline, conf.tagLineLocale);
  77.     else
  78. setupTagLine(req, conf.tagLineFmt, conf.tagLineLocale);
  79.     curreq = &req;
  80.     if (conf.setOriginCmd != "") {
  81. fxStr origincmd = conf.setOriginCmd;
  82. u_int numpos = origincmd.find(0, "%d");
  83. u_int nampos = origincmd.find(0, "%s");
  84. if (numpos == origincmd.length() && nampos == origincmd.length()) {
  85.     // neither %d nor %s appear in the cmd
  86.     if (!atCmd(origincmd)) return (false);
  87. } else if (numpos == origincmd.length()) {
  88.     // just %s appears in the cmd
  89.     if (!atCmd(fxStr::format((const char*) origincmd, (const char*) req.faxname))) return (false);
  90. } else if (nampos == origincmd.length()) {
  91.     // just %d appears in the cmd
  92.     origincmd[numpos+1] = 's'; // change %d to %s
  93.     if (!atCmd(fxStr::format((const char*) origincmd, (const char*) req.faxnumber))) return (false);
  94. } else {
  95.     // both %d and %s appear in the cmd
  96.     origincmd[numpos+1] = 's'; // change %d to %s
  97.     if (numpos < nampos) {
  98. // %d appears before %s
  99. if (!atCmd(fxStr::format((const char*) origincmd, (const char*) req.faxnumber, (const char*) req.faxname))) return (false);
  100.     } else {
  101. // %s appears before %d
  102. if (!atCmd(fxStr::format((const char*) origincmd, (const char*) req.faxname, (const char*) req.faxnumber))) return (false);
  103.     }
  104. }
  105.     }
  106.     return (true);
  107. }
  108. /*
  109.  * Do work at the beginning of a send operation;
  110.  * after a call has been established.
  111.  */
  112. void
  113. FaxModem::sendBegin()
  114. {
  115.     if (conf.sendBeginCmd != "")
  116. atCmd(conf.sendBeginCmd);
  117.     optFrames = 0;
  118. }
  119. void FaxModem::sendSetupPhaseB(const fxStr&, const fxStr&){}
  120. void FaxModem::sendEnd() {}
  122. bool
  123. FaxModem::recvBegin(FaxSetup*, fxStr&)
  124. {
  125.     optFrames = 0;
  126.     return (true);
  127. }
  129. bool
  130. FaxModem::recvEOMBegin(FaxSetup*, fxStr&)
  131. {
  132.     optFrames = 0;
  133.     return (true);
  134. }
  136. bool
  137. FaxModem::pollBegin(const fxStr&, const fxStr&, const fxStr&, fxStr&)
  138. {
  139.     optFrames = 0;
  140.     return (true);
  141. }
  143. /*
  144.  * Issue a command upon successful reception.
  145.  */
  146. void
  147. FaxModem::recvSucceeded()
  148. {
  149.     if (conf.recvSuccessCmd != "")
  150. atCmd(conf.recvSuccessCmd, AT_OK);
  151. }
  153. static void
  154. stripBlanks(fxStr& d, const fxStr& s)
  155. {
  156.     d = s;
  157.     d.remove(0, d.skip(0,' ')); // strip leading white space
  158.     u_int pos = d.skipR(d.length(),' ');
  159.     d.remove(pos, d.length() - pos); // and trailing white space
  160. }
  162. void
  163. FaxModem::recvTSI(const fxStr& s)
  164. {
  165.     stripBlanks(tsi, s);
  166.     protoTrace("REMOTE TSI "%s"", (const char*) tsi);
  167.     optFrames |= 0x1;
  168. }
  169. void
  170. FaxModem::recvCSI(const fxStr& s)
  171. {
  172.     stripBlanks(tsi, s);
  173.     protoTrace("REMOTE CSI "%s"", (const char*) tsi);
  174.     optFrames |= 0x1;
  175. }
  176. bool
  177. FaxModem::getRecvTSI(fxStr& s)
  178. {
  179.     if (optFrames & 0x1) {
  180. s = tsi;
  181. return (true);
  182.     } else
  183. return (false);
  184. }
  185. bool FaxModem::getSendCSI(fxStr& s) { return getRecvTSI(s); }
  187. void
  188. FaxModem::recvPWD(const fxStr& s)
  189. {
  190.     stripBlanks(pwd, s);
  191.     protoTrace("REMOTE PWD "%s"", (const char*) pwd);
  192.     optFrames |= 0x2;
  193. }
  194. bool
  195. FaxModem::getRecvPWD(fxStr& s)
  196. {
  197.     if (optFrames & 0x2) {
  198. s = pwd;
  199. return (true);
  200.     } else
  201. return (false);
  202. }
  203. void
  204. FaxModem::recvSUB(const fxStr& s)
  205. {
  206.     stripBlanks(sub, s);
  207.     protoTrace("REMOTE SUB "%s"", (const char*) sub);
  208.     optFrames |= 0x4;
  209. }
  210. bool
  211. FaxModem::getRecvSUB(fxStr& s)
  212. {
  213.     if (optFrames & 0x4) {
  214. s = sub;
  215. return (true);
  216.     } else
  217. return (false);
  218. }
  220. void
  221. FaxModem::recvNSF( const NSF& aNsf )
  222. {
  223.     nsf = aNsf;
  224.     optFrames |= 0x8;
  225.     protoTrace("REMOTE NSF "%s"", (const char*) nsf.getHexNsf() );
  226.     protoTrace("NSF remote fax equipment: %s %s", 
  227.                (const char*)nsf.getVendor(),
  228.                (const char*)nsf.getModel());
  229.     if( nsf.stationIdFound() )
  230.         protoTrace("NSF %sremote station ID: "%s"",
  231.                    nsf.vendorFound()? "": "possible ",
  232.                    nsf.getStationId());
  233. }
  235. bool
  236. FaxModem::getSendNSF(NSF& aNsf)
  237. {
  238.     if (optFrames & 0x8) {
  239.         aNsf = nsf;
  240.         return (true);
  241.     } else {
  242.         return (false);
  243.     }
  244. }
  246. void
  247. FaxModem::recvDCS(const Class2Params& params)
  248. {
  249.     protoTrace("REMOTE wants %s", params.bitRateName());
  250.     protoTrace("REMOTE wants %s", params.pageWidthName());
  251.     protoTrace("REMOTE wants %s", params.pageLengthName());
  252.     protoTrace("REMOTE wants %s", params.verticalResName());
  253.     protoTrace("REMOTE wants %s", params.dataFormatName());
  254.     if (params.ec != EC_DISABLE)
  255. protoTrace("REMOTE wants %s", params.ecmName());
  256. }
  257. const Class2Params& FaxModem::getRecvParams() const { return params; }
  259. /*
  260.  * Decode the post-page-handling string to get page
  261.  * chopping information for the current page.  The
  262.  * page chop information is optional and always
  263.  * precedes the page-handling information, so at least
  264.  * 2+5+1 characters must be present.  The format of the
  265.  * information is:
  266.  *
  267.  *   xxZcccxM
  268.  *
  269.  * xx is the hex-encoded session parameters (see below),
  270.  * M is a post-page message, and cccc is an optional 4-digit
  271.  * hex encoding of the number of bytes to chop from the
  272.  * encoded page data.  Note also that we only return the
  273.  * chop count if the negotiated session parameters permit
  274.  * us to send a variable-length page.
  275.  */ 
  276. u_int
  277. FaxModem::decodePageChop(const fxStr& pph, const Class2Params& params)
  278. {
  279.     if (params.ln == LN_INF && pph.length() >= 2+5+1 && pph[2] == 'Z') {
  280. char buf[5];
  281. buf[0] = pph[2+1];
  282. buf[1] = pph[2+2];
  283. buf[2] = pph[2+3];
  284. buf[3] = pph[2+4];
  285. buf[4] = '';
  286. return ((u_int) strtoul(buf, NULL, 16));
  287.     } else
  288. return (0);
  289. }
  291. /*
  292.  * Decode the post-page-handling string to get the next
  293.  * post-page message.  The string is assumed to have 3
  294.  * characters per page of the form:
  295.  *
  296.  *   xxM
  297.  *
  298.  * where xx is a 2-digit hex encoding of the session
  299.  * parameters required to send the page data and the M
  300.  * the post-page message to use between this page and
  301.  * the next page.  See FaxServer::sendPrepareFax for the
  302.  * construction of this string.
  303.  */ 
  304. bool
  305. FaxModem::decodePPM(const fxStr& pph, u_int& ppm, fxStr& emsg)
  306. {
  307.     const char* what;
  308.     if (pph.length() >= 3 && (pph[2] != 'Z' || pph.length() >= 2+5+1)) {
  309. switch (pph[pph[2] == 'Z' ? 2+5 : 2+0]) {
  310. case 'P': ppm = PPM_EOP; return (true);
  311. case 'M': ppm = PPM_EOM; return (true);
  312. case 'S': ppm = PPM_MPS; return (true);
  313. }
  314. what = "unknown";
  315.     } else
  316. what = "bad";
  317.     emsg = fxStr::format( "Internal botch; %s post-page handling string "%s" {E303}",
  318. what, (const char*) pph);
  319.     return (false);
  320. }
  322. /*
  323.  * Modem capability (and related) query interfaces.
  324.  */
  326. u_int
  327. FaxModem::getCapabilities() const
  328. {
  329.     return modemParams.encodeCaps();
  330. }
  332. static u_int
  333. bestBit(u_int bits, u_int top, u_int bot)
  334. {
  335.     while (top > bot && (bits & BIT(top)) == 0)
  336. top--;
  337.     return (top);
  338. }
  340. /*
  341.  * Return Class 2 code for best modem signalling rate.
  342.  */
  343. u_int
  344. FaxModem::getBestSignallingRate() const
  345. {
  346.     return bestBit(modemParams.br, BR_33600, BR_2400);
  347. }
  349. /*
  350.  * Compare the requested signalling rate against
  351.  * those the modem can do and return the appropriate
  352.  * Class 2 bit rate code.
  353.  */
  354. int
  355. FaxModem::selectSignallingRate(int br) const
  356. {
  357.     for (; br >= 0 && (modemParams.br & BIT(br)) == 0; br--)
  358. ;
  359.     return (br);
  360. }
  362. /*
  363.  * Compare the requested min scanline time
  364.  * to what the modem can do and return the
  365.  * lowest time the modem can do.
  366.  */
  367. int
  368. FaxModem::selectScanlineTime(int st) const
  369. {
  370.     for (; st < ST_40MS && (modemParams.st & BIT(st)) == 0; st++)
  371. ;
  372.     return (st);
  373. }
  375. /*
  376.  * Return the best min scanline time the modem
  377.  * is capable of supporting.
  378.  */
  379. u_int
  380. FaxModem::getBestScanlineTime() const
  381. {
  382.     u_int st;
  383.     for (st = ST_0MS; st < ST_40MS; st++)
  384. if (modemParams.st & BIT(st))
  385.     break;
  386.     return st;
  387. }
  389. /*
  390.  * Return the best vres the modem supports.
  391.  */
  392. u_int
  393. FaxModem::getVRes() const
  394. {
  395.     /*
  396.      * We don't use bestBit() here because T.32 Table 21
  397.      * states that VR is to be reported as a bitmask
  398.      * of supported resolutions.  So we already have it.
  399.      */
  400.     return (modemParams.vr);
  401. }
  403. /*
  404.  * Return the best page width the modem supports.
  405.  */
  406. u_int
  407. FaxModem::getBestPageWidth() const
  408. {
  409.     // XXX NB: we don't use anything > WD_A3
  410.     return bestBit(modemParams.wd, WD_A3, WD_A4);
  411. }
  413. /*
  414.  * Return the best page length the modem supports.
  415.  */
  416. u_int
  417. FaxModem::getBestPageLength() const
  418. {
  419.     return bestBit(modemParams.ln, LN_INF, LN_A4);
  420. }
  422. /*
  423.  * Return the best data format the modem supports.
  424.  */
  425. u_int
  426. FaxModem::getBestDataFormat() const
  427. {
  428.     return bestBit(modemParams.df, DF_JBIG, DF_1DMH);
  429. }
  431. /*
  432.  * Return the best ECM functionality the modem supports.
  433.  */
  434. u_int
  435. FaxModem::getBestECM() const
  436. {
  437.     return bestBit(modemParams.ec, EC_ECLFULL, EC_DISABLE);
  438. }
  440. /*
  441.  * Return whether or not the modem supports 2DMR.
  442.  */
  443. bool
  444. FaxModem::supports2D() const
  445. {
  446.     return (modemParams.df & BIT(DF_2DMR)) != 0;
  447. }
  449. /*
  450.  * Return whether or not the modem supports 2DMMR.
  451.  */
  452. bool
  453. FaxModem::supportsMMR() const
  454. {
  455.     return (modemParams.df & BIT(DF_2DMMR)) != 0;
  456. }
  458. /*
  459.  * Return whether or not the modem supports JBIG.
  460.  */
  461. bool
  462. FaxModem::supportsJBIG() const
  463. {
  464.     return (modemParams.df & BIT(DF_JBIG)) != 0;
  465. }
  467. /*
  468.  * Return whether or not received EOLs are byte aligned.
  469.  */
  470. bool
  471. FaxModem::supportsEOLPadding() const
  472. {
  473.     return false;
  474. }
  476. /*
  477.  * Return whether or not the modem is capable of polling.
  478.  */
  479. bool
  480. FaxModem::supportsPolling() const
  481. {
  482.     return false;
  483. }
  485. /*
  486.  * Return whether or not the modem supports
  487.  * the optional Error Correction Mode (ECM).
  488.  */
  489. bool
  490. FaxModem::supportsECM(u_int ec) const
  491. {
  492.     if (ec)
  493. return (modemParams.ec & BIT(ec)) != 0;
  494.     else // supports "any ecm"
  495. return (modemParams.ec &~ BIT(EC_DISABLE)) != 0;
  496. }
  498. /*
  499.  * Return whether or not the modem supports the
  500.  * specified vertical resolution.  Note that we're
  501.  * rather tolerant because of potential precision
  502.  * problems and general sloppiness on the part of
  503.  * applications writing TIFF files.
  504.  *
  505.  * Because R8 and R16 vertical resolutions are the same
  506.  * but differ by horizontal resolution, R16 is "coded"
  507.  * as "20" in order to support it.
  508.  */
  509. bool
  510. FaxModem::supportsVRes(float res) const
  511. {
  512.     if (3.0 <= res && res < 4.75)
  513. return ((modemParams.vr & VR_NORMAL) || (modemParams.vr & VR_200X100)) != 0;
  514.     else if (5.9 <= res && res < 9.8)
  515. return ((modemParams.vr & VR_FINE) || (modemParams.vr & VR_200X200)) != 0;
  516.     else if (9.8 <= res && res < 13)
  517. return (modemParams.vr & VR_300X300) != 0;
  518.     else if (13 <= res && res < 19)
  519. return ((modemParams.vr & VR_R8) || (modemParams.vr & VR_200X400)) != 0;
  520.     else if (res == 20)
  521. return (modemParams.vr & VR_R16) != 0;
  522.     else
  523. return false;
  524. }
  526. /*
  527.  * Return whether or not the modem supports the
  528.  * specified page width.
  529.  */
  530. bool
  531. FaxModem::supportsPageWidth(u_int w, u_int r) const
  532. {
  533.     switch (r) {
  534. case VR_R16:
  535.     switch (w) {
  536. case 3456:   return (modemParams.wd & BIT(WD_A4)) != 0;
  537. case 4096:   return (modemParams.wd & BIT(WD_B4)) != 0;
  538. case 4864:   return (modemParams.wd & BIT(WD_A3)) != 0;
  539.     }
  540. case VR_300X300:
  541.     switch (w) {
  542. case 2592:   return (modemParams.wd & BIT(WD_A4)) != 0;
  543. case 3072:   return (modemParams.wd & BIT(WD_B4)) != 0;
  544. case 3648:   return (modemParams.wd & BIT(WD_A3)) != 0;
  545.     }
  546. case VR_NORMAL:
  547. case VR_FINE:
  548. case VR_R8:
  549. case VR_200X100:
  550. case VR_200X200:
  551. case VR_200X400:
  552.     switch (w) {
  553. case 1728:   return (modemParams.wd & BIT(WD_A4)) != 0;
  554. case 2048:   return (modemParams.wd & BIT(WD_B4)) != 0;
  555. case 2432:   return (modemParams.wd & BIT(WD_A3)) != 0;
  556.     }
  557.     }
  558.     return false;
  559. }
  561. /*
  562.  * Return whether or not the modem supports the
  563.  * specified page length.  As above for vertical
  564.  * resolution we're lenient in what we accept.
  565.  */
  566. bool
  567. FaxModem::supportsPageLength(u_int l) const
  568. {
  569.     // XXX probably need to be more forgiving with values
  570.     if (270 < l && l <= 330)
  571. return (modemParams.ln & (BIT(LN_A4)|BIT(LN_INF))) != 0;
  572.     else if (330 < l && l <= 390)
  573. return (modemParams.ln & (BIT(LN_B4)|BIT(LN_INF))) != 0;
  574.     else
  575. return (modemParams.ln & BIT(LN_INF)) != 0;
  576. }
  578. /*
  579.  * Return modems best capabilities for setting up
  580.  * the initial T.30 DIS when receiving data.
  581.  */
  582. FaxParams
  583. FaxModem::modemDIS() const
  584. {
  585.     Class2Params tmp(modemParams);
  586.     tmp.update(true);
  587.     return tmp;
  588. }
  590. /*
  591.  * Tracing support.
  592.  */
  594. /*
  595.  * Trace a modem's capabilities.
  596.  */
  597. void
  598. FaxModem::traceModemParams()
  599. {
  600.     traceBitMask(modemParams.vr, Class2Params::verticalResNames);
  601.     traceBits(modemParams.br, Class2Params::bitRateNames);
  602.     traceBits(modemParams.wd, Class2Params::pageWidthNames);
  603.     traceBits(modemParams.ln, Class2Params::pageLengthNames);
  604.     u_int dataforms = modemParams.df + ((modemParams.jp & (BIT(JP_GREY) | BIT(JP_COLOR))) << 4);
  605.     traceBits(dataforms, Class2Params::dataFormatNames);
  606.     if (supportsECM())
  607. traceBits(modemParams.ec, Class2Params::ecmNames);
  608.     if (modemParams.bf & BIT(BF_ENABLE))
  609. modemSupports("binary file transfer");
  610.     traceBits(modemParams.st, Class2Params::scanlineTimeNames);
  611. }
  613. void
  614. FaxModem::traceFCF(const char* dir, u_int fcf)
  615. {
  616.     const char* fcfname;
  617.     switch (fcf & 0x7F) {
  618. case 0x00:
  619.     fcfname = "NULL (more blocks, same page)";
  620.     break;
  621. case FCF_DIS:
  622.     fcfname = "DIS (identification signal)";
  623.     break;
  624. case FCF_DCS:
  625.     fcfname = "DCS (command signal)";
  626.     break;
  627. case FCF_CSI:
  628.     fcfname = "CSI (called subscriber id)";
  629.     break;
  630. case FCF_TSI:
  631.     fcfname = "TSI (sender id)";
  632.     break;
  633. case FCF_CFR:
  634.     fcfname = "CFR (confirmation to receive)";
  635.     break;
  636. case FCF_FTT:
  637.     fcfname = "FTT (failure to train)";
  638.     break;
  639. case FCF_CRP:
  640.     fcfname = "CRP (command repeat)";
  641.     break;
  642. case FCF_EOM:
  643.     fcfname = "EOM (more documents)";
  644.     break;
  645. case FCF_MPS:
  646.     fcfname = "MPS (more pages, same document)";
  647.     break;
  648. case FCF_EOR:
  649.     fcfname = "EOR (end of retransmission)";
  650.     break;
  651. case FCF_EOP:
  652.     fcfname = "EOP (no more pages or documents)";
  653.     break;
  654. case FCF_RR:
  655.     fcfname = "RR (receive ready)";
  656.     break;
  657. case FCF_CTC:
  658.     fcfname = "CTC (continue to correct)";
  659.     break;
  660. case FCF_PRI_EOM:
  661.     fcfname = "PRI-EOM (more documents after interrupt)";
  662.     break;
  663. case FCF_PRI_MPS:
  664.     fcfname = "PRI-MPS (more pages after interrupt)";
  665.     break;
  666. case FCF_PRI_EOP:
  667.     fcfname = "PRI-EOP (no more pages after interrupt)";
  668.     break;
  669. case FCF_PPS:
  670.     fcfname = "PPS (partial page signal)";
  671.     break;
  672. case FCF_DCN:
  673.     fcfname = "DCN (disconnect)";
  674.     break;
  675. case FCF_CTR:
  676.     fcfname = "CTR (confirm continue to correct)";
  677.     break;
  678. case FCF_NSF:
  679.     fcfname = "NSF (non-standard facilities)";
  680.     break;
  681. case FCF_NSS:
  682.     fcfname = "NSS (non-standard setup)";
  683.     break;
  684. case FCF_MCF:
  685.     fcfname = "MCF (message confirmation)";
  686.     break;
  687. case FCF_RTN:
  688.     fcfname = "RTN (retrain negative)";
  689.     break;
  690. case FCF_RTP:
  691.     fcfname = "RTP (retrain positive)";
  692.     break;
  693. case FCF_PIN:
  694.     fcfname = "PIN (procedural interrupt negative)";
  695.     break;
  696. case FCF_PIP:
  697.     fcfname = "PIP (procedural interrupt positive)";
  698.     break;
  699. case FCF_RNR:
  700.     fcfname = "RNR (receive not ready)";
  701.     break;
  702. case FCF_ERR:
  703.     fcfname = "ERR (confirm end of retransmisison)";
  704.     break;
  705. case FCF_PPR:
  706.     fcfname = "PPR (partial page request)";
  707.     break;
  708. case FCF_SUB:
  709.     fcfname = "SUB (subaddress)";
  710.     break;
  711. case FCF_PWD:
  712.     fcfname = "PWD (password)";
  713.     break;
  714. default:
  715.     protoTrace("unknown FCF 0x%X", fcf);
  716.     return;
  717.     }
  718.     protoTrace("%s %s", dir, (const char*) fcfname);
  719. }
  721. /*
  722.  * Modem i/o support.
  723.  */
  725. /*
  726.  * Miscellaneous server interfaces hooks.
  727.  */
  728. bool FaxModem::isFaxModem() const { return true; }
  730. bool FaxModem::getHDLCTracing()
  731.     { return (server.getSessionTracing() & FAXTRACE_HDLC) != 0; }
  732. bool FaxModem::getECMTracing()
  733.     { return (server.getSessionTracing() & FAXTRACE_ECM) != 0; }
  735. FaxSendStatus
  736. FaxModem::sendSetupParams(TIFF* tif, Class2Params& params,
  737.     FaxMachineInfo& info, fxStr& emsg)
  738. {
  739.     return server.sendSetupParams(tif, params, info, emsg);
  740. }
  743. /*
  744.  * Record the file offset to the start of the data
  745.  * in the file.  We write zero bytes to force the
  746.  * strip offset to be setup in case this is the first
  747.  * time the strip is being written.
  748.  */
  749. void
  750. FaxModem::recvStartPage(TIFF* tif)
  751. {
  752.     u_char null[1];
  753.     (void) TIFFWriteRawStrip(tif, 0, null, 0);
  754.     (void) TIFFGetField(tif, TIFFTAG_STRIPOFFSETS, &savedWriteOff);
  755.     (void) TIFFGetField(tif, TIFFTAG_STRIPBYTECOUNTS, &savedStripByteCounts);
  756.     pageStarted = true;
  757. }
  759. /*
  760.  * Reset the TIFF state for the current page so that
  761.  * subsequent data overwrites anything previously
  762.  * written.  This is done by reseting the file offset
  763.  * and setting the strip's bytecount and offset to
  764.  * values they had at the start of the page.  This
  765.  * scheme assumes that only page data is written to
  766.  * the file between the time recvSetupPage is called
  767.  * and recvResetPage is called.
  768.  */
  769. void
  770. FaxModem::recvResetPage(TIFF* tif)
  771. {
  772.     if (!pageStarted) return;
  773.     TIFFSetWriteOffset(tif, 0); // force library to reset state
  774.     TIFFSetField(tif, TIFFTAG_STRIPOFFSETS, savedWriteOff);
  775.     TIFFSetField(tif, TIFFTAG_STRIPBYTECOUNTS, savedStripByteCounts);
  776. }
  778. void
  779. FaxModem::countPage()
  780. {
  781.     pageNumber++;
  782.     pageNumberOfJob++;
  783.     pageNumberOfCall++;
  784.     if (noCountCoverPages > 0) noCountCoverPages--;
  785. }
  787. int
  788. FaxModem::getPageNumberOfCall()
  789. {
  790.     return pageNumberOfCall;
  791. }
  793. void
  794. FaxModem::notifyPageSent(TIFF* tif)
  795. {
  796.     if (curreq)
  797. server.notifyPageSent(*curreq, TIFFFileName(tif));
  798. }
  800. #include "MemoryDecoder.h"
  802. void
  803. FaxModem::correctPhaseCData(u_char* buf, u_long& pBufSize,
  804.                             u_int fillorder, const Class2Params& params, uint32& rows)
  805. {
  806.     u_char* endOfData;
  807.     MemoryDecoder dec1(buf, params.pageWidth(), pBufSize, fillorder, params.is2D(), false);
  808.     dec1.fixFirstEOL();
  809.     /*
  810.      * We have to construct new decoder. See comments to cutExtraRTC().
  811.      */
  812.     MemoryDecoder dec2(buf, params.pageWidth(), pBufSize, fillorder, params.is2D(), false);
  813.     endOfData = dec2.cutExtraRTC();
  814.     // we don't update rows because we don't decode the entire image
  815.     if( endOfData )
  816.         pBufSize = endOfData - buf;
  817. }
  819. u_char*
  820. FaxModem::convertPhaseCData(u_char* buf, u_long& totdata, u_int fillorder, 
  821.     const Class2Params& params, const Class2Params& newparams, uint32& rows)
  822. {
  823.     MemoryDecoder dec(buf, params.pageWidth(), totdata, fillorder, params.is2D(), (params.df == DF_2DMMR));
  824.     u_char* data = dec.convertDataFormat(newparams);
  825.     totdata = dec.getCC();
  826.     rows = dec.getRows();
  827.     return (data);
  828. }