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

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

传真(Fax)编程

开发平台：

C/C++

Class2Params.c++：源码内容
  1. /* $Id: Class2Params.c++,v 1.12 2008/04/26 22:34:29 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 "config.h"
  27. #include "Class2Params.h"
  28. #include "Sys.h"
  29. #include "t.30.h"
  31. Class2Params::Class2Params()
  32. {
  33.     vr = (u_int) -1;
  34.     br = (u_int) -1;
  35.     wd = (u_int) -1;
  36.     ln = (u_int) -1;
  37.     df = (u_int) -1;
  38.     ec = (u_int) -1;
  39.     bf = (u_int) -1;
  40.     st = (u_int) -1;
  41.     jp = (u_int) -1;
  42. }
  44. int
  45. Class2Params::operator==(const Class2Params& other) const
  46. {
  47.     return vr == other.vr
  48. && br == other.br
  49. && wd == other.wd
  50. && ln == other.ln
  51. && df == other.df
  52. && ec == other.ec
  53. && bf == other.bf
  54. && st == other.st
  55. && jp == other.jp;
  56. }
  58. int
  59. Class2Params::operator!=(const Class2Params& other) const
  60. {
  61.     return !(*this == other);
  62. }
  64. fxStr
  65. Class2Params::cmd(bool class2UseHex, bool ecm20, bool doDFbitmap, bool useJP) const
  66. {
  67.     u_int unset = (u_int) -1;
  68.     fxStr comma(",");
  69.     fxStr notation;
  70.     if (class2UseHex)
  71.         notation = "%X";
  72.     else
  73.         notation = "%u";
  74.     fxStr s;
  75.     if (vr != unset) s.append(fxStr::format(notation, vr));
  76.     s.append(comma);
  77.     if (br != unset) s.append(fxStr::format(notation, br));
  78.     s.append(comma);
  79.     if (wd != unset) s.append(fxStr::format(notation, wd));
  80.     s.append(comma);
  81.     if (ln != unset) s.append(fxStr::format(notation, ln));
  82.     s.append(comma);
  83.     if (doDFbitmap) {
  84. /*
  85.  * We need to produce a T.32 Amendment 1 data format 
  86.  * extension bitmap rather than a point-value.
  87.  */
  88. u_int dfmap = 0;
  89. if (df &  BIT(DF_2DMR)) dfmap |= 0x1;
  90. if (df & BIT(DF_2DMMR)) dfmap |= 0x3;
  91. if (df &  BIT(DF_JBIG)) dfmap |= 0xC; // JBIG L0 (4) + JBIG (8)
  92. if (df != unset) s.append(fxStr::format(notation, dfmap));
  93.     } else
  94. if (df != unset) s.append(fxStr::format(notation, df != 4 ? df : 8)); // we don't do JBIG L0
  95.     s.append(comma);
  96.     if (ec != unset) s.append(fxStr::format(notation, ec - (ecm20 && ec ? 1 : 0)));
  97.     s.append(comma);
  98.     if (bf != unset) s.append(fxStr::format(notation, bf));
  99.     s.append(comma);
  100.     if (st != unset) s.append(fxStr::format(notation, st));
  101.     if (useJP) {
  102. s.append(comma);
  103. if (df != unset) s.append(fxStr::format(notation, jp));
  104.     }
  105.     return s;
  106. }
  108. bool
  109. Class2Params::is2D() const
  110. {
  111.     return (DF_2DMR <= df && df <= DF_2DMMR);
  112. }
  114. /*
  115.  * Tables for mapping a T.30 DIS to Class 2
  116.  * subparameter code values.
  117.  */
  118. u_int Class2Params::DISdfTab[2] = {
  119.     DF_1DMH, // !DIS_2DENCODE
  120.     DF_2DMR // DIS_2DENCODE
  121. };
  122. u_int Class2Params::DISvrTab[2] = {
  123.     VR_NORMAL, // !DIS_7MMVRES
  124.     VR_FINE // DIS_7MMVRES
  125. };
  126. /*
  127.  * Beware that this table returns the ``best speed''
  128.  * based on the signalling capabilities of the DIS.
  129.  */
  130. u_int Class2Params::DISbrTab[16] = {
  131.     BR_2400, // 0x0 V27ter fall-back (BR_4800 could be assumed, T.30 Table 2 Note 3)
  132.     BR_14400, // 0x1 undefined
  133.     BR_9600, // 0x2 undefined
  134.     BR_14400, // 0x3 undefined
  135.     BR_4800, // 0x4 V27ter
  136.     BR_14400, // 0x5 reserved
  137.     BR_4800, // 0x6 reserved
  138.     BR_14400, // 0x7 reserved
  139.     BR_9600, // 0x8 V29
  140.     BR_14400, // 0x9 undefined
  141.     BR_9600, // 0xA undefined
  142.     BR_14400, // 0xB undefined
  143.     BR_9600, // 0xC V27ter+V29
  144.     BR_14400, // 0xD V27ter+V29+V17 (not V.33, post-1994)
  145.     BR_14400, // 0xE V27ter+V29+V33 (invalid, post-1994, T.30 Table 2 Notes 31, 32)
  146.     BR_14400, // 0xF undefined
  147. };
  148. u_int Class2Params::DISwdTab[4] = {
  149.     WD_A4, // DISWIDTH_A4
  150.     WD_A3, // DISWIDTH_A3
  151.     WD_B4 // DISWIDTH_B4
  152. };
  153. u_int Class2Params::DISlnTab[4] = {
  154.     LN_A4, // DISLENGTH_A4
  155.     LN_INF, // DISLENGTH_UNLIMITED
  156.     LN_B4, // DISLENGTH_B4
  157.     LN_A4 // undefined
  158. };
  159. u_int Class2Params::DISstTab[8] = {
  160.     ST_20MS, // DISMINSCAN_20MS
  161.     ST_40MS, // DISMINSCAN_40MS
  162.     ST_10MS, // DISMINSCAN_10MS
  163.     ST_10MS2, // DISMINSCAN_10MS2
  164.     ST_5MS, // DISMINSCAN_5MS
  165.     ST_40MS2, // DISMINSCAN_40MS2
  166.     ST_20MS2, // DISMINSCAN_20MS2
  167.     ST_0MS // DISMINSCAN_0MS
  168. };
  169. u_int Class2Params::DCSbrTab[16] = {
  170.     BR_2400, // 0x0/2400 V27
  171.     BR_14400, // 0x1/14400 V17
  172.     BR_14400, // 0x2/14400 V33
  173.     0, // 0x3/undefined 
  174.     BR_4800, // 0x4/4800 V27
  175.     BR_12000, // 0x5/12000 V17
  176.     BR_12000, // 0x6/12000 V33
  177.     0, // 0x7/undefined 
  178.     BR_9600, // 0x8/9600 V29
  179.     BR_9600, // 0x9/9600 V17
  180.     BR_9600, // 0xA/9600 V33
  181.     0, // 0xB/undefined
  182.     BR_7200, // 0xC/7200 V29
  183.     BR_7200, // 0xD/7200 V17
  184.     BR_7200, // 0xE/7200 V33
  185.     0, // 0xF/undefined 
  186. };
  188. /*
  189.  * Convert a T.30 DIS to a Class 2 parameter block.
  190.  *
  191.  * Note that DIS is a list of *capabilities* and not necessarily maximums.
  192.  * Thus the values here can be set to bitmaps rather than settings.
  193.  */  
  194. void
  195. Class2Params::setFromDIS(FaxParams& dis_caps)
  196. {  
  197.     assign(dis_caps);
  198.     u_int dis = 0;
  199.     u_int xinfo = 0;
  201.     dis |= getByte(0) << 16;
  202.     dis |= getByte(1) << 8;
  203.     dis |= getByte(2) << 0;
  205.     xinfo |= getByte(3) << 24;
  206.     xinfo |= getByte(4) << 16;
  207.     xinfo |= getByte(5) << 8;
  208.     xinfo |= getByte(6) << 0;
  210.     setFromDIS(dis, xinfo);
  212.     if (ec != EC_DISABLE) {
  213. if (dis_caps.isBitEnabled(FaxParams::BITNUM_JBIG_BASIC)) df |= BIT(DF_JBIG);
  214. if (dis_caps.isBitEnabled(FaxParams::BITNUM_JPEG)) jp |= BIT(JP_GREY);
  215. if (dis_caps.isBitEnabled(FaxParams::BITNUM_FULLCOLOR)) {
  216.     if (jp & BIT(JP_GREY)) jp |= BIT(JP_COLOR);
  217. }
  218.     }
  219. }
  221. /*
  222.  * Convert a T.30 DIS to a Class 2 parameter block.
  223.  */
  224. void
  225. Class2Params::setFromDIS(u_int dis, u_int xinfo)
  226. {
  227.     // VR is a bitmap of available settings, not a maximum
  228.     vr = DISvrTab[(dis & DIS_7MMVRES) >> 9];
  229.     if (xinfo & DIS_METRES) {
  230. if (xinfo & DIS_200X400) vr |= VR_R8;
  231. if (xinfo & DIS_400X400) vr |= VR_R16;
  232.     }
  233.     if (xinfo & DIS_INCHRES) {
  234. vr |= VR_200X100;
  235. if (dis & DIS_7MMVRES) vr |= VR_200X200;
  236. if (xinfo & DIS_200X400) vr |= VR_200X400;
  237.     }
  238.     if (xinfo & DIS_300X300) vr |= VR_300X300;
  239.     /*
  240.      * Beware that some modems (e.g. the Supra) indicate they
  241.      * support the V.17 bit rates, but not the normal V.27+V.29
  242.      * signalling rates.  The DISbrTab is NOT setup to mark the
  243.      * V.27 and V.29 if V.17 is set.  Instead we let the upper
  244.      * layers select appropriate signalling rate knowing that
  245.      * we'll fall back to something that the modem will support.
  246.      */
  247.     if ((dis & DIS_V8) && (xinfo & DIS_ECMODE))
  248. br = BR_33600; // Is V.8 only used by V.34 (SuperG3) faxes?
  249.     else
  250. br = DISbrTab[(dis & DIS_SIGRATE) >> 10];
  251.     wd = DISwdTab[(dis & DIS_PAGEWIDTH) >> 6];
  252.     ln = DISlnTab[(dis & DIS_PAGELENGTH) >> 4];
  254.     // DF here is a bitmap
  255.     df = BIT(DF_1DMH); // required support for all G3 facsimile
  256.     if ((xinfo & DIS_G4COMP) && (xinfo & DIS_ECMODE)) // MMR requires ECM
  257. df |= BIT(DF_2DMMR);
  258.     if (xinfo & DIS_2DUNCOMP)
  259. df |= BIT(DF_2DMRUNCOMP);
  260.     if (dis & DIS_2DENCODE)
  261. df |= BIT(DF_2DMR);
  263.     if (xinfo & DIS_ECMODE)
  264. ec = (dis & DIS_FRAMESIZE) ? EC_ENABLE64 : EC_ENABLE256;
  265.     else
  266. ec = EC_DISABLE;
  267.     bf = BF_DISABLE; // XXX from xinfo
  268.     st = DISstTab[(dis & DIS_MINSCAN) >> 1];
  269.     jp = 0;
  270. }
  272. /*
  273.  * Convert a T.30 DCS to a Class 2 parameter block.
  274.  */
  275. void 
  276. Class2Params::setFromDCS(FaxParams& dcs_caps)
  277. {
  278.     assign(dcs_caps);
  279.     u_int dcs = 0;
  280.     u_int xinfo = 0;
  281.   
  282.     dcs |= getByte(0) << 16;
  283.     dcs |= getByte(1) << 8;
  284.     dcs |= getByte(2) << 0;
  286.     xinfo |= getByte(3) << 24;
  287.     xinfo |= getByte(4) << 16;
  288.     xinfo |= getByte(5) << 8;
  289.     xinfo |= getByte(6) << 0;
  291.     setFromDCS(dcs, xinfo);
  293.     if (dcs_caps.isBitEnabled(FaxParams::BITNUM_LETTER_SIZE) || 
  294. dcs_caps.isBitEnabled(FaxParams::BITNUM_LEGAL_SIZE)) {
  295. // we map letter and legal onto WD_A4 + LN_INF for convenience
  296. wd = WD_A4;
  297. ln = LN_INF;
  298.     }
  299.     // Dex 855 sets MMR when also indicating JBIG.  We deliberately let JBIG override.
  300.     if (dcs_caps.isBitEnabled(FaxParams::BITNUM_JBIG_BASIC)) df = DF_JBIG;
  301.     if (dcs_caps.isBitEnabled(FaxParams::BITNUM_JBIG_L0)) df = DF_JBIG;
  302.     if (dcs_caps.isBitEnabled(FaxParams::BITNUM_JPEG)) jp = JP_GREY;
  303.     if (dcs_caps.isBitEnabled(FaxParams::BITNUM_FULLCOLOR)) {
  304. if (jp == JP_GREY) jp = JP_COLOR;
  305.     }
  306.     if (ec == EC_DISABLE && 
  307. (df == DF_2DMMR || df == DF_JBIG || jp == JP_GREY || jp == JP_COLOR)) {
  308. // MMR, JBIG, and JPEG require ECM... we've seen cases where fax
  309. // senders screw up and don't signal ECM but do send ECM-framed 
  310. // image data in the signalled format, and an RTN will break protocol,
  311. // and thus a failure, so we correct the sender's mistake 
  312. // guessing at 256-byte ECM since 64-byte is so rarely used.
  313. ec = EC_ENABLE256;
  314.     }
  315. }
  317. /*
  318.  * Convert a T.30 DCS to a Class 2 parameter block.
  319.  */
  320. void
  321. Class2Params::setFromDCS(u_int dcs, u_int xinfo)
  322. {
  323.     setFromDIS(dcs, xinfo);
  324.     // override DIS setup
  325.     br = DCSbrTab[(dcs & DCS_SIGRATE) >> 10];
  326.     if (xinfo & DCS_INCHRES) {
  327. if (xinfo & DCS_400X400) vr = VR_R16; // rather than adding a VR_400X400
  328. else if (xinfo & DCS_300X300) vr = VR_300X300;
  329. else if (xinfo & DCS_200X400) vr = VR_200X400;
  330. else if (dcs & DCS_7MMVRES) vr = VR_200X200;
  331. else vr = VR_200X100;
  332.     } else { // bit 44 of DCS is 0
  333. // some manufacturers don't send DCS_INCHRES with DCS_300X300
  334. if (xinfo & DCS_300X300) vr = VR_300X300;
  335. else if (xinfo & DCS_400X400) vr = VR_R16;
  336. else if (xinfo & DCS_200X400) vr = VR_R8;
  337. else vr = DISvrTab[(dcs & DCS_7MMVRES) >> 9];
  338.     }
  340.     // DF here is a setting, not a bitmap, max of DF_2DMMR (JPEG, JBIG set later)
  341.     if (df & BIT(DF_2DMMR)) df = DF_2DMMR;
  342.     else if (df & BIT(DF_2DMR)) df = DF_2DMR;
  343.     else df = DF_1DMH;
  345.     if (xinfo & DCS_ECMODE)
  346. ec = (xinfo & DCSFRAME_64) ? EC_ENABLE64 : EC_ENABLE256;
  347.     else
  348. ec = EC_DISABLE;
  349. }
  351. #define CHECKPARAM(a, b, c) (c ? a & BIT(b) : a == b)
  353. /*
  354.  * Set the T.30 DIS/DCS bits that reflects the parameters.
  355.  * isDIS distinguishes between DIS and DCS
  356.  *
  357.  * Class2Params may be capability bitmaps (modemParams) or may be
  358.  * settings (params), we must be capable of handling both.
  359.  */
  360. void
  361. Class2Params::update(bool isDIS)
  362. {
  363.     setupT30(0,0);
  364.     setBit(BITNUM_T4RCVR, true); // Table 2-T.30 Notes 19 & 20
  365.     /*
  366.      * RESOLUTIONS
  367.      *
  368.      * We set both resolution units preferences in order to
  369.      * allow the sender to choose between them.  If it has
  370.      * prepared an inch-based document, that's how we want it.
  371.      * VR is bitmapped natively in all cases.
  372.      */
  373.     if (vr & VR_FINE || vr & VR_200X200) setBit(BITNUM_VR_FINE, true); // R8  x  7.7 l/mm
  374.     if (vr & VR_R8 || vr & VR_200X400)   setBit(BITNUM_VR_R8, true); // R8  x 15.4 l/mm
  375.     if (vr & VR_R16)  setBit(BITNUM_VR_R16, true); // R16 x 15.4 l/mm
  376.     if (vr & VR_300X300)  setBit(BITNUM_VR_300X300, true);// 300 x 300 dpi
  377.     if (!isDIS && (vr & VR_200X200 || vr & VR_200X400 || vr & VR_300X300)) {
  378. setBit(BITNUM_INCH_RES, true); // indicate inch-based resolution usage
  379.     }
  381.     /*
  382.      * SIGNALING RATE
  383.      *
  384.      * Converting br into a meaningful T.30
  385.      * representation is an inexact science because
  386.      *  1) V.17 speeds overlap V.33 and V.29, and
  387.      *  2) br indicates speed, and T.30
  388.      *     indicates modulation also, and
  389.      *  3) V.34 overlaps V.17, V.33, V.29, and V.27.
  390.      *
  391.      * As V.33 is no longer part of T.30 as of 1994,
  392.      * we do not set it here.
  393.      *
  394.      * V.17 support requires both V.29 and V.27 support.
  395.      * V.29 and V.27 support are independent.
  396.      * V.34 requires V.8 support.
  397.      *
  398.      * The imperfect assumptions are that:
  399.      * BR_2400 -- BR_4800  are V.27
  400.      * BR_7200 -- BR_9600  are V.29
  401.      * BR_12000 - BR_14400 are V.17
  402.      * BR_16800 - BR_33600 are V.34
  403.      *
  404.      * The protocol drivers will certainly need to reproduce
  405.      * this independently.
  406.      */
  407.     if (isDIS) { // DIS
  408. if (CHECKPARAM(br, BR_14400, true)) setBit(BITNUM_SIGRATE_14, true);
  409. if (CHECKPARAM(br, BR_9600, true)) setBit(BITNUM_SIGRATE_11, true);
  410. if (CHECKPARAM(br, BR_4800, true)) setBit(BITNUM_SIGRATE_12, true);
  411. if (CHECKPARAM(br, BR_33600, true)) setBit(BITNUM_V8_CAPABLE, true);
  412.     } else { // DCS
  413. // no bits set for V.34 rates and V.27ter 2400
  414. if (CHECKPARAM(br, BR_14400, false)) setBit(BITNUM_SIGRATE_14, true);
  415. if (CHECKPARAM(br, BR_12000, false)) {
  416.     setBit(BITNUM_SIGRATE_14, true);
  417.     setBit(BITNUM_SIGRATE_12, true);
  418. }
  419. if (CHECKPARAM(br, BR_9600, false)) setBit(BITNUM_SIGRATE_11, true);
  420. if (CHECKPARAM(br, BR_7200, false)) {
  421.     setBit(BITNUM_SIGRATE_11, true);
  422.     setBit(BITNUM_SIGRATE_12, true);
  423. }
  424. if (CHECKPARAM(br, BR_4800, false)) setBit(BITNUM_SIGRATE_12, true);
  425.     }
  427.     /*
  428.      * RECORDING WIDTH
  429.      *
  430.      * Post-1994 T.30 revisions have three page width
  431.      * options: A4 (215 mm), B4 (255 mm), and A3 (303 mm).
  432.      * Earlier revisions also included A5 (151 mm) and
  433.      * A6 (107 mm).
  434.      *
  435.      * Trying to support A5 and A6 is likely to only
  436.      * be counterproductive, thus we do not support them.
  437.      *
  438.      * A3 support requires B4 support.
  439.      * A4 support is required.
  440.      */
  441.     if (CHECKPARAM(wd, WD_A3, isDIS)) setBit(BITNUM_WIDTH_18, true);
  442.     else if (CHECKPARAM(wd, WD_B4, isDIS)) setBit(BITNUM_WIDTH_17, true);
  444.     /*
  445.      * RECORDING LENGTH
  446.      *
  447.      * Three possibilities: A4 (297 mm), B4 (364 mm), and unlimited.
  448.      * A4 page length support is required.
  449.      *
  450.      * Using "unlimited" page length is the only way to get the popular
  451.      * "US-Legal" page size.
  452.      */
  453.     if (CHECKPARAM(ln, LN_INF, isDIS)) setBit(BITNUM_LENGTH_20, true);
  454.     else if (CHECKPARAM(ln, LN_B4, isDIS)) setBit(BITNUM_LENGTH_19, true);
  456.     /*
  457.      * DATA FORMAT
  458.      *
  459.      * Options: MH (required), MR, MMR, JBIG, JPEG.
  460.      *
  461.      * ECM support is required for MMR, JBIG, and JPEG.
  462.      *
  463.      * There are other data format options in T.30
  464.      * such as T.81, and T.43.
  465.      */
  466.     if (CHECKPARAM(df, DF_2DMR, isDIS))  setBit(BITNUM_2DMR, true);
  467.     if (CHECKPARAM(df, DF_2DMMR, isDIS) && (CHECKPARAM(ec, EC_ENABLE64, isDIS) || CHECKPARAM(ec, EC_ENABLE256, isDIS)))
  468. setBit(BITNUM_2DMMR, true);
  469.     if (CHECKPARAM(df, DF_JBIG, isDIS) && (CHECKPARAM(ec, EC_ENABLE64, isDIS) || CHECKPARAM(ec, EC_ENABLE256, isDIS)))
  470. setBit(BITNUM_JBIG_BASIC, true);
  471.     if (CHECKPARAM(jp, JP_GREY, isDIS) && (CHECKPARAM(ec, EC_ENABLE64, isDIS) || CHECKPARAM(ec, EC_ENABLE256, isDIS)))
  472. setBit(BITNUM_JPEG, true);
  473.     if (CHECKPARAM(jp, JP_COLOR, isDIS) && (CHECKPARAM(ec, EC_ENABLE64, isDIS) || CHECKPARAM(ec, EC_ENABLE256, isDIS))) {
  474. setBit(BITNUM_JPEG, true);
  475. setBit(BITNUM_FULLCOLOR, true);
  476.     }
  478.     /*
  479.      * MINIMUM SCANLINE TIME
  480.      */
  481.     if (CHECKPARAM(st, ST_5MS, isDIS) || 
  482.         CHECKPARAM(st, ST_20MS2, isDIS) ||
  483.         CHECKPARAM(st, ST_40MS2, isDIS) ||
  484.         CHECKPARAM(st, ST_0MS, isDIS)) {
  485. setBit(BITNUM_ST_21, true);
  486.     }
  487.     if (CHECKPARAM(st, ST_10MS, isDIS) || 
  488.         CHECKPARAM(st, ST_10MS2, isDIS) ||
  489.         CHECKPARAM(st, ST_20MS2, isDIS) ||
  490.         CHECKPARAM(st, ST_0MS, isDIS)) {
  491. setBit(BITNUM_ST_22, true);
  492.     }
  493.     if (CHECKPARAM(st, ST_40MS, isDIS) || 
  494.         CHECKPARAM(st, ST_10MS2, isDIS) ||
  495.         CHECKPARAM(st, ST_40MS2, isDIS) ||
  496.         CHECKPARAM(st, ST_0MS, isDIS)) {
  497. setBit(BITNUM_ST_23, true);
  498.     }
  499.     
  500.     /*
  501.      * ECM
  502.      *
  503.      * 64-byte and 256-byte frame-size options.
  504.      * A receiver must support both or neither.
  505.      *
  506.      * A sender must support no ECM.  Senders
  507.      * should honor the preference of the receiver.
  508.      */
  509.     if (CHECKPARAM(ec, EC_ENABLE64, isDIS)) {
  510. setBit(BITNUM_ECM, true);
  511. if (isDIS) setBit(BITNUM_FRAMESIZE_DIS, true);
  512. else setBit(BITNUM_FRAMESIZE_DCS, true);
  513.     }
  514.     if (CHECKPARAM(ec, EC_ENABLE256, isDIS)) {
  515. setBit(BITNUM_ECM, true);
  516. if (isDIS) setBit(BITNUM_FRAMESIZE_DIS, false);
  517. else setBit(BITNUM_FRAMESIZE_DCS, false);
  518.     }
  519. }
  521. /*
  522.  * Return the number of bytes that can be
  523.  * transferred at the selected signalling
  524.  * rate in <ms> milliseconds.
  525.  */
  526. u_int
  527. Class2Params::transferSize(u_int ms) const
  528. {
  529.     return (bitRate()/8 * ms) / 1000;
  530. }
  532. /*
  533.  * Return the minimum number of bytes in a
  534.  * scanline as determined by the signalling
  535.  * rate, vertical resolution, and min-scanline
  536.  * time parameters.
  537.  */
  538. u_int
  539. Class2Params::minScanlineSize() const
  540. {
  541.     static const u_int stTimes[8] =
  542. { 0, 5, 10, 10, 20, 20, 40, 40 };
  543.     u_int ms = stTimes[st&7];
  544.     if ((st & 1) == 0 && vr > VR_NORMAL)
  545. ms /= 2;
  546.     return transferSize(ms);
  547. }
  549. u_int
  550. Class2Params::pageWidth() const
  551. {
  552.     u_int widths[8] = {
  553. 1728, // 1728 in 215 mm line
  554. 2048, // 2048 in 255 mm line
  555. 2432, // 2432 in 303 mm line
  556. 1216, // 1216 in 151 mm line
  557. 864, // 864 in 107 mm line
  558. 1728, // undefined
  559. 1728, // undefined
  560. 1728, // undefined
  561.     };
  562.     switch (vr) {
  563. case VR_300X300: 
  564.     widths[0] = 2592;
  565.     widths[1] = 3072;
  566.     widths[2] = 3648;
  567.     widths[3] = 1824;
  568.     widths[4] = 1296;
  569.     break;  
  570. case VR_R16:
  571.     widths[0] = 3456;
  572.     widths[1] = 4096;
  573.     widths[2] = 4864;
  574.     widths[3] = 2432;
  575.     widths[4] = 1728;
  576.     break;
  577. case VR_NORMAL:
  578. case VR_FINE:
  579. case VR_R8:
  580. case VR_200X100:
  581. case VR_200X200:
  582. case VR_200X400:
  583.     // nothing
  584.     break;
  585.     }
  586.     return (widths[wd&7]);
  587. }
  589. void
  590. Class2Params::setPageWidthInMM(u_int w)
  591. {
  592.     /*
  593.      * We get the width in MM from the q file.  Basically,
  594.      * faxing only deals with three page widths defined by
  595.      * pixel-widths: 1728, 2048, and 2432 (in R8 resolution).
  596.      * The associated page size names are A4, B4, and A3.  
  597.      * However, the calculated size in millimeters differs
  598.      * between pixel-widths and page size.
  599.      * 1728 pixels = 215 mm : A4 = 209.903 mm
  600.      * 2048 pixels = 255 mm : B4 = 250.119 mm
  601.      * 2432 pixels = 303 mm : A3 = 297.039 mm
  602.      * The client program may therefore use a range of
  603.      * pagewidth (mm) values.  We must interpret wisely.
  604.      */
  605.     wd = (w > 270 ? WD_A3 : w > 230 ? WD_B4 : WD_A4);
  606. }
  608. void
  609. Class2Params::setPageWidthInPixels(u_int w)
  610. {
  611.     /*
  612.      * Here we attempt to determine the WD parameter with
  613.      * a pixel width which is impossible to be perfect
  614.      * because there are colliding values.  However,
  615.      * since we don't use > WD_A3, this is fine.
  616.      */
  617.     wd = (w == 1728 ? WD_A4 :
  618.   w == 2048 ? WD_B4 :
  619.   w == 2432 ? WD_A3 :
  620.   w == 3456 ? WD_A4 :
  621.   w == 4096 ? WD_B4 :
  622.   w == 4864 ? WD_A3 :
  623.   w == 2592 ? WD_A4 :
  624.   w == 3072 ? WD_B4 :
  625.   w == 3648 ? WD_A3 :
  626.       WD_A4);
  627. }
  629. u_int
  630. Class2Params::pageLength() const
  631. {
  632.     static const u_int lengths[4] = {
  633. 297, // A4 paper
  634. 364, // B4 paper
  635. (u_int) -1, // unlimited
  636. 280, // US letter (used internally)
  637.     };
  638.     return (lengths[ln&3]);
  639. }
  641. void
  642. Class2Params::setPageLengthInMM(u_int l)
  643. {
  644.     ln = (l == (u_int) -1 ?  LN_INF :
  645.   l <= 280 ?      LN_LET :
  646.   l <= 300 ?      LN_A4 :
  647.   l <= 380 ?      LN_B4 :
  648.      LN_INF);
  649. }
  651. u_int
  652. Class2Params::horizontalRes() const
  653. {
  654.     /*
  655.      * Technically horizontal resolution depends upon the
  656.      * the number of pixels across the page and the page width.
  657.      * But, these are just used for writing TIFF tags for 
  658.      * received faxes, so we do this to accomodate the session
  659.      * parameters, even though it may be slightly off.
  660.      */
  661.     return (vr == VR_NORMAL ? 204 :
  662.     vr == VR_FINE ? 204 :
  663.     vr == VR_R8 ? 204 :
  664.     vr == VR_R16 ? 408 :
  665.     vr == VR_200X100 ? 200 :
  666.     vr == VR_200X200 ? 200 :
  667.     vr == VR_200X400 ? 200 :
  668.     vr == VR_300X300 ? 300 :
  669.     (u_int) -1);
  670. }
  672. u_int
  673. Class2Params::verticalRes() const
  674. {
  675.     return (vr == VR_NORMAL ? 98 :
  676.     vr == VR_FINE ? 196 :
  677.     vr == VR_R8 ? 391 :
  678.     vr == VR_R16 ? 391 :
  679.     vr == VR_200X100 ? 100 :
  680.     vr == VR_200X200 ? 200 :
  681.     vr == VR_200X400 ? 400 :
  682.     vr == VR_300X300 ? 300 :
  683.     (u_int) -1);
  684. }
  686. void
  687. Class2Params::setRes(u_int xres, u_int yres)
  688. {
  689.     vr = (xres > 300 && yres > 391 ? VR_R16 : 
  690. xres > 204 && yres > 250 ? VR_300X300 :
  691. yres > 391 ? VR_200X400 : 
  692. yres > 250 ? VR_R8 : 
  693. yres > 196 ? VR_200X200 :
  694. yres > 150 ? VR_FINE : 
  695. yres > 98 ? VR_200X100 : VR_NORMAL);
  696. }
  698. fxStr
  699. Class2Params::encodePage() const
  700. {
  701.     int v = (vr&3) | ((wd&7)<<1) | ((ln&3)<<4) | ((df&3)<<6);
  702.     return fxStr(v, "%02x");
  703. }
  705. void
  706. Class2Params::decodePage(const char* s)
  707. {
  708.     u_int v = (u_int) strtoul(s, NULL, 16);
  709.     vr = (v>>0) & 1;
  710.     wd = (v>>1) & 7;
  711.     ln = (v>>4) & 3;
  712.     if (ln == LN_LET) // force protocol value
  713. ln = LN_A4;
  714.     df = (v>>6) & 3;
  715. }
  717. u_int
  718. Class2Params::encode() const
  719. {
  720.     return  (vr > 4 ? ((vr>>4)&7)<<0 : (vr&7)<<0) // push inch resolutions
  721.   | ((br&15)<<3)
  722.   | ((wd&7)<<9)
  723.   | ((ln&3)<<12)
  724.   | ((df&3)<<14)
  725.   | ((ec == EC_DISABLE ? 0 : 1)<<16) // boolean value
  726.   | ((bf&1)<<17)
  727.   | ((st&7)<<18)
  728.   | (1<<21) // this is the version identifier
  729.   ;
  730. }
  732. void
  733. Class2Params::decode(u_int v)
  734. {
  735.     if (v>>21 == 1) { // check version
  736. vr = ((v>>0) & 7); // VR is a bitmap
  737. br = (v>>3) & 15;
  738. wd = (v>>9) & 7;
  739. ln = (v>>12) & 3;
  740. if (ln == LN_LET) // force protocol value
  741.     ln = LN_A4;
  742. df = (v>>14) & 3;
  743. ec = (v>>16) & 1;
  744. bf = (v>>17) & 1;
  745. st = (v>>18) & 7;
  746.     } else { // original version
  747. vr = (v>>0) & 1;
  748. br = (v>>1) & 7;
  749. wd = (v>>4) & 7;
  750. ln = (v>>7) & 3;
  751. if (ln == LN_LET) // force protocol value
  752.     ln = LN_A4;
  753. df = (v>>9) & 3;
  754. ec = (v>>11) & 1;
  755. bf = (v>>12) & 1;
  756. st = (v>>13) & 7;
  757.     }
  758. }
  760. u_int
  761. Class2Params::getMinSpeed() const
  762. {
  763.     u_int minspeed = BR_14400;
  764.     for (int speed = BR_14400; speed >= BR_2400; speed--) {
  765. if (br & BIT(speed)) minspeed = speed;
  766.     }
  767.     return (minspeed);
  768. }
  770. u_int
  771. Class2Params::encodeCaps() const
  772. {
  773.     // we can't use all of BR_ALL because we're limited to 32 bits
  774.     // all ECM support is reduced to "1" (EC_ENABLE64) if any ECM is available
  775.     return (vr&VR_ALL)
  776.  | ((br&(BR_2400|BR_4800|BR_7200|BR_9600|BR_12000|BR_14400))<<8)
  777.  | ((wd&WD_ALL)<<14)
  778.  | ((ln&LN_ALL)<<19)
  779.  | ((df&DF_ALL)<<22)
  780.  | ((ec&EC_DISABLE)<<26)
  781.  | (((ec&EC_ALL) != 0 ? 1 : 0)<<27)
  782.  | ((bf&BF_ALL)<<28)
  783.  | ((st&ST_ALL)<<30)
  784.  ;
  785. }
  787. void
  788. Class2Params::decodeCaps(u_int v)
  789. {
  790.     vr = (v>>0)  & VR_ALL;
  791.     br = (v>>8)  & (BR_2400|BR_4800|BR_7200|BR_9600|BR_12000|BR_14400); // see encoding
  792.     wd = (v>>14) & WD_ALL;
  793.     ln = (v>>19) & LN_ALL;
  794.     df = (v>>22) & DF_ALL;
  795.     ec = (v>>26) & (EC_DISABLE|EC_ENABLE64); // see encoding
  796.     bf = (v>>28) & BF_ALL;
  797.     st = (v>>30) & ST_ALL;
  798. }
  800. /*
  801.  * Routines for printing some Class 2 capabilities.
  802.  */
  803. const char* Class2Params::verticalResNames[65] = {
  804.     "3.85 line/mm",
  805.     "7.7 line/mm",
  806.     "15.4 line/mm", "",
  807.     "R16 x 15.4 line/mm", "", "", "",
  808.     "200 x 100 dpi", "", "", "", "", "", "", "",
  809.     "200 x 200 dpi", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
  810.     "200 x 400 dpi", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
  811.     "300 x 300 dpi"
  812. };
  814. const char* Class2Params::verticalResName() const
  815.     { return (verticalResNames[(vr & VR_ALL) > 64 ? 0 : (vr & VR_ALL)]); }
  817. const char* Class2Params::bestVerticalResName() const
  818. {
  819.     /*
  820.      * "Best" is determined by comparing pixels per square
  821.      * area of image.  Thus 300x300 is "better" than 200x400.
  822.      */
  823.     u_int res = VR_NORMAL; // required default
  824.     if (vr & VR_200X100) res = VR_200X100;
  825.     if (vr & VR_FINE) res = VR_FINE;
  826.     if (vr & VR_200X200) res = VR_200X200;
  827.     if (vr & VR_R8) res = VR_R8;
  828.     if (vr & VR_200X400) res = VR_200X400;
  829.     if (vr & VR_300X300) res = VR_300X300;
  830.     if (vr & VR_R16) res = VR_R16;
  831.     return(verticalResNames[res]);
  832. }
  835. const char* Class2Params::bitRateNames[16] = {
  836.     "2400 bit/s", // BR_2400
  837.     "4800 bit/s", // BR_4800
  838.     "7200 bit/s", // BR_7200
  839.     "9600 bit/s", // BR_9600
  840.     "12000 bit/s", // BR_12000
  841.     "14400 bit/s", // BR_14400
  842.     "16800 bit/s", // BR_16800
  843.     "19200 bit/s", // BR_19200
  844.     "21600 bit/s", // BR_21600
  845.     "24000 bit/s", // BR_24000
  846.     "26400 bit/s", // BR_26400
  847.     "28800 bit/s", // BR_28800
  848.     "31200 bit/s", // BR_31200
  849.     "33600 bit/s", // BR_33600
  850.     "0 bit/s", // 14 ???
  851.     "0 bit/s", // 15 ???
  852. };
  853. const char* Class2Params::bitRateName() const
  854.     { return (bitRateNames[br&15]); }
  855. u_int
  856. Class2Params::bitRate() const
  857. {
  858.     static const u_int brRates[16] = {
  859. 2400, // BR_2400
  860. 4800, // BR_4800
  861. 7200, // BR_7200
  862. 9600, // BR_9600
  863. 12000, // BR_12000
  864. 14400, // BR_14400
  865. 16800, // BR_16800
  866. 19200, // BR_19200
  867. 21600, // BR_21600
  868. 24000, // BR_24000
  869. 26400, // BR_26400
  870. 28800, // BR_28800
  871. 31200, // BR_31200
  872. 33600, // BR_33600
  873. 14400, // 14? XXX
  874. 14400, // 15? XXX
  875.     };
  876.     return (brRates[br & 15]);
  877. }
  879. const char* Class2Params::dataFormatNames[7] = {
  880.     "1-D MH", // DF_1DMH
  881.     "2-D MR", // DF_2DMR
  882.     "2-D Uncompressed Mode", // DF_2DMRUNCOMP
  883.     "2-D MMR", // DF_2DMMR
  884.     "JBIG", // DF_JBIG
  885.     "JPEG Greyscale", // JP_GREY
  886.     "JPEG Full-Color" // JP_COLOR
  887. };
  888. const char* Class2Params::dataFormatName() const
  889. { 
  890.     u_int dfid = df+(jp > 0 && jp < (u_int) -1 ? jp + 4 : 0);
  891.     return (dataFormatNames[dfid > 6 ? 0 : dfid]);
  892. }
  894. fxStr
  895. Class2Params::dataFormatsName()
  896. {
  897.     fxStr formats = "MH";
  898.     if (df & BIT(DF_2DMR)) formats.append(", MR");
  899.     if (df & BIT(DF_2DMMR)) formats.append(", MMR");
  900.     if (df & BIT(DF_JBIG)) formats.append(", JBIG");
  901.     // since color requires greyscale, just say one or the other
  902.     if (jp & BIT(JP_COLOR)) formats.append(", JPEG Full-Color");
  903.     else if (jp & BIT(JP_GREY))  formats.append(", JPEG Greyscale");
  904.     return (formats);
  905. }
  907. const char* Class2Params::pageWidthNames[8] = {
  908.     "A4 page width (215 mm)",
  909.     "B4 page width (255 mm)",
  910.     "A3 page width (303 mm)",
  911.     "page width 151 mm",
  912.     "page width 107 mm",
  913.     "undefined page width (wd=5)",
  914.     "undefined page width (wd=6)",
  915.     "undefined page width (wd=7)",
  916. };
  917. const char* Class2Params::pageWidthName() const
  918.     { return (pageWidthNames[wd&7]); }
  920. const char* Class2Params::pageLengthNames[4] = {
  921.     "A4 page length (297 mm)",
  922.     "B4 page length (364 mm)",
  923.     "unlimited page length",
  924.     "invalid page length (ln=3)",
  925. };
  926. const char* Class2Params::pageLengthName() const
  927.     { return (pageLengthNames[ln&3]); }
  929. const char* Class2Params::scanlineTimeNames[8] = {
  930.     "0 ms/scanline",
  931.     "5 ms/scanline",
  932.     "10 ms, 5 ms/scanline",
  933.     "10 ms/scanline",
  934.     "20 ms, 10 ms/scanline",
  935.     "20 ms/scanline",
  936.     "40 ms, 20 ms/scanline",
  937.     "40 ms/scanline",
  938. };
  939. const char* Class2Params::scanlineTimeName() const
  940.     { return (scanlineTimeNames[st&7]); }
  941. const char* Class2Params::ecmNames[8] = {
  942.     "no ECM",
  943.     "T.30 Annex A, 64-byte ECM",
  944.     "T.30 Annex A, 256-byte ECM",
  945.     "T.30 Annex C, half duplex ECM",
  946.     "T.30 Annex C, full duplex ECM",
  947.     "undefined ECM",
  948.     "undefined ECM",
  949.     "undefined ECM"
  950. };
  951. const char* Class2Params::ecmName() const
  952.     { return (ecmNames[ec&7]); }