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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
FaxFile.cpp
资源名称：faxengine-1.0.3.zip　[点击查看]
上传用户：glass0516
上传日期：2010-01-11
资源大小：104k
文件大小：38k
源码类别：

传真(Fax)编程

开发平台：

Visual C++

FaxFile.cpp：源码内容
  1. /*****************************************************************************
  2. * RelayFax Open Source Project
  3. * Copyright 1996-2004 Alt-N Technologies, Ltd.
  4. * All rights reserved.
  5. *
  6. * Redistribution and use in source and binary forms, with or without
  7. * modification, are permitted only as authorized by the RelayFax Open 
  8. * Source License.  A copy of this license is available in file LICENSE 
  9. * in the top-level directory of the distribution.
  10. *
  11. * RelayFax is a registered trademark of Alt-N Technologies, Ltd.
  12. *
  13. * Individual files and/or contributed packages may be copyright by
  14. * other parties and subject to additional restrictions.
  15. *****************************************************************************/
  17. #include "stdafx.h"
  18. #include "FaxFile.h"
  19. #include "ClassOne.h"
  21. //////////////////////////////////////////////////////////////////////
  22. // Local definitions
  23. //////////////////////////////////////////////////////////////////////
  25. # define WHITE       0
  26. # define BLACK       0xff
  28. # define FAXFILE_OFFTREE    10000
  29. # define FAXFILE_EOL 11000
  30. # define FAXFILE_EOL2 11001
  31. # define FAXFILE_HORZ 11002
  32. # define FAXFILE_V_MINUS3   11003 
  33. # define FAXFILE_V_MINUS2   11004 
  34. # define FAXFILE_V_MINUS1   11005 
  35. # define FAXFILE_V_0 11006 
  36. # define FAXFILE_V_PLUS1 11007 
  37. # define FAXFILE_V_PLUS2 11008 
  38. # define FAXFILE_V_PLUS3    11009 
  39. # define FAXFILE_PASS 11010
  41. typedef int NODE [][2] ;
  43. //////////////////////////////////////////////////////////////////////
  44. // Statics
  45. //////////////////////////////////////////////////////////////////////
  47. BYTE CFaxFile::s_LeadZero[256] = {
  48. 8, 7, 6, 6, 5, 5, 5, 5,
  49. 4, 4, 4, 4, 4, 4, 4, 4,
  50. 3, 3, 3, 3, 3, 3, 3, 3,
  51. 3, 3, 3, 3, 3, 3, 3, 3,
  52. 2, 2, 2, 2, 2, 2, 2, 2,
  53. 2, 2, 2, 2, 2, 2, 2, 2,
  54. 2, 2, 2, 2, 2, 2, 2, 2,
  55. 2, 2, 2, 2, 2, 2, 2, 2,
  56. 1, 1, 1, 1, 1, 1, 1, 1,
  57. 1, 1, 1, 1, 1, 1, 1, 1,
  58. 1, 1, 1, 1, 1, 1, 1, 1,
  59. 1, 1, 1, 1, 1, 1, 1, 1,
  60. 1, 1, 1, 1, 1, 1, 1, 1,
  61. 1, 1, 1, 1, 1, 1, 1, 1,
  62. 1, 1, 1, 1, 1, 1, 1, 1,
  63. 1, 1, 1, 1, 1, 1, 1, 1,
  64. 0, 0, 0, 0, 0, 0, 0, 0,
  65. 0, 0, 0, 0, 0, 0, 0, 0,
  66. 0, 0, 0, 0, 0, 0, 0, 0,
  67. 0, 0, 0, 0, 0, 0, 0, 0,
  68. 0, 0, 0, 0, 0, 0, 0, 0,
  69. 0, 0, 0, 0, 0, 0, 0, 0,
  70. 0, 0, 0, 0, 0, 0, 0, 0,
  71. 0, 0, 0, 0, 0, 0, 0, 0,
  72. 0, 0, 0, 0, 0, 0, 0, 0,
  73. 0, 0, 0, 0, 0, 0, 0, 0,
  74. 0, 0, 0, 0, 0, 0, 0, 0,
  75. 0, 0, 0, 0, 0, 0, 0, 0,
  76. 0, 0, 0, 0, 0, 0, 0, 0,
  77. 0, 0, 0, 0, 0, 0, 0, 0,
  78. 0, 0, 0, 0, 0, 0, 0, 0,
  79. 0, 0, 0, 0, 0, 0, 0, 0,
  80. };
  82. BYTE CFaxFile::s_TrailZero[256] = {
  83. 8,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,
  84. 1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,6,0,1,0,2,0,1,0,3,0,1,0,
  85. 2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,
  86. 1,0,2,0,1,0,3,0,1,0,2,0,1,0,7,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,
  87. 3,0,1,0,2,0,1,0,5,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,
  88. 1,0,6,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0,5,0,1,0,
  89. 2,0,1,0,3,0,1,0,2,0,1,0,4,0,1,0,2,0,1,0,3,0,1,0,2,0,1,0
  90. };
  92. unsigned char CFaxFile::s_FlipTable[] = {
  93.   0, 128,  64, 192,  32, 160,  96, 224,  16, 
  94. 144,  80, 208,  48, 176, 112, 240,   8, 
  95. 136,  72, 200,  40, 168, 104, 232,  24, 
  96. 152,  88, 216,  56, 184, 120, 248,   4, 
  97. 132,  68, 196,  36, 164, 100, 228,  20, 
  98. 148,  84, 212,  52, 180, 116, 244,  12, 
  99. 140,  76, 204,  44, 172, 108, 236,  28, 
  100. 156,  92, 220,  60, 188, 124, 252,   2, 
  101. 130,  66, 194,  34, 162,  98, 226,  18, 
  102. 146,  82, 210,  50, 178, 114, 242,  10, 
  103. 138,  74, 202,  42, 170, 106, 234,  26, 
  104. 154,  90, 218,  58, 186, 122, 250,   6, 
  105. 134,  70, 198,  38, 166, 102, 230,  22, 
  106. 150,  86, 214,  54, 182, 118, 246,  14, 
  107. 142,  78, 206,  46, 174, 110, 238,  30, 
  108. 158,  94, 222,  62, 190, 126, 254,   1, 
  109. 129,  65, 193,  33, 161,  97, 225,  17, 
  110. 145,  81, 209,  49, 177, 113, 241,   9, 
  111. 137,  73, 201,  41, 169, 105, 233,  25, 
  112. 153,  89, 217,  57, 185, 121, 249,   5, 
  113. 133,  69, 197,  37, 165, 101, 229,  21, 
  114. 149,  85, 213,  53, 181, 117, 245,  13, 
  115. 141,  77, 205,  45, 173, 109, 237,  29, 
  116. 157,  93, 221,  61, 189, 125, 253,   3, 
  117. 131,  67, 195,  35, 163,  99, 227,  19, 
  118. 147,  83, 211,  51, 179, 115, 243,  11, 
  119. 139,  75, 203,  43, 171, 107, 235,  27, 
  120. 155,  91, 219,  59, 187, 123, 251,   7, 
  121. 135,  71, 199,  39, 167, 103, 231,  23, 
  122. 151,  87, 215,  55, 183, 119, 247,  15, 
  123. 143,  79, 207,  47, 175, 111, 239,  31, 
  124. 159,  95, 223,  63, 191, 127, 255, 
  125. };
  127. const int CFaxFile::s_WTree [][2] =
  128. {
  129. {1, 80}, {40, 2}, {21, 3}, {4, -2}, {16, 5}, {10, 6}, {7, -256}, {9, 8}, {-1344, -1408},
  130. {-1216, -1280}, {11, 13}, {-576, 12}, {-832, -896}, {14, 15}, {-960, -1024}, {-1088, -1152}, {-1664, 17},
  131. {18, 19}, {-448, -512}, {20, -640}, {-704, -768}, {32, 22}, {23, 28}, {24, 26}, {-24, 25},
  132. {-49, -50}, {27, -25}, {-51, -52}, {29, -192}, {30, 31}, {-55, -56}, {-57, -58}, {-11, 33},
  133. {34, 36}, {-27, 35}, {-59, -60}, {37, -18}, {38, 39}, {-1472, -1536}, {-1600, -1728}, {59, 41},
  134. {49, 42}, {43, -10}, {47, 44}, {46, 45}, {-320, -384}, {-63, 0}, {-28, 48}, {-61, -62}, 
  135. {56, 50}, {53, 51}, {52, -21}, {-43, -44}, {55, 54}, {-41, -42}, {-39, -40}, {-12, 57},
  136. {58, -26}, {-53, -54}, {70, 60}, {64, 61}, {62, -1}, {-19, 63}, {-31, -32}, {68, 65},
  137. {67, 66}, {-37, -38}, {-35, -36}, {-20, 69}, {-33, -34}, {74, 71}, {72, -13}, {-23, 73},
  138. {-47, -48}, {77, 75}, {76, -22}, {-45, -46}, {79, 78}, {-29, -30}, {FAXFILE_EOL, FAXFILE_OFFTREE}, {86, 81},
  139. {83, 82}, {-6, -7}, {-5, 84}, {85, -64}, {-14, -15}, {90, 87}, {88, -4}, {-9, 89},
  140. {-16, -17}, {-3, 91}, {-128, -8}
  141. } ;
  143. const int CFaxFile::s_BTree [][2] =
  144. {
  145. {2, 1}, {-3, -2}, {4, 3}, {-1, -4}, {6, 5}, {-6, -5}, {9, 7}, {8, -7},  {-9, -8}, 
  146. {31, 10}, {30, 11}, {12, -12}, {23, 13}, {17, 14}, {15, 0}, {-21, 16}, {-42, -43},
  147. {21, 18}, {20, 19}, {-38, -39}, {-36, -37}, {-20, 22}, {-34, -35}, {-15, 24}, {27, 25},
  148. {26, -19}, {-28, -29}, {29, 28}, {-26, -27}, {-128, -192}, {-10, -11}, {57, 32}, {45, 33},
  149. {34, -14}, {41, 35}, {38, 36}, {37, -22}, {-40, -41}, {40, 39}, {-32, -33}, {-30, -31},
  150. {-17, 42}, {44, 43}, {-62, -63}, {-48, -49}, {-13, 46}, {51, 47}, {48, -16}, {50, 49},
  151. {-61, -256}, {-57, -58}, {55, 52}, {54, 53}, {-46, -47}, {-44, -45}, {-23, 56}, {-50, -51},
  152. {FAXFILE_EOL, 58}, {75, 59}, {67, 60}, {61, -64}, {65, 62}, {64, 63}, {-1152, -1216}, {-1024, -1088},
  153. {-54, 66}, {-896, -960}, {72, 68}, {71, 69}, {70, -53}, {-512, -576}, {-384, -448}, {-25, 73},
  154. {74, -320}, {-1664, -1728}, {85, 76}, {80, 77}, {78, -24}, {-60, 79}, {-1536, -1600}, {83, 81},
  155. {82, -59}, {-1408, -1472}, {-56, 84}, {-1280, -1344}, {-18, 86}, {89, 87}, {88, -55}, {-768, -832},
  156. {-52, 90}, {-640, -704}
  157. } ;
  160. const int CFaxFile::s_TwoTree [][2] =
  161. {
  162. {1, FAXFILE_V_0}, {2, 3}, {4, FAXFILE_HORZ}, {FAXFILE_V_MINUS1, FAXFILE_V_PLUS1},
  163. {5, FAXFILE_PASS}, {6, 7}, {8, 9}, {FAXFILE_V_MINUS2, FAXFILE_V_PLUS2},
  164. {FAXFILE_EOL, FAXFILE_OFFTREE}, {FAXFILE_V_MINUS3, FAXFILE_V_PLUS3}
  165. } ;
  169. //////////////////////////////////////////////////////////////////////
  170. // Construction/Destruction
  171. //////////////////////////////////////////////////////////////////////
  173. CFaxFile::CFaxFile()
  174. {
  175. m_PageCount = 0;
  176. m_PageBuffer = NULL;
  177. m_tiff = NULL;
  179. m_nSendEncoding = FAXAPI_ENC_CCITT_T6;
  180. m_bGotData = false;
  182. bitspersample = 1;
  183. width = 1728;
  184. length = 0;
  185. fillorder = 1;
  186. g3opts = 0;
  187. compression = COMPRESSION_CCITTFAX3;
  188. xres = 204.0f;
  189. yres = 196.0f;
  191. m_bFileHasData = false;
  192. }
  194. CFaxFile::~CFaxFile()
  195. {
  196. }
  199. //////////////////////////////////////////////////////////////////////
  200. // IsHiRes
  201. //////////////////////////////////////////////////////////////////////
  202. bool CFaxFile::IsHiRes(void) 
  203. { 
  204. short oures=(short)((2*xres)/yres); 
  206. if (oures<3) 
  207. return true; 
  209. return false; 
  210. }
  213. //////////////////////////////////////////////////////////////////////
  214. // ReadFirstHeader
  215. //////////////////////////////////////////////////////////////////////
  216. int CFaxFile::ReadFirstHeader(void)
  217. {
  218. m_bFileHasData = true;
  220. m_tiff = TIFFOpen( m_sFaxFile.c_str(), "r" );
  222. m_PageCount = 0;
  223. m_bPartialPage = false;
  224. m_nBlockCount = 0;
  226. if ( m_tiff == NULL ) 
  227. {
  228. return 1;
  229. }
  231. // read TIFF tags
  232. ReadIfd();
  234. if( width != 1728 )
  235. {
  236. TIFFClose( m_tiff );
  237. m_tiff = NULL;
  238. return 2;
  239. }
  241. return 0;
  242. }
  245. //////////////////////////////////////////////////////////////////////
  246. // ReadIfd
  247. //////////////////////////////////////////////////////////////////////
  248. int CFaxFile::ReadIfd (void)
  249. {
  250. TIFFGetField( m_tiff, TIFFTAG_IMAGEWIDTH, &width );
  251. TIFFGetField( m_tiff, TIFFTAG_IMAGELENGTH, &length);
  252. TIFFGetField( m_tiff, TIFFTAG_BITSPERSAMPLE, &bitspersample);
  253. TIFFGetField( m_tiff, TIFFTAG_FILLORDER, &fillorder);
  254. TIFFGetField( m_tiff, TIFFTAG_XRESOLUTION, &xres );
  255. TIFFGetField( m_tiff, TIFFTAG_YRESOLUTION, &yres );
  256. TIFFGetField( m_tiff, TIFFTAG_ROWSPERSTRIP, &rowsperstrip );
  258. return 0;
  259. }
  262. //////////////////////////////////////////////////////////////////////
  263. // ReadPage
  264. //////////////////////////////////////////////////////////////////////
  265. bool CFaxFile::ReadPage( bool bUseECM, int nClass1Speed, WORD wMinLineChars, bool bClassTwoZero, bool bClassTwo )
  266. {
  267. unsigned int nTotalBytes;
  268. int i;
  269. int nMaxBytes;
  270. int nFlagLength = 0;
  271. unsigned int nOffset;
  272. int nDataBits = 0;
  273. bool bFoundRTC = false;
  275. if( m_bPartialPage ) 
  276. {
  277. m_nBlockCount++;
  278. nOffset = m_nPartialPagePos;
  279. }
  280. else
  281. {
  282. m_nBlockCount = 0;
  283. nOffset = 0;
  284. }
  286. if( m_MemFile.ReadPage( m_tiff, m_nSendEncoding ) != 0 )
  287. {
  288. return false;
  289. }
  291. nBitCntr = 0;
  292. nOctet = 0;
  294. if( m_PageBuffer != NULL )
  295. {
  296. delete[] m_PageBuffer;
  297. }
  299. if( bUseECM )
  300. {
  301. nFlagLength = (int)(((float)(cls1Speeds[nClass1Speed].dwSpeed / 8)) * 0.2f);
  303. nMaxBytes = nFlagLength + // initial flags  
  304.         (3 * 6) + // RCP frames
  305.         (255) * (m_nECMFrameSize + ECM_DATA_HDR + 3) +
  306. 2; // DLE ETX
  308. nMaxBytes = nMaxBytes*2; // zero/DLE insertion fudge factor
  309. }
  310. else
  311. {
  312. nZcnt = 0;
  313. nRTCCnt = 0;
  314. //m_bFoundEndOfPage = false;
  316. if( wMinLineChars > 0 )
  317. {
  318. nMaxBytes = (wMinLineChars * rowsperstrip + m_MemFile.GetDataLen()) *2 + 2;
  319. }
  320. else
  321. {
  322. nMaxBytes = m_MemFile.GetDataLen()*2 + 2;
  323. }
  324. }
  326. m_PageBuffer = new unsigned char[nMaxBytes];
  328. m_PagePtr = (unsigned char*)m_PageBuffer;
  330. // Initial flag sequence
  331. if( bUseECM )
  332. {
  333. for( i = 0; i < nFlagLength; i++ )
  334. {
  335. *m_PagePtr++ = HDLC_FLAG;
  336. }
  338. nZeroBitDeleteCntr = 0;
  340. m_ECMBuffer.InitFrame();
  341. m_ECMBuffer.SetLastSeq(0);
  342. m_ECMBuffer.SetHighestSeq(0);
  343. }
  345. if( m_bPartialPage ) 
  346. {
  347. m_bPartialPage = false;
  348. }
  350. nTotalBytes = m_MemFile.GetDataLen();
  352. unsigned char* pData = m_MemFile.GetData(nOffset);
  354. i = nOffset;
  356. while( i < nTotalBytes )
  357. {
  358. // todo: byte order?
  360. if( bUseECM )
  361. {
  362. unsigned char c = s_FlipTable[ *pData ];
  364. if( m_ECMBuffer.GetSize() == 0 )
  365. {
  366. AddFCDHeader();
  367. }
  369. AddByte( c, true );
  371. if( m_ECMBuffer.GetSize() == m_nECMFrameSize + ECM_DATA_HDR )
  372. {
  373. unsigned short wFCS = m_ECMBuffer.GetFCS();
  375. AddByte( wFCS & 0xff, false );
  376. AddByte( (wFCS >> 8) & 0xff, false );
  378. AddFlag(); // FLAG
  380. m_ECMBuffer.InitFrame();
  382. if( GetFrameCount() == 255 )
  383. {
  384. // Set Partial Page flag and save state
  385. m_bPartialPage = true;
  386. m_nPartialPagePos = i + 1;
  387. }
  388. }
  389. }
  390. else
  391. {
  392. unsigned char c = *pData;
  394. if (nZcnt) 
  395. {
  396. nZcnt += s_LeadZero[c];
  397. if (c && (nZcnt < 11)) 
  398. {
  399. nRTCCnt = 0;
  400. nZcnt = s_TrailZero[c];
  401. }
  402. }
  403. else 
  404. {
  405. nZcnt = s_TrailZero[c];
  406. if (!nZcnt) nRTCCnt = 0;
  407. }
  409. if( nZcnt > 10 && c != 0 )
  410. {
  411. nDataBits += s_LeadZero[c] + 1;
  413. if( nDataBits > 12 )
  414. {
  415. int nInsertBytes = wMinLineChars - (nDataBits/8);
  417. for( int ii = 0; ii < nInsertBytes; ii++ )
  418. {
  419. *m_PagePtr++ = 0;
  420. }
  421. }
  422. else
  423. {
  424. nRTCCnt++;
  425. }
  427. nDataBits = (7 - s_LeadZero[c]);
  429. if (nRTCCnt > 5) 
  430. {
  431. bFoundRTC = true;
  432. //char szMsg[80];
  433. //wsprintf( szMsg, "ReadPage: Found RTC at byte %dn", ftell(m_fp) - nBytesRead + i + 1 );
  434. //OutputDebugString( szMsg );
  435. //IncrementImageLength( -5 );
  436. //m_bFoundEndOfPage = true;
  437. }
  438. else
  439. {
  440. //IncrementImageLength();
  441. }
  442. nZcnt = s_TrailZero[c];
  443. }
  444. else 
  445. {
  446. nDataBits += 8;
  447. }
  449. c = s_FlipTable[c];
  451. // DLE Insertion
  452. if( c == DLE )
  453. {
  454. *m_PagePtr++ = c;
  455. }
  456. *m_PagePtr++ = c;
  457. }
  459. pData++;
  460. i++;
  462. if( m_bPartialPage )
  463. {
  464. i = nTotalBytes;
  465. }
  466. }
  469. if( bUseECM )
  470. {
  471. if( m_ECMBuffer.GetSize() > 0 )
  472. {
  473. unsigned short wFCS = m_ECMBuffer.GetFCS();
  474. AddByte( wFCS & 0xff, false );
  475. AddByte( (wFCS >> 8) & 0xff, false );
  477. AddFlag(); // FLAG
  478. }
  480. // now add RCP frames
  481. AddRCPFrames();
  482. }
  483. else
  484. {
  485. // TODO: class 1 or class 2.0 should include RTC, but not class 2
  487. if( !bFoundRTC && !bClassTwo )
  488. {
  489. // OutputDebugString( "ReadPage adding RTC!n" );
  490. *m_PagePtr++ = s_FlipTable[ 0x00 ];
  491. *m_PagePtr++ = s_FlipTable[ 0x10 ];
  492. *m_PagePtr++ = s_FlipTable[ 0x01 ];
  493. *m_PagePtr++ = s_FlipTable[ 0x00 ];
  494. *m_PagePtr++ = s_FlipTable[ 0x10 ];
  495. *m_PagePtr++ = s_FlipTable[ 0x01 ];
  496. *m_PagePtr++ = s_FlipTable[ 0x00 ];
  497. *m_PagePtr++ = s_FlipTable[ 0x10 ];
  498. *m_PagePtr++ = s_FlipTable[ 0x01 ];
  499. }
  500. }
  502. *m_PagePtr++ = DLE;
  504. if( bClassTwoZero )
  505. {
  506. *m_PagePtr++ = MorePages() ? 0x2c : 0x2e;
  507. }
  508. else
  509. {
  510. *m_PagePtr++ = ETX;
  511. }
  513. m_PageBufferSize = m_PagePtr - m_PageBuffer;
  515. return true;
  516. }
  519. //////////////////////////////////////////////////////////////////////
  520. // ReadBadFrames
  521. //////////////////////////////////////////////////////////////////////
  522. bool CFaxFile::ReadBadFrames( int nClass1Speed )
  523. {
  524. // get the bad frame numbers from SeqMap and construct frames
  525. int i,j,k;
  526. BYTE b;
  527. BYTE bit;
  528. int nSeqNum = 0;
  530. m_PagePtr = (unsigned char*)m_PageBuffer;
  531. nBitCntr = 0;
  532. nOctet = 0;
  535. int nFlagLength = (int)(((float)(cls1Speeds[nClass1Speed].dwSpeed / 8)) * 0.2f);
  537. for( i = 0; i < nFlagLength; i++ )
  538. {
  539. *m_PagePtr++ = HDLC_FLAG;
  540. }
  542. for( i = 0; i < SEQ_MAP_SIZE; i++ )
  543. {
  544. b = m_ECMBuffer.GetSeqMap()[i];
  546. for( j = 0; j < 8; j++, b >>= 1 )
  547. {
  548. bit = (b & 0x01);
  550. if( bit )
  551. {
  552. //char szMsg[80];
  553. //wsprintf( szMsg, "Resending Seq=%dn", nSeqNum );
  554. //OutputDebugString( szMsg );
  556. unsigned int nOffset = (256 * m_nBlockCount + nSeqNum) * m_nECMFrameSize;
  558. memcpy( m_ECMBuffer.GetData(), m_MemFile.GetData( nOffset ), m_nECMFrameSize ); ;
  560. nZeroBitDeleteCntr = 0;
  562. m_ECMBuffer.InitFrame();
  563. m_ECMBuffer.SetLastSeq( nSeqNum );
  565. AddFCDHeader();
  567. for( k = 0; k < m_nECMFrameSize; k++ )
  568. {
  569. AddByte( s_FlipTable[m_ECMBuffer.GetData()[k]], true );
  570. }
  572. unsigned short wFCS = m_ECMBuffer.GetFCS();
  573. AddByte( wFCS & 0xff, false );
  574. AddByte( (wFCS >> 8) & 0xff, false );
  576. AddFlag(); // FLAG
  577. }
  579. nSeqNum++;
  581. // Ignore any sequence numbers which we didn't transmit
  582. if( nSeqNum > m_ECMBuffer.GetHighestSeq() )
  583. {
  584. break;
  585. }
  586. }
  587. if( nSeqNum > m_ECMBuffer.GetHighestSeq() )
  588. {
  589. break;
  590. }
  591. }
  593. AddRCPFrames();
  595. *m_PagePtr++ = DLE;
  596. *m_PagePtr++ = ETX;
  598. m_PageBufferSize = m_PagePtr - m_PageBuffer;
  600. return true;
  601. }
  604. //////////////////////////////////////////////////////////////////////
  605. // AddRCPFrames
  606. //////////////////////////////////////////////////////////////////////
  607. void CFaxFile::AddRCPFrames(void)
  608. {
  609. int i;
  611. for( i = 0; i < 3; i++ )
  612. {
  613. m_ECMBuffer.InitFrame();
  614. AddByte( 0xff, true );
  615. AddByte( 0x03, true );
  616. AddByte( RCP, true );
  618. unsigned short wFCS = m_ECMBuffer.GetFCS();
  619. AddByte( wFCS & 0xff, false );
  620. AddByte( (wFCS >> 8) & 0xff, false );
  622. AddFlag(); // FLAG
  623. }
  625. // output the last byte
  626. while( nBitCntr > 0 )
  627. {
  628. AddBit( 0 );
  629. }
  630. }
  633. //////////////////////////////////////////////////////////////////////
  634. // AddFCDHeader
  635. //////////////////////////////////////////////////////////////////////
  636. void CFaxFile::AddFCDHeader(void)
  637. {
  638. AddByte( 0xff, true );
  639. AddByte( 0x03, true );
  640. AddByte( FCD, true );
  641. AddByte( (unsigned char) m_ECMBuffer.GetLastSeq(), true );
  642. m_ECMBuffer.IncrementLastSeq();
  643. }
  646. //////////////////////////////////////////////////////////////////////
  647. // AddByte
  648. //////////////////////////////////////////////////////////////////////
  649. void CFaxFile::AddByte( unsigned char b, bool bCalcFCS )
  650. {
  651. int i;
  652. BYTE bit;
  654. if( bCalcFCS )
  655. {
  656. m_ECMBuffer.CalcFCS( b );
  657. }
  659. for( i = 0; i < 8; i++, b >>= 1 )
  660. {
  661. bit = (b & 0x01);
  663. AddBit( bit );
  665. nZeroBitDeleteCntr = (bit == 1) ? (nZeroBitDeleteCntr + 1) : 0;
  667. if( nZeroBitDeleteCntr == 5 )
  668. {
  669. nZeroBitDeleteCntr = 0;
  671. AddBit( 0 );
  672. }
  673. }
  674. }
  677. //////////////////////////////////////////////////////////////////////
  678. // AddFlag
  679. //////////////////////////////////////////////////////////////////////
  680. void CFaxFile::AddFlag( void )
  681. {
  682. BYTE b = HDLC_FLAG;
  683. BYTE bit;
  684. int i;
  686. nZeroBitDeleteCntr = 0;
  688. for( i = 0; i < 8; i++, b >>= 1 )
  689. {
  690. bit = (b & 0x01);
  691. AddBit( bit );
  692. }
  693. }
  696. //////////////////////////////////////////////////////////////////////
  697. // AddBit
  698. //////////////////////////////////////////////////////////////////////
  699. void CFaxFile::AddBit( unsigned char bit )
  700. {
  701. nOctet = (nOctet << 1) + bit;
  702. nBitCntr++;
  704. if( nBitCntr >= 8 )
  705. {
  706. nOctet = s_FlipTable[nOctet];
  708. *m_PagePtr++ = nOctet;
  710. if( nOctet == DLE )
  711. {
  712. *m_PagePtr++ = nOctet;
  713. }
  714. nOctet = 0;
  715. nBitCntr = 0;
  716. }
  717. }
  719. //////////////////////////////////////////////////////////////////////
  720. // ReadNextHeader
  721. //////////////////////////////////////////////////////////////////////
  722. bool CFaxFile::ReadNextHeader(void)
  723. {
  724. m_PageCount++;
  725. m_nBlockCount = 0;
  727. if( TIFFReadDirectory( m_tiff ) == 0 )
  728. return false;
  730. ReadIfd();
  732. return true;
  733. }
  736. //////////////////////////////////////////////////////////////////////
  737. // Close
  738. //////////////////////////////////////////////////////////////////////
  739. void CFaxFile::Close(void)
  740. {
  741. if( m_bGotData )
  742. {
  743. WriteIFD();
  744. }
  746. m_PageCount = 0;
  748. if( m_PageBuffer != NULL )
  749. {
  750. delete[] m_PageBuffer;
  751. m_PageBuffer = NULL;
  752. }
  754. if( m_tiff )
  755. {
  756. TIFFClose( m_tiff );
  757. m_tiff = NULL;
  758. }
  760. if( m_bFileHasData == false )
  761. {
  762. remove( m_sFaxFile.c_str() );
  763. }
  764. }
  767. //////////////////////////////////////////////////////////////////////
  768. // SetImageRes
  769. //////////////////////////////////////////////////////////////////////
  770. void CFaxFile::SetImageRes( bool bHiRes )
  771. {
  772. yres = (bHiRes) ? 196.0f : 98.0f;
  773. }
  775. //////////////////////////////////////////////////////////////////////
  776. // SetImageWidth
  777. //////////////////////////////////////////////////////////////////////
  778. void CFaxFile::SetImageWidth( int nWidth )
  779. {
  780. width = nWidth;
  781. }
  783. //////////////////////////////////////////////////////////////////////
  784. // SetImageLength
  785. //////////////////////////////////////////////////////////////////////
  786. void CFaxFile::SetImageLength( int nLength )
  787. {
  788. length = nLength;
  789. }
  792. //////////////////////////////////////////////////////////////////////
  793. // IncrementImageLength
  794. //////////////////////////////////////////////////////////////////////
  795. void CFaxFile::IncrementImageLength( int n )
  796. {
  797. length += n;
  798. }
  801. //////////////////////////////////////////////////////////////////////
  802. // SetImageCompression
  803. //////////////////////////////////////////////////////////////////////
  804. void CFaxFile::SetImageCompression( int nCompression )
  805. {
  806. compression = nCompression;
  808. }
  810. //////////////////////////////////////////////////////////////////////
  811. // SetT4Options
  812. //////////////////////////////////////////////////////////////////////
  813. void CFaxFile::SetT4Options( int nOptions )
  814. {
  815. g3opts = nOptions;
  816. }
  820. //////////////////////////////////////////////////////////////////////
  821. // WriteFileHeader
  822. //////////////////////////////////////////////////////////////////////
  823. bool CFaxFile::WriteFileHeader(void)
  824. {
  825. if( m_tiff == NULL )
  826. {
  827. m_tiff = TIFFOpen( m_sFaxFile.c_str(), "w" );
  829. if( m_tiff == NULL )
  830. {
  831. return false;
  832. }
  833. }
  835. m_bFileHasData = false;
  836. m_bGotData = false;
  837. m_bFoundStartOfPage = false;
  838. m_bFoundEndOfPage = false;
  839. m_bFoundStartOfFrame = false;
  840. nZcnt = 0;
  841. nRTCCnt = 0;
  842. nBitCntr = 0;
  843. nZeroBitDeleteCntr = 0;
  844. m_PageCount = 0;
  846. return true;
  847. }
  850. //////////////////////////////////////////////////////////////////////
  851. // WriteBuffer
  852. //////////////////////////////////////////////////////////////////////
  853. bool CFaxFile::WriteBuffer( unsigned char* szBuffer, unsigned int nBytes, bool bFlipBytes )
  854. {
  855. int nNewBytes =0 ;
  856. int i;
  857. BYTE lastByte;
  859. if( nBytes > 0 ) 
  860. {
  861. m_bGotData = true;
  862. }
  864. for (i = 0; i < nBytes; i++ )
  865. {
  866. BYTE b = (bFlipBytes) ? s_FlipTable[szBuffer[i]] : szBuffer[i];
  868. if( compression == 4 )
  869. {
  870. m_MemFile.AddDataByte( b );
  871. }
  872. else
  873. {
  874. if( !m_bFoundEndOfPage )
  875. {
  876. if (nZcnt) 
  877. {
  878. nZcnt += s_LeadZero[b];
  879. if (b && (nZcnt < 11)) 
  880. {
  881. nRTCCnt = 0;
  882. nZcnt = s_TrailZero[b];
  883. }
  884. }
  885. else 
  886. {
  887. nZcnt = s_TrailZero[b];
  888. if (!nZcnt) nRTCCnt = 0;
  889. }
  891. if( (nNewBytes > 0) && (lastByte == 0) && (nZcnt > 18) )
  892. {
  893. nNewBytes--; // skip last byte
  894. nZcnt -= 8;
  895. }
  897. if( (nZcnt > 10) && (b != 0) )
  898. {
  899. if( !m_bFoundStartOfPage )
  900. {
  901. m_bFoundStartOfPage = true;
  902. m_MemFile.AddDataByte( 0 );
  903. m_MemFile.AddDataByte( 0 );
  904. IncrementImageLength();
  905. }
  906. else
  907. {
  908. nRTCCnt++;
  909. if (nRTCCnt > 5) 
  910. {
  911. //OutputDebugString( "Found RTC!n" );
  912. IncrementImageLength( -5 );
  913. m_bFoundEndOfPage = true;
  914. m_MemFile.AddDataByte( b );  // stuff in the last byte
  915. }
  916. else
  917. {
  918. IncrementImageLength();
  919. }
  920. }
  921. nZcnt = s_TrailZero[b];
  922. }
  923. }
  925. if( m_bFoundStartOfPage && !m_bFoundEndOfPage )
  926. {
  927. m_MemFile.AddDataByte( b );
  928. lastByte = b;
  929. }
  930. }
  931. }
  933. // char szMsg[100];
  934. // wsprintf( szMsg, "Writing Fax Data, nBytes=%d, nNewBytes=%dn", nBytes, nNewBytes );
  935. // OutputDebugString( szMsg );
  937. return true;
  938. }
  941. //////////////////////////////////////////////////////////////////////
  942. // WriteECMBuffer
  943. //////////////////////////////////////////////////////////////////////
  944. bool CFaxFile::WriteECMBuffer( unsigned char* szBuffer, unsigned int nBytes )
  945. {
  946. int i,j;
  947. BYTE bit;
  949. //char szMsg[180];
  950. //wsprintf( szMsg, "Writing ECM Fax Data, nBytes=%dn", nBytes );
  951. //OutputDebugString( szMsg );
  953. if( nBytes > 0 ) 
  954. {
  955. m_bGotData = true;
  956. }
  958. for (i = 0; i < nBytes; i++ )
  959. {
  960. //BYTE b = fliptable[szBuffer[i]];
  961. BYTE b = szBuffer[i];
  963. //char szMsg1[80];
  964. //wsprintf( szMsg1, "%04d: {%02X}n", i, b );
  965. //OutputDebugString( szMsg1 );
  967. for( j = 0; j < 8; j++, b >>= 1 )
  968. {
  969. bit = (b & 0x01);
  971. // look for flags
  972. if( !m_bFoundStartOfPage )
  973. {
  974. if( (nBitCntr == 0) || (nBitCntr == 7) )
  975. {
  976. nBitCntr = (bit == 0) ? (nBitCntr + 1) : 0;
  977. }
  978. else
  979. {
  980. nBitCntr = (bit == 1) ? (nBitCntr + 1) : 0;
  981. }
  983. if (nBitCntr == 8 )
  984. {
  985. //wsprintf( szMsg, "Found a flag %dn", i );
  986. //OutputDebugString( szMsg );
  987. nBitCntr = 0;
  988. nOctet = 0;
  989. nZeroBitDeleteCntr = 0;
  990. m_ECMBuffer.InitFrame();
  991. m_bFoundStartOfPage = true;
  992. }
  993. }
  994. else if( !m_bFoundStartOfFrame )
  995. {
  996. if( nZeroBitDeleteCntr == 5 )
  997. {
  998. nZeroBitDeleteCntr = 0;
  1000. if( bit == 1 )
  1001. {
  1002. // must be another flag
  1003. nOctet = (nOctet << 1) + bit;
  1004. nBitCntr++;
  1005. }
  1006. }
  1007. else
  1008. {
  1009. nOctet = (nOctet << 1) + bit;
  1010. nBitCntr++;
  1011. nZeroBitDeleteCntr = (bit == 1) ? (nZeroBitDeleteCntr + 1) : 0;
  1013. if( nBitCntr == 8 )
  1014. {
  1015. if( nOctet == 255 )
  1016. {
  1017. m_bFoundStartOfFrame = true;
  1018. //wsprintf( szMsg, "Found start of frame %dn", i );
  1019. //OutputDebugString( szMsg );
  1020. m_bFlagFound = false;
  1021. m_ECMBuffer.AddByte( nOctet );
  1022. }
  1023. else
  1024. {
  1025. if( nOctet != HDLC_FLAG )
  1026. {
  1027. //wsprintf( szMsg, "Unexpected octet [%02X], re-syncing %dn", nOctet, i );
  1028. //OutputDebugString( szMsg );
  1029. m_bFoundStartOfPage = false;
  1030. }
  1032. nZeroBitDeleteCntr = 0;
  1033. }
  1035. nBitCntr = 0;
  1036. nOctet = 0;
  1037. }
  1038. else if( nBitCntr > 8 )
  1039. {
  1040. //OutputDebugString( "Whoops!n" );
  1041. m_bFoundStartOfPage = false;
  1042. }
  1043. }
  1044. }
  1045. else // found start of frame
  1046. {
  1047. if( nZeroBitDeleteCntr == 5 )
  1048. {
  1049. nZeroBitDeleteCntr = 0;
  1051. if( bit == 1 )
  1052. {
  1053. // must be another flag
  1054. nOctet = (nOctet << 1) + bit;
  1055. nBitCntr++;
  1056. //wsprintf( szMsg, "Found potential flag %dn", i );
  1057. //OutputDebugString( szMsg );
  1058. m_bFlagFound = true;
  1059. }
  1060. }
  1061. else
  1062. {
  1063. nOctet = (nOctet << 1) + bit;
  1064. nBitCntr++;
  1065. nZeroBitDeleteCntr = (bit == 1) ? (nZeroBitDeleteCntr + 1) : 0;
  1067. if( nBitCntr == 8 )
  1068. {
  1069. if( (m_bFlagFound && nOctet == HDLC_FLAG) ||
  1070. (m_ECMBuffer.GetSize() == m_nECMFrameSize + ECM_DATA_HDR + 2) )
  1071. {
  1072. m_bFoundStartOfFrame = false;
  1073. nZeroBitDeleteCntr = 0;
  1074. //wsprintf( szMsg, "Found end of frame %dn", i );
  1075. //OutputDebugString( szMsg );
  1076. if( ProcessECMFrame() == false )
  1077. {
  1078. // bad frame - resync
  1079. m_bFoundStartOfPage = false;
  1080. }
  1081. }
  1082. else
  1083. {
  1084. m_ECMBuffer.AddByte( nOctet );
  1085. }
  1087. nBitCntr = 0;
  1088. nOctet = 0;
  1089. }
  1090. else if( nBitCntr > 8 )
  1091. {
  1092. //OutputDebugString( "Whoops 2!n" );
  1093. m_bFoundStartOfPage = false;
  1094. m_bFoundStartOfFrame = false;
  1095. }
  1096. }
  1097. }
  1098. }
  1099. }
  1101. return true;
  1102. }
  1107. //////////////////////////////////////////////////////////////////////
  1108. // ProcessECMFrame
  1109. //////////////////////////////////////////////////////////////////////
  1110. bool CFaxFile::ProcessECMFrame( void )
  1111. {
  1112. //char szMsg[160];
  1113. bool bRet = true;
  1115. if( m_ECMBuffer.CheckFCS() )
  1116. {
  1117. if( m_ECMBuffer.GetFCF() == FCD )
  1118. {
  1120. //wsprintf( szMsg, "ECM Frame %d bytes, Control=%02X FCF=%02X Seq=%d LastSeq=%d Data[0]=%02Xn", m_ECMBuffer.GetSize(), 
  1121. //   m_ECMBuffer.GetControl(), m_ECMBuffer.GetFCF(), m_ECMBuffer.GetSeq(), m_ECMBuffer.GetLastSeq(), m_ECMBuffer.GetData()[0] );
  1122. //OutputDebugString( szMsg );
  1124. int nGap = m_ECMBuffer.GetSeq() - m_ECMBuffer.GetLastSeq();
  1126. if( nGap < 1 )
  1127. {
  1128. //wsprintf( szMsg, "Backing up %d framesn", 1 -  nGap );
  1129. //OutputDebugString( szMsg );
  1131. m_MemFile.Seek( (nGap-1) * m_nECMFrameSize, SEEK_CUR );
  1132. //fseek( m_fp, (nGap-1) * m_nECMFrameSize, SEEK_CUR );
  1133. }
  1134. else if( nGap > 1 )
  1135. {
  1136. char Zeros[MAX_ECM_DATA];
  1137. ZeroMemory( Zeros, m_nECMFrameSize );
  1139. if( m_ECMBuffer.GetHighestSeq() > m_ECMBuffer.GetLastSeq() )
  1140. {
  1141. int nNewGap = m_ECMBuffer.GetHighestSeq() - m_ECMBuffer.GetLastSeq();
  1143. if( nNewGap > nGap )
  1144. {
  1145. nNewGap = nGap;
  1146. }
  1148. //wsprintf( szMsg, "Moving forward %d framesn", nNewGap );
  1149. //OutputDebugString( szMsg );
  1150. m_MemFile.Seek( (nNewGap-1) * m_nECMFrameSize, SEEK_CUR );
  1151. //fseek( m_fp, (nNewGap-1) * m_nECMFrameSize, SEEK_CUR );
  1152. nGap -= nNewGap;
  1153. }
  1155. if( nGap > 0 )
  1156. {
  1157. //wsprintf( szMsg, "Skipping %d framesn", nGap - 1 );
  1158. //OutputDebugString( szMsg );
  1160. for( int i = 1; i < nGap; i++ )
  1161. {
  1162. if( m_MemFile.Write( Zeros, m_nECMFrameSize ) == 0 )
  1163. //if( fwrite( Zeros, 1, m_nECMFrameSize, m_fp ) != m_nECMFrameSize )
  1164. {
  1165. //OutputDebugString( "Error writing to filen" );
  1166. }
  1167. }
  1168. }
  1169. }
  1171. m_MemFile.Write( m_ECMBuffer.GetData(), m_nECMFrameSize );
  1173. //if( fwrite( m_ECMBuffer.GetData(), 1, m_nECMFrameSize, m_fp ) != m_nECMFrameSize )
  1174. {
  1175. //OutputDebugString( "Error writing to filen" );
  1176. }
  1178. m_ECMBuffer.UpdateLastSeq();
  1179. }
  1180. else if( m_ECMBuffer.GetFCF() == RCP )
  1181. {
  1182. //OutputDebugString( "Got RCPn" );
  1183. }
  1184. else
  1185. {
  1186. //OutputDebugString( "Unknown ECM Framen" );
  1187. }
  1188. }
  1189. else
  1190. {
  1191. //OutputDebugString( "Bad ECM Framen" );
  1192. bRet = false;
  1193. }
  1195. m_ECMBuffer.InitFrame();
  1197. return bRet;
  1198. }
  1200. //////////////////////////////////////////////////////////////////////
  1201. // NextBlock called between ECM blocks
  1202. //////////////////////////////////////////////////////////////////////
  1203. void CFaxFile::NextECMBlock(void)
  1204. {
  1205. m_MemFile.Seek( 0, SEEK_END );
  1206. m_ECMBuffer.InitFrame();
  1207. m_ECMBuffer.InitBlock();
  1209. m_bFoundStartOfPage = false;
  1210. m_bFoundStartOfFrame = false;
  1211. m_bFoundEndOfPage = false;
  1212. nZcnt = 0;
  1213. nRTCCnt = 0;
  1214. nBitCntr = 0;
  1215. nZeroBitDeleteCntr = 0;
  1216. }
  1218. //////////////////////////////////////////////////////////////////////
  1219. // NextBlock called between ECM blocks
  1220. //////////////////////////////////////////////////////////////////////
  1221. void CFaxFile::RedoECMBlock(void)
  1222. {
  1223. m_ECMBuffer.InitFrame();
  1225. m_bFoundStartOfPage = false;
  1226. m_bFoundStartOfFrame = false;
  1227. m_bFoundEndOfPage = false;
  1228. nZcnt = 0;
  1229. nRTCCnt = 0;
  1230. nBitCntr = 0;
  1231. nZeroBitDeleteCntr = 0;
  1232. }
  1235. //////////////////////////////////////////////////////////////////////
  1236. // WriteIFD prepares for the next fax page
  1237. //////////////////////////////////////////////////////////////////////
  1238. bool CFaxFile::WriteIFD(void)
  1239. {
  1240. m_bGotData = false;
  1241. m_bFoundStartOfPage = false;
  1242. m_bFoundStartOfFrame = false;
  1243. m_bFoundEndOfPage = false;
  1244. nZcnt = 0;
  1245. nRTCCnt = 0;
  1246. nBitCntr = 0;
  1247. nZeroBitDeleteCntr = 0;
  1249. bool bRet = ( WriteIfd() > 0 ) ? true : false;
  1251. if( bRet )
  1252. {
  1253. m_PageCount++;
  1254. }
  1256. return bRet;
  1257. }
  1259. //////////////////////////////////////////////////////////////////////
  1260. // WriteIfd dumps the page to disk
  1261. //////////////////////////////////////////////////////////////////////
  1262. int CFaxFile::WriteIfd (void)
  1263. {
  1264. int nRet = m_MemFile.Size();
  1266. if( length == 0 )
  1267. {
  1268. if( compression == 3 )
  1269. {
  1270. CountGroup3TiffLines();
  1271. }
  1272. else
  1273. {
  1274. CountGroup4TiffLines();
  1275. }
  1276. //char szMsg[80];
  1277. //wsprintf( szMsg, "Counted %d linesn", length );
  1278. //OutputDebugString( szMsg );
  1279. }
  1281. if( (length < 10) || (nRet == 0 ) )
  1282. {
  1283. return 0;
  1284. }
  1286. TIFFSetField( m_tiff, TIFFTAG_SUBFILETYPE, 2 );
  1287. TIFFSetField( m_tiff, TIFFTAG_IMAGEWIDTH, width );
  1288. TIFFSetField( m_tiff, TIFFTAG_IMAGELENGTH, length);
  1289. TIFFSetField( m_tiff, TIFFTAG_PHOTOMETRIC, 0 );
  1290. TIFFSetField( m_tiff, TIFFTAG_ROWSPERSTRIP, length );
  1291. TIFFSetField( m_tiff, TIFFTAG_BITSPERSAMPLE, bitspersample);
  1292. TIFFSetField( m_tiff, TIFFTAG_FILLORDER, fillorder);
  1293. TIFFSetField( m_tiff, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH );
  1294. TIFFSetField( m_tiff, TIFFTAG_XRESOLUTION, xres );
  1295. TIFFSetField( m_tiff, TIFFTAG_YRESOLUTION, yres );
  1296. TIFFSetField( m_tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG );
  1297. TIFFSetField( m_tiff, TIFFTAG_COMPRESSION, compression );
  1298. TIFFSetField( m_tiff, TIFFTAG_PAGENUMBER, m_PageCount, 0 );
  1300. if( compression == COMPRESSION_CCITTFAX3 )
  1301. {
  1302. TIFFSetField( m_tiff, TIFFTAG_GROUP3OPTIONS, g3opts );
  1303. }
  1304. else if( compression == COMPRESSION_CCITTFAX4 )
  1305. {
  1306. TIFFSetField( m_tiff, TIFFTAG_GROUP4OPTIONS, 0 );
  1307. }
  1309. TIFFWriteRawStrip( m_tiff, 0, m_MemFile.GetData(0), m_MemFile.Size() );
  1311. TIFFWriteDirectory( m_tiff );
  1313. m_bFileHasData = true;
  1315. m_MemFile.Clear();
  1317. length = 0;
  1319. return nRet;
  1320. }
  1322. //////////////////////////////////////////////////////////////////////
  1323. // CountGroup3TiffLines
  1324. //////////////////////////////////////////////////////////////////////
  1325. void CFaxFile::CountGroup3TiffLines(void)
  1326. {
  1327. int i;
  1329. nZcnt = 0;
  1330. nRTCCnt = 0;
  1331. m_bFoundEndOfPage = false;
  1333. m_MemFile.Seek( 0, SEEK_SET );
  1335. for( i = 0; i < m_MemFile.Size(); i++ )
  1336. {
  1337. if( !m_bFoundEndOfPage )
  1338. {
  1339. BYTE b = *m_MemFile.GetData(i);
  1341. if (nZcnt) 
  1342. {
  1343. nZcnt += s_LeadZero[b];
  1344. if (b && (nZcnt < 11)) 
  1345. {
  1346. nRTCCnt = 0;
  1347. nZcnt = s_TrailZero[b];
  1348. }
  1349. }
  1350. else 
  1351. {
  1352. nZcnt = s_TrailZero[b];
  1353. if (!nZcnt) nRTCCnt = 0;
  1354. }
  1356. if( nZcnt > 10 && b != 0 )
  1357. {
  1358. nRTCCnt++;
  1359. if (nRTCCnt > 5) 
  1360. {
  1361. //OutputDebugString( "Found RTC!n" );
  1362. IncrementImageLength( -5 );
  1363. m_bFoundEndOfPage = true;
  1364. }
  1365. else
  1366. {
  1367. IncrementImageLength();
  1368. }
  1369. nZcnt = s_TrailZero[b];
  1370. }
  1371. }
  1372. }
  1373. }
  1376. //////////////////////////////////////////////////////////////////////
  1377. // ExpandLine - used by CountGroup4TiffLines
  1378. //////////////////////////////////////////////////////////////////////
  1379. void ExpandLine ( unsigned char color, char *cur_line, 
  1380.    int& bit_2D, int& i_2D, int runlength )
  1381. {
  1382. int copyrun=runlength ;
  1383. if (color==WHITE)
  1384. {
  1385. bit_2D-=(copyrun%8) ;
  1386. i_2D+=(copyrun/8) ;
  1387. if (bit_2D<0)
  1388. {
  1389. bit_2D+=8 ;
  1390. i_2D++ ;
  1391. }
  1392. }
  1393. else for (;;)
  1394. {
  1395. while (bit_2D>0)
  1396. {
  1397. cur_line[i_2D]|=(1<<(bit_2D-1)) ;
  1398. bit_2D-- ;
  1399. if (!(--copyrun)) break ;
  1400. }
  1401. if (copyrun==0) break ;
  1402. i_2D++ ;
  1403. for (; copyrun>8 ; copyrun-=8) cur_line[i_2D++]=(char)0xff ;
  1404. if (copyrun==0) break ;
  1405. bit_2D=8 ;
  1406. }
  1407. }
  1409. //////////////////////////////////////////////////////////////////////
  1410. // CountGroup4TiffLines
  1411. //////////////////////////////////////////////////////////////////////
  1412. void CFaxFile::CountGroup4TiffLines(void)
  1413. {
  1414. int i,j,k;
  1416. nZcnt = 0;
  1417. nRTCCnt = 0;
  1418. m_bFoundEndOfPage = false;
  1420. int dots_left= width;
  1421. int code= 0;
  1422. int resync, a0, b1, b2, horz_runs;
  1423. NODE *tree= (NODE *)&s_WTree ;
  1424. unsigned char octet, ref_color, this_bit, coding_scheme = 1;
  1425.     unsigned char color;      
  1426.     char *cur_line; 
  1427. int i_2D= 0; 
  1428. int bit_2D=8 ;
  1430. char twolines[(2432/8)*2];
  1431. char *ref_line;
  1432. char *tmp_line;
  1434. ref_color = WHITE;
  1436.     memset (twolines,0x00,(width/8)*2) ;
  1437. ref_line= &twolines[0] ;
  1438. cur_line= &twolines[width/8] ;
  1439. coding_scheme= 2 ;
  1440. resync= 0 ;
  1441. color= WHITE ;
  1442. dots_left= width ;
  1443. tree= (NODE *)&s_TwoTree ;
  1444. horz_runs= code= 0 ;
  1445. a0= (-1) ;
  1447. m_MemFile.Seek( 0, SEEK_SET );
  1449. for( k = 0; k < m_MemFile.Size(); k++ )
  1450. {
  1451. octet = *m_MemFile.GetData(k);
  1453. for (i= 0 ; i<8 ; i++, octet<<= 1)
  1454. {
  1456. if( !m_bFoundEndOfPage )
  1457. {
  1458. if ((horz_runs==0)&&(dots_left==0))
  1459. {
  1460. i_2D=0 ;
  1461. bit_2D=8 ;
  1462. IncrementImageLength();
  1463.         coding_scheme= 2 ;
  1464. resync= 0 ;
  1465. color= WHITE ;
  1466. dots_left= width ;
  1467.         tree= (NODE *)&s_TwoTree ;
  1468. tmp_line= ref_line ;
  1469. ref_line= cur_line ;
  1470. cur_line= tmp_line ;
  1471. memset (cur_line,0x00,width/8) ;
  1472. horz_runs= code= 0 ;
  1473. a0= (-1) ;
  1474. }
  1476. if (code== FAXFILE_EOL)
  1477. {
  1478. m_bFoundEndOfPage = true;
  1479. break;
  1480. }
  1482. if (code== FAXFILE_EOL2)
  1483. {
  1484. coding_scheme= ((octet&0x80) >> 7) ;
  1485. if (coding_scheme== 1) tree= (NODE *)&s_WTree ;
  1486. else
  1487. {
  1488. tree= (NODE *)&s_TwoTree ;
  1489. horz_runs= 0 ;
  1490. a0= (-1) ;
  1491. }
  1492. tmp_line= ref_line ;
  1493. ref_line= cur_line ;
  1494. cur_line= tmp_line ;
  1495. memset (cur_line,0x00,width/8) ;
  1496. code= 0 ;
  1497. continue ;
  1498. }
  1500. int nBit = (octet&0x80)>>7;
  1502. code= (*tree)[code][nBit]  ;
  1503. if (code<1)
  1504. {
  1505. code= (-code) ;
  1506. if (!resync) if ((dots_left-= code)<0) resync= 1 ;
  1507. if ((!resync)&&(code!= 0)) ExpandLine( color, cur_line, bit_2D, i_2D, code) ;
  1508. if (code < 64)
  1509. {
  1510. color= (~color) ;
  1511. tree= color ? (NODE *)&s_BTree: (NODE *)&s_WTree;
  1512. if ((coding_scheme!= 1)&&(--horz_runs== 0))
  1513. {
  1514. a0= 0 ;
  1515. tree= (NODE *)&s_TwoTree ;
  1516. }
  1517. } 
  1518. code= 0 ;
  1519. continue ;
  1520. }
  1521. if (code<FAXFILE_OFFTREE) continue ;
  1523. if (code== FAXFILE_OFFTREE)
  1524. {
  1525. resync= 1 ;
  1526. continue ;
  1527. }
  1529. if (code== FAXFILE_EOL)
  1530. {
  1531. continue;
  1532. }
  1534. if (code== FAXFILE_HORZ)
  1535. {
  1536. horz_runs= 2 ;
  1537. code= 0 ;
  1538. tree= color ? (NODE *)&s_BTree: (NODE *)&s_WTree;
  1539. continue ;
  1540. }
  1543. if (a0== (-1)) ref_color= WHITE ;
  1544. else
  1545. {
  1546. a0= (width-dots_left) ;
  1547. j= (a0/8) ;
  1548. this_bit= (0x80>>(a0%8)) ;
  1549. if ((unsigned char)ref_line[j]&this_bit) ref_color= BLACK ; else ref_color= WHITE ;
  1550. }
  1552. for (b1= a0+1;b1<width;b1++)
  1553. {
  1554. j= (b1/8) ;
  1555. this_bit= (0x80>>(b1%8)) ;
  1556. if (((unsigned char)ref_line[j]&this_bit)!= (ref_color&this_bit)) break ;
  1557. }
  1558. if (ref_color!= color)
  1559. {
  1560. for (b1++;b1<width;b1++)
  1561. {
  1562. j= (b1/8) ;
  1563. this_bit= (0x80>>(b1%8)) ;
  1564. if (((unsigned char)ref_line[j]&this_bit)== (ref_color&this_bit)) break ;
  1565. }
  1566. }
  1567. if (b1>width) b1= width ;
  1568. a0= (width-dots_left) ;
  1570. if (code<FAXFILE_PASS)
  1571. {
  1572. code= ((b1-a0)+(code-FAXFILE_V_0)) ; if (code < 0) resync= 1;
  1573. if (!resync) if ((dots_left-= code)<0) resync= 1 ;
  1574. if ((!resync)&&(code!= 0)) ExpandLine( color, cur_line, bit_2D, i_2D, code);
  1575. color= (~color) ;
  1576. code= 0 ;
  1577. continue ;
  1578. }
  1580. for (b2= b1+1;b2<width;b2++)
  1581. {
  1582. j= (b2/8) ;
  1583. this_bit= (0x80>>(b2%8)) ;
  1584. if (((unsigned char)ref_line[j]&this_bit)== (color&this_bit)) break ;
  1585. }
  1586. if (b2>width) b2= width ;
  1588. if (code== FAXFILE_PASS)
  1589. {
  1590. code= (b2-a0) ; if (code < 0) resync= 1;
  1591. if (!resync) if ((dots_left-= code)<0) resync= 1 ;
  1592. if ((!resync)&&(code!= 0)) ExpandLine( color, cur_line, bit_2D, i_2D, code);
  1593. code= 0 ;
  1594. continue ;
  1595. }
  1597. m_bFoundEndOfPage = true;
  1598. break;
  1599. }
  1600. }
  1601. }
  1602. }
  1605. //////////////////////////////////////////////////////////////////////
  1606. // SelectEncoding
  1607. //////////////////////////////////////////////////////////////////////
  1608. void CFaxFile::SelectEncoding( int nEncoding )
  1609. {
  1610. m_nSendEncoding = nEncoding;
  1611. }
  1614. //////////////////////////////////////////////////////////////////////
  1615. // Clear
  1616. //////////////////////////////////////////////////////////////////////
  1617. void CFaxFile::Clear(void)
  1618. {
  1619. bitspersample = 1;
  1620. width = 1728;
  1621. length = 0;
  1622. fillorder = 1;
  1623. g3opts = 0;
  1624. compression = COMPRESSION_CCITTFAX3;
  1625. xres = 204.0f;
  1626. yres = 196.0f;
  1628. m_MemFile.Clear();
  1629. }