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

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

传真(Fax)编程

开发平台：

Visual C++

ClassOne.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. ////////////////////////////////////////////////////////////////////////////////
  18. //
  19. // The purpose of CClassOne is contain the protocol specifics of EIA
  20. // fax modem class 1
  21. //
  22. ////////////////////////////////////////////////////////////////////////////////
  24. #include "stdafx.h"
  25. #include "ClassOne.h"
  28. //////////////////////////////////////////////////////////////////////
  29. // Construction/Destruction
  30. //////////////////////////////////////////////////////////////////////
  32. CClassOne::CClassOne()
  33. {
  34. m_sEIAClass = "1";
  35. }
  37. CClassOne::~CClassOne()
  38. {
  40. }
  43. void CClassOne::OnConnect(void)
  44. {
  45. SetState( STATE_INIT );
  47. SendCommand( COMMAND_INIT );
  49. m_nLoopCtr = 0; 
  50. }
  53. bool CClassOne::OnDisconnect(void)
  54. {
  55. switch( m_nState )
  56. {
  57. case STATE_INIT:
  58. SignalEvent( EVENT_ERROR );
  59. return true;
  61. case STATE_PHASE_A:
  62. case STATE_PHASE_B:
  63. case STATE_PHASE_C:
  64.   case STATE_PHASE_D:
  65.     case STATE_PHASE_E:
  66. Abort( true );
  67. return false;
  68. }
  70. return true;
  71. }
  73. //////////////////////////////////////////////////////////////////////
  74. // OnWrite
  75. //////////////////////////////////////////////////////////////////////
  76. void CClassOne::OnWrite(void)
  77. {
  78. m_dwActivityTimer = GetTickCount();
  80. if( m_nState == STATE_PHASE_C && !m_bReceiving )
  81. {
  82. m_nPageBytes += m_BytesWritten;
  84. int nPercent = 100 * m_nPageBytes / m_FaxFile.GetPageBytes();
  86. if( nPercent > 100 )
  87. nPercent = 100;
  89. SignalEvent( EVENT_PAGE_DATA, nPercent );
  90. }
  91. }
  94. //////////////////////////////////////////////////////////////////////
  95. // OnReadLine
  96. //////////////////////////////////////////////////////////////////////
  97. void CClassOne::OnReadLine(void)
  98. {
  99. //char szMsg[256];
  100. //wsprintf( szMsg, "CClassOne::OnReadLine: %s %dn", m_szLineBuff, m_nLineBuffPtr );
  101. //OutputDebugString( szMsg );
  103. switch( m_nState )
  104. {
  105. case STATE_IDLE:
  106. PhaseIdle();
  107. break;
  109. case STATE_INIT:
  110. PhaseInit();
  111. break;
  113. case STATE_PHASE_A:
  114. PhaseA();
  115. break;
  117. case STATE_PHASE_B:
  118. PhaseB();
  119. break;
  121. case STATE_PHASE_C:
  122. PhaseC();
  123. break;
  125. case STATE_PHASE_D:
  126. PhaseD();
  127. break;
  129. case STATE_PHASE_E:
  130. PhaseE();
  131. break;
  133. case STATE_RINGING:
  134. PhaseRinging();
  135. break;
  137. case STATE_DISCONNECT:
  138. PhaseDisconnect();
  139. break;
  140. }
  142. }
  145. //////////////////////////////////////////////////////////////////////
  146. // PhaseInit
  147. //////////////////////////////////////////////////////////////////////
  148. void CClassOne::PhaseInit(void)
  149. {
  150. if( stricmp( m_szLineBuff, m_LastCommandString.c_str() ) == 0 )
  151. {
  152. // Echo - ignore
  153. return;
  154. }
  156. if( IsRing() )
  157. {
  158. // RING
  159. m_nRingCount++;
  160. return;
  161. }
  163. switch( m_nLastCommand )
  164. {
  165. case COMMAND_INIT:
  166. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  167. {
  168. m_bGotOK = true;
  169. // m_nLoopCtr = 0;
  170. // SendCommand( COMMAND_SETUP_STRING );
  171. }
  172. else 
  173. {
  174. if( ++m_nLoopCtr >= 3 )
  175. {
  176. ErrorUnexpectedResponse();
  177. KillTimer( TIMER_COMMAND );
  178. OnDisconnectMsg();
  179. }
  180. }
  181. break;
  183. case COMMAND_SETUP_STRING:
  184. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  185. {
  186. SendCommand( COMMAND_DISABLE_ECHO );
  187. }
  188. else
  189. {
  190. ErrorUnexpectedResponse();
  191. //SetState( STATE_IDLE );
  192. SendCommand( COMMAND_DISABLE_ECHO );
  193. }
  194. break;
  196. case COMMAND_DISABLE_ECHO:
  197. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  198. {
  199. SendCommand( COMMAND_SET_SPKR_VOL );
  200. }
  201. else
  202. {
  203. ErrorUnexpectedResponse();
  204. SendCommand( COMMAND_SET_SPKR_VOL );
  205. }
  206. break;
  208. case COMMAND_SET_SPKR_VOL:
  209. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  210. {
  211. SendCommand( COMMAND_SET_SPKR_MODE );
  212. }
  213. else
  214. {
  215. ErrorUnexpectedResponse();
  216. SendCommand( COMMAND_SET_SPKR_MODE );
  217. }
  218. break;
  220. case COMMAND_SET_SPKR_MODE:
  221. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  222. {
  223. SendCommand( COMMAND_SET_FCLASS_1 );
  224. }
  225. else
  226. {
  227. ErrorUnexpectedResponse();
  228. SendCommand( COMMAND_SET_FCLASS_1 );
  229. }
  230. break;
  232. case COMMAND_SET_FCLASS_1:
  233. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  234. {
  235. SendCommand( COMMAND_QUERY_SEND_SPEEDS );
  236. }
  237. else
  238. {
  239. ErrorUnexpectedResponse();
  240. KillTimer( TIMER_COMMAND );
  241. OnDisconnectMsg();
  242. }
  243. break;
  245. case COMMAND_QUERY_SEND_SPEEDS:
  246. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  247. {
  248. SendCommand( COMMAND_QUERY_RECEIVE_SPEEDS );
  249. }
  250. else
  251. {
  252. ProcSupportedSpeeds( m_szLineBuff, true );
  253. }
  254. break;
  256. case COMMAND_QUERY_RECEIVE_SPEEDS:
  257. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  258. {
  259. KillTimer( TIMER_COMMAND );
  260. SetState( STATE_IDLE );
  261. }
  262. else
  263. {
  264. ProcSupportedSpeeds( m_szLineBuff, false );
  265. }
  266. break;
  267. }
  268. }
  270. //////////////////////////////////////////////////////////////////////
  271. // PhaseIdle
  272. //////////////////////////////////////////////////////////////////////
  273. void CClassOne::PhaseIdle(void)
  274. {
  275. if( IsRing() )
  276. {
  277. m_nRingCount = 1;
  278. SetState( STATE_RINGING );
  280. SignalEvent( EVENT_RING, m_nRingCount );
  281. }
  282. }
  284. //////////////////////////////////////////////////////////////////////
  285. // Phase Ringing
  286. //////////////////////////////////////////////////////////////////////
  287. void CClassOne::PhaseRinging(void)
  288. {
  289. if( IsRing() )
  290. {
  291. m_nRingCount++;
  293. SignalEvent( EVENT_RING, m_nRingCount );
  295. /*
  296. if( OkToAnswer() )
  297. {
  298. m_bReceiving = true;
  299. m_bSuccessful = false;
  300. SendCommand( COMMAND_ANSWER );
  301. SetState( STATE_PHASE_A );
  302. }
  303. */
  304. }
  305. else if( strnicmp( m_szLineBuff, "CONNECT", 7 ) == 0 )
  306. {
  307. m_FaxFile.SetSendEncoding( m_nSendEncoding );
  308. m_bReceiving = true;
  309. m_bSuccessful = false;
  310. m_nLoopCtr = 0;
  311. m_bGotDCN = false;
  312. SignalEvent( EVENT_START_RECV );
  313. SendID(CSI);
  314. SetState( STATE_PHASE_B, STATE_SEND_DIS );
  315. }
  316. else
  317. {
  318. SignalEvent( EVENT_CALLERID );
  319. }
  320. }
  322. //////////////////////////////////////////////////////////////////////
  323. // Phase A - call setup
  324. //////////////////////////////////////////////////////////////////////
  325. void CClassOne::PhaseA(void)
  326. {
  327. if( strnicmp( m_szLineBuff, "CONNECT", 7 ) == 0 )
  328. {
  329. m_nLoopCtr = 0;
  330. m_bGotDCN = false;
  332. if( m_bReceiving )
  333. {
  334. SignalEvent( EVENT_START_RECV );
  335. SendID(CSI);
  336. SetState( STATE_PHASE_B, STATE_SEND_DIS );
  337. }
  338. else
  339. {
  340. SignalEvent( EVENT_START_SEND );
  341. m_bGotDIS = false;
  342. m_bGotConnect = false;
  343. InitHDLC();
  344. SetState( STATE_PHASE_B, STATE_WAIT_FOR_DIS );
  345. }
  346. return;
  347. }
  348. else
  349. {
  350. ErrorConnectResponse();
  351. Terminate();
  352. PhaseDisconnect();
  353. }
  354. }
  356. //////////////////////////////////////////////////////////////////////
  357. // Phase B - negotiation and training
  358. //////////////////////////////////////////////////////////////////////
  359. void CClassOne::PhaseB(void)
  360. {
  361. switch( m_nPhaseState )
  362. {
  364. // begin sending states
  366. case STATE_WAIT_FOR_DIS:
  367. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  368. {
  369. if( m_bGotDCN )
  370. {
  371. m_sLastError.assign( (char*)LoadString(GEN_UNEXPECTED_DCN_RECEIVED).c_str() );
  372. Terminate();
  373. DoHangup();
  374. }
  375. else if( m_bFinalHDLCFrame && m_bGotDIS )
  376. {
  377. m_nLoopCtr = 0;
  378. EnableSoftFlowControl( true );
  379. SendHDLCFrame();
  380. m_nPhaseState = STATE_SEND_TIS;
  381. }
  382. else
  383. {
  384. // ask for another
  385. if( ++m_nLoopCtr >= 6 )
  386. {
  387. m_sLastError.assign( (char*)LoadString(GEN_DIS_NOT_RECEIVED).c_str() );
  388. // SignalEvent( EVENT_ERROR );
  389. SendHDLCFrame();
  390. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  391. }
  392. else
  393. {
  394. RecvHDLCFrame();
  395. }
  396. }
  397. }
  398. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  399. {
  400. // get ready for another HDLC frame
  401. m_bGotConnect = true;
  402. InitHDLC();
  403. KillTimer( TIMER_HDLC_RECV );
  404. }
  405. else 
  406. {
  407. if( ++m_nLoopCtr >= 3 )
  408. {
  409. m_sLastError.assign( (char*)LoadString(GEN_DIS_NOT_RECEIVED).c_str() );
  410. // SignalEvent( EVENT_ERROR );
  411. SendHDLCFrame();
  412. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  413. }
  414. else
  415. {
  416. RecvHDLCFrame();
  417. }
  418. }
  419. break;
  421. case STATE_SEND_TIS:
  422. if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  423. {
  424. SendID(TSI);
  425. m_nPhaseState = STATE_SEND_DCS;
  426. m_bGotConnect = false;
  427. }
  428. else 
  429. {
  430. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SENDING_TSI).c_str() );
  431. // SignalEvent( EVENT_ERROR );
  432. SendHDLCFrame();
  433. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  434. }
  435. break;
  437. case STATE_SEND_DCS:
  438. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  439. {
  440. // Send 75ms of silence
  441. SendFormattedCommand( "FTS", 8 );
  442. m_nPhaseState = STATE_SEND_SILENCE_BEFORE_TRAINING;
  443. }
  444. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  445. {
  446. m_bGotConnect = true;
  447. SendDCS();
  448. }
  449. else 
  450. {
  451. if( ++m_nLoopCtr >= 3 )
  452. {
  453. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SENDING_DCS).c_str() );
  454. // SignalEvent( EVENT_ERROR );
  455. SendHDLCFrame();
  456. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  457. }
  458. else
  459. {
  460. SendHDLCFrame();
  461. }
  462. }
  463. break;
  465. case STATE_SEND_SILENCE_BEFORE_TRAINING:
  466. //if( stricmp( m_szLineBuff, "OK" ) != 0 )
  467. //{
  468. // OutputDebugString( "Error sending silencen" );
  469. //}
  470. SendLongTraining();
  471. // change state
  472. m_nPhaseState = STATE_SEND_TRAINING_DATA;
  473. SignalEvent( EVENT_START_TRAINING );
  474. break;
  476. case STATE_SEND_TRAINING_DATA:
  477. if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  478. {
  479. SendTraining();
  480. m_nPhaseState = STATE_SEND_TRAINING;
  481. }
  482. else 
  483. {
  484. if( ++m_nLoopCtr >= 3 )
  485. {
  486. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SENDING_TRAINING_DATA).c_str() );
  487. // SignalEvent( EVENT_ERROR );
  488. SendHDLCFrame();
  489. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  490. }
  491. else
  492. {
  493. SendHDLCFrame();
  494. m_nPhaseState = STATE_SEND_DCS;
  495. m_bGotConnect = false;
  496. }
  497. }
  498. break;
  500. case STATE_SEND_TRAINING:
  501. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  502. {
  503. m_bGotCFR = false;
  504. m_bGotCRP = false;
  505. //OutputDebugString( "Requesting CFRn" );
  506. EnableSoftFlowControl( false );
  507. RecvHDLCFrame();
  508. // change state
  509. m_nPhaseState = STATE_WAIT_FOR_CFR;
  510. m_bFinalHDLCFrame = false;
  512. char szEvMsg[FAXAPI_MODEMMSG_INFOLEN];
  513. wsprintf( szEvMsg, (char*)LoadString(GEN_SENT_TRAINING_AT_BAUD).c_str(), cls1Speeds[m_nClass1Speed].dwSpeed );
  514. SignalEventString( EVENT_INFO, szEvMsg );
  515. }
  516. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  517. {
  518. if( m_WriteQueue.size() == 0 )
  519. {
  520. // Send another end of data in case it got lost
  521. //OutputDebugString( "Sending extra <DLE><ETX>n" );
  522. unsigned char Frame[2];
  523. Frame[0] = DLE; // <dle>
  524. Frame[1] = ETX; // <etx>
  525. DoWrite( (char*)Frame, 2, false );
  526. }
  527. }
  528. else if( m_szLineBuff[0] == XOFF )
  529. {
  530. // Ignore
  531. }
  532. else
  533. {
  534. if( ++m_nLoopCtr >= 3 )
  535. {
  536. m_sLastError.assign( (char*)LoadString(GEN_ERROR_IN_TRAINING).c_str() );
  537. // SignalEvent( EVENT_ERROR );
  538. SendHDLCFrame();
  539. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  540. }
  541. else
  542. {
  543. SendHDLCFrame();
  544. m_nPhaseState = STATE_SEND_DCS;
  545. m_bGotConnect = false;
  546. }
  547. }
  548. break;
  550. case STATE_WAIT_FOR_CFR:
  551. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  552. {
  553. if( m_bGotDCN )
  554. {
  555. Terminate();
  556. DoHangup();
  557. }
  558. else if( m_bGotCRP )
  559. {
  560. SendHDLCFrame();
  561. m_nPhaseState = STATE_SEND_DCS;
  562. m_bGotConnect = false;
  563. }
  564. else if( m_bFinalHDLCFrame )
  565. {
  566. m_nLoopCtr = 0;
  567. EnableSoftFlowControl( true );
  569. if( m_bGotCFR )
  570. {
  571. // Send 75ms of silence
  572. SendFormattedCommand( "FTS", 8 );
  573. m_nPhaseState = STATE_SEND_SILENCE_BEFORE_DATA;
  575. m_nPPRCtr = 0;
  576. if( m_FaxFile.ReadPage( m_bECM, m_nClass1Speed, m_wMinLineChars ) == false )
  577. {
  578. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  579. // SignalEvent( EVENT_ERROR );
  580. SendHDLCFrame();
  581. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  582. }
  583. }
  584. else
  585. {
  586. if( m_nClass1Speed == 0 )
  587. {
  588. m_sLastError.assign( (char*)LoadString(GEN_ERROR_IN_TRAINING).c_str() );
  589. SendHDLCFrame();
  590. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  591. }
  592. else
  593. {
  594. //  decrement speed and retrain
  595. DecrementSpeed();
  596. SendHDLCFrame();
  597. m_nPhaseState = STATE_SEND_DCS;
  598. m_bGotConnect = false;
  599. }
  600. }
  601. }
  602. else if( m_bRecvHDLCError )
  603. {
  604. if( ++m_nLoopCtr >= 3 )
  605. {
  606. m_sLastError.assign( (char*)LoadString(GEN_SENT_DCS_3_TIMES_WITHOUT_RESPONSE).c_str() );
  607. // SignalEvent( EVENT_ERROR );
  608. SendHDLCFrame();
  609. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  610. }
  611. else
  612. {
  613. SendHDLCFrame();
  614. m_nPhaseState = STATE_SEND_DCS;
  615. m_bGotConnect = false;
  616. }
  617. }
  618. else
  619. {
  620. RecvHDLCFrame();
  621. }
  622. }
  623. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  624. {
  625. m_bGotConnect = true;
  626. // get ready for another HDLC frame
  627. InitHDLC();
  628. KillTimer( TIMER_HDLC_RECV );
  629. }
  630. else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
  631. {
  632. m_bRecvHDLCError = true;
  633. }
  634. else 
  635. {
  636. if( ++m_nLoopCtr >= 3 )
  637. {
  638. m_sLastError.assign( (char*)LoadString(GEN_SENT_DCS_3_TIMES_WITHOUT_RESPONSE).c_str() );
  639. // SignalEvent( EVENT_ERROR );
  640. SendHDLCFrame();
  641. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  642. }
  643. else
  644. {
  645. SendHDLCFrame();
  646. m_nPhaseState = STATE_SEND_DCS;
  647. m_bGotConnect = false;
  648. }
  649. }
  650. break;
  652. case STATE_SEND_SILENCE_BEFORE_DATA:
  653. //if( stricmp( m_szLineBuff, "OK" ) != 0 )
  654. //{
  655. // OutputDebugString( "Error sending silencen" );
  656. //}
  657. SendShortTraining();
  658. // change state
  659. SetState( STATE_PHASE_C );
  660. break;
  663. // begin receiving states
  665. case STATE_SEND_CSI:
  666. if( strnicmp( m_szLineBuff, "CONNECT", 7 ) == 0 )
  667. {
  668. SendID(CSI);
  669. m_nPhaseState = STATE_SEND_DIS;
  670. }
  671. else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
  672. {
  673. // ignore
  674. }
  675. else
  676. {
  677. if( ++m_nLoopCtr >= 3 )
  678. {
  679. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SENDING_CSI).c_str() );
  680. // SignalEvent( EVENT_ERROR );
  681. SendHDLCFrame();
  682. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  683. }
  684. else
  685. {
  686. SendHDLCFrame();
  687. }
  688. }
  689. break;
  691. case STATE_SEND_DIS:
  692. if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  693. {
  694. //OutputDebugString( "Sending DISn" );
  695. SendDIS();
  696. m_bFinalHDLCFrame = false;
  697. m_bGotDCS = false;
  698. m_bGotCRP = false;
  699. m_nPhaseState = STATE_DIS_SENT;
  700. EnableSoftFlowControl( false );
  701. }
  702. else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
  703. {
  704. // ignore
  705. }
  706. else 
  707. {
  708. if( ++m_nLoopCtr >= 3 )
  709. {
  710. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SENDING_DIS).c_str() );
  711. // SignalEvent( EVENT_ERROR );
  712. SendHDLCFrame();
  713. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  714. }
  715. else
  716. {
  717. SendHDLCFrame();
  718. m_nPhaseState = STATE_SEND_CSI;
  719. }
  720. }
  721. break;
  723. case STATE_DIS_SENT:
  724. //OutputDebugString( "Waiting for DCSn" );
  725. RecvHDLCFrame();
  726. m_nPhaseState = STATE_WAIT_FOR_DCS;
  727. m_bGotConnect = false;
  728. break;
  730. case STATE_WAIT_FOR_DCS:
  731. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  732. {
  733. if( m_bGotDCN )
  734. {
  735. m_sLastError.assign( (char*)LoadString(GEN_UNEXPECTED_DCN_RECEIVED).c_str() );
  736. Terminate();
  737. DoHangup();
  738. }
  739. else if( m_bFinalHDLCFrame )
  740. {
  741. if( m_bGotDCS )
  742. {
  743. m_dwTrainingStart = GetTickCount();
  744. SetTimer( TIMER_TRAINING, 4000 );
  745. m_nPhaseState = STATE_RECEIVE_TRAINING_DATA;
  746. RecvLongTraining();
  747. SignalEvent( EVENT_START_TRAINING );
  748. }
  749. else if( m_bGotCRP )
  750. {
  751. SendHDLCFrame();
  752. m_nPhaseState = STATE_SEND_CSI;
  753. }
  754. else
  755. {
  756. if( ++m_nLoopCtr >= 3 )
  757. {
  758. m_sLastError.assign( (char*)LoadString(GEN_SENT_DIS_3_TIMES_WITHOUT_RESPONSE).c_str() );
  759. // SignalEvent( EVENT_ERROR );
  760. SendHDLCFrame();
  761. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  762. }
  763. else
  764. {
  765. m_nPhaseState = STATE_SEND_CSI;
  766. SendHDLCFrame();
  767. }
  768. }
  769. }
  770. else if( m_bRecvHDLCError )
  771. {
  772. if( ++m_nLoopCtr >= 3 )
  773. {
  774. m_sLastError.assign( (char*)LoadString(GEN_SENT_DIS_3_TIMES_WITHOUT_RESPONSE).c_str() );
  775. // SignalEvent( EVENT_ERROR );
  776. SendHDLCFrame();
  777. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  778. }
  779. else
  780. {
  781. m_nPhaseState = STATE_SEND_CSI;
  782. SendHDLCFrame();
  783. }
  784. }
  785. else
  786. {
  787. // ask for another
  788. //OutputDebugString( "Waiting for DCSn" );
  789. RecvHDLCFrame();
  790. }
  791. }
  792. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  793. {
  794. // get ready for another HDLC frame
  795. m_bGotConnect = true;
  796. InitHDLC();
  797. KillTimer( TIMER_HDLC_RECV );
  798. }
  799. else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
  800. {
  801. m_bRecvHDLCError = true;
  802. }
  803. else 
  804. {
  805. if( ++m_nLoopCtr >= 3 )
  806. {
  807. m_sLastError.assign( (char*)LoadString(GEN_SENT_DIS_3_TIMES_WITHOUT_RESPONSE).c_str() );
  808. // SignalEvent( EVENT_ERROR );
  809. SendHDLCFrame();
  810. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  811. }
  812. else
  813. {
  814. m_nPhaseState = STATE_SEND_CSI;
  815. SendHDLCFrame();
  816. }
  817. }
  818. break;
  820. case STATE_RECEIVE_TRAINING_DATA:
  821. if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  822. {
  823. KillTimer( TIMER_TRAINING );
  824. InitHDLC();
  825. m_nPhaseState = STATE_RECEIVE_TRAINING;
  826. m_nCorrect = 0;
  827. }
  828. else 
  829. {
  830. // Wait 1.5 seconds so that the transmitter gets our FTT
  831. int nTimeLeft = (1500 - (GetTickCount() - m_dwTrainingStart));
  832. if( nTimeLeft > 0 )
  833. {
  834. // try the receive command again
  835. RecvLongTraining();
  836. }
  837. else
  838. {
  839. KillTimer( TIMER_TRAINING );
  840. SendHDLCFrame();
  841. m_nPhaseState = STATE_SEND_CFR;
  842. }
  843. }
  844. break;
  846. case STATE_RECEIVE_TRAINING:
  847. if( stricmp( m_szLineBuff, "OK" ) == 0 ||
  848. stricmp( m_szLineBuff, "NO CARRIER" ) == 0 )
  849. {
  850. // send CFR
  851. SendHDLCFrame();
  852. m_nPhaseState = STATE_SEND_CFR;
  853. }
  854. else 
  855. {
  856. // Wait 1.5 seconds so that the transmitter gets our FTT
  857. int nDelay = (1500 - (GetTickCount() - m_dwTrainingStart));
  858. if( nDelay > 0 )
  859. {
  860. Sleep( nDelay );
  861. }
  863. //OutputDebugString( "Error receiving training datan" );
  864. // send CFR
  865. SendHDLCFrame();
  866. m_nPhaseState = STATE_SEND_CFR;
  867. }
  868. break;
  870. case STATE_SEND_CFR:
  871. if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  872. {
  873. // send CFR
  874. if( m_nCorrect > 70 )
  875. {
  876. SendCFR();
  877. m_nPhaseState = STATE_SEND_RECV_DATA;
  878. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_CFR).c_str() );
  879. }
  880. else
  881. {
  882. SendFTT();
  883. m_bFinalHDLCFrame = false;
  884. m_bRecvHDLCError = false;
  885. m_nPhaseState = STATE_SENT_FTT;
  886. EnableSoftFlowControl( false );
  887. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_FTT).c_str() );
  888. }
  889. }
  890. else 
  891. {
  892. if( ++m_nLoopCtr >= 3 )
  893. {
  894. m_sLastError.assign( (char*)LoadString(GEN_SENT_DIS_3_TIMES_WITHOUT_RESPONSE).c_str() );
  895. // SignalEvent( EVENT_ERROR );
  896. SendHDLCFrame();
  897. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  898. }
  899. else
  900. {
  901. m_nPhaseState = STATE_SEND_CSI;
  902. SendHDLCFrame();
  903. }
  904. }
  905. break;
  907. case STATE_SEND_RECV_DATA:
  908. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  909. {
  910. //OutputDebugString( "Going to phase Cn" );
  911. RecvShortTraining();
  912. SetState( STATE_PHASE_C );
  913. m_FaxFile.WriteFileHeader();
  914. m_nPPRCtr = 0;
  915. }
  916. else 
  917. {
  918. if( ++m_nLoopCtr >= 3 )
  919. {
  920. m_sLastError.assign( (char*)LoadString(GEN_SENT_DIS_3_TIMES_WITHOUT_RESPONSE).c_str() );
  921. // SignalEvent( EVENT_ERROR );
  922. SendHDLCFrame();
  923. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  924. }
  925. else
  926. {
  927. m_nPhaseState = STATE_SEND_CSI;
  928. SendHDLCFrame();
  929. }
  930. }
  931. break;
  934. case STATE_SENT_FTT:
  935. RecvHDLCFrame();
  936. m_nPhaseState = STATE_SENT_FTT_WAIT_FOR_DCS;
  937. break;
  939. case STATE_SENT_FTT_WAIT_FOR_DCS:
  940. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  941. {
  942. if( m_bGotDCN )
  943. {
  944. m_sLastError.assign( (char*)LoadString(GEN_UNEXPECTED_DCN_RECEIVED).c_str() );
  945. Terminate();
  946. DoHangup();
  947. }
  948. else if( m_bFinalHDLCFrame )
  949. {
  950. if( m_bGotDCS )
  951. {
  952. m_nLoopCtr = 0;
  953. SetTimer( TIMER_TRAINING, 4000 );
  954. m_nPhaseState = STATE_RECEIVE_TRAINING_DATA;
  955. RecvLongTraining();
  956. SignalEvent( EVENT_START_TRAINING );
  957. }
  958. else if( m_bGotCRP )
  959. {
  960. SendHDLCFrame();
  961. m_nPhaseState = STATE_SEND_CFR;
  962. }
  963. else
  964. {
  965. if( ++m_nLoopCtr >= 3 )
  966. {
  967. m_sLastError.assign( (char*)LoadString(GEN_SENT_FTT_3_TIMES_WITHOUT_RESPONSE).c_str() );
  968. // SignalEvent( EVENT_ERROR );
  969. SendHDLCFrame();
  970. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  971. }
  972. else
  973. {
  974. m_nPhaseState = STATE_SEND_CFR;
  975. SendHDLCFrame();
  976. }
  977. }
  978. }
  979. else if( m_bRecvHDLCError )
  980. {
  981. if( ++m_nLoopCtr >= 3 )
  982. {
  983. m_sLastError.assign( (char*)LoadString(GEN_SENT_FTT_3_TIMES_WITHOUT_RESPONSE).c_str() );
  984. // SignalEvent( EVENT_ERROR );
  985. SendHDLCFrame();
  986. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  987. }
  988. else
  989. {
  990. m_nPhaseState = STATE_SEND_CFR;
  991. SendHDLCFrame();
  992. }
  993. }
  994. else
  995. {
  996. // ask for another
  997. //OutputDebugString( "Waiting for DCSn" );
  998. RecvHDLCFrame();
  999. }
  1000. }
  1001. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1002. {
  1003. // get ready for another HDLC frame
  1004. m_bGotConnect = true;
  1005. InitHDLC();
  1006. KillTimer( TIMER_HDLC_RECV );
  1007. }
  1008. else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
  1009. {
  1010. m_bRecvHDLCError = true;
  1011. }
  1012. else 
  1013. {
  1014. if( ++m_nLoopCtr >= 3 )
  1015. {
  1016. m_sLastError.assign( (char*)LoadString(GEN_SENT_FTT_3_TIMES_WITHOUT_RESPONSE).c_str() );
  1017. // SignalEvent( EVENT_ERROR );
  1018. SendHDLCFrame();
  1019. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1020. }
  1021. else
  1022. {
  1023. m_nPhaseState = STATE_SEND_CFR;
  1024. SendHDLCFrame();
  1025. }
  1026. }
  1027. break;
  1029. }
  1030. }
  1032. //////////////////////////////////////////////////////////////////////
  1033. // Phase C - transmit/receive data
  1034. //////////////////////////////////////////////////////////////////////
  1035. void CClassOne::PhaseC(void)
  1036. {
  1037. if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1038. {
  1039. if( m_bReceiving )
  1040. {
  1041. InitHDLC();
  1042. }
  1043. else
  1044. {
  1045. m_nPageBytes = 0;
  1046. DoWrite( m_FaxFile.GetPageData(), m_FaxFile.GetPageBytes(), false );
  1048. SetMaxPageRetriesTimer();
  1049. }
  1051. SignalEvent( EVENT_START_PAGE );
  1052. }
  1053. else if( stricmp( m_szLineBuff, "+FCERROR" ) == 0 )
  1054. {
  1055. if( m_bReceiving )
  1056. {
  1057. RecvShortTraining();
  1058. }
  1059. else
  1060. {
  1061. SendShortTraining();
  1062. }
  1063. }
  1064. else /*if( stricmp( m_szLineBuff, "OK" ) == 0 ||
  1065.      stricmp( m_szLineBuff, "NO CARRIER" ) == 0) */
  1066. {
  1067. m_nLoopCtr = 0;
  1069. if( m_bReceiving )
  1070. {
  1071. if( !m_bECM )
  1072. {
  1073. m_bLastPageGood = m_FaxFile.WriteIFD();
  1074. }
  1076. m_bGotEOP = false;
  1077. m_bGotMPS = false;
  1078. m_bGotEOM = false;
  1079. m_bFinalHDLCFrame = false;
  1080. RecvHDLCFrame();
  1082. m_dwEOPWaitStart = GetTickCount();
  1084. SetState( STATE_PHASE_D, STATE_WAIT_FOR_EOP );
  1085. }
  1086. else
  1087. {
  1088. // Send 75ms of silence
  1089. SendFormattedCommand( "FTS", 8 );
  1090. SetState( STATE_PHASE_D, STATE_SEND_SILENCE_BEFORE_PAGE_FINISHED );
  1091. }
  1092. }
  1093. }
  1095. //////////////////////////////////////////////////////////////////////
  1096. // Phase D - end of page
  1097. //////////////////////////////////////////////////////////////////////
  1098. void CClassOne::PhaseD(void)
  1099. {
  1100. switch( m_nPhaseState )
  1101. {
  1103. // begin sending states
  1105. case STATE_SEND_SILENCE_BEFORE_PAGE_FINISHED:
  1106. //if( stricmp( m_szLineBuff, "OK" ) != 0 )
  1107. //{
  1108. // OutputDebugString( "Error sending silencen" );
  1109. //}
  1110. SendHDLCFrame();
  1111. m_nPhaseState = STATE_SEND_PAGE_FINISHED;
  1112. break;
  1114. case STATE_SEND_PAGE_FINISHED:
  1115. if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1116. {
  1117. SendEOP();
  1118. m_nPhaseState = STATE_PAGE_FINISHED_SENT;
  1119. m_bGotPPR = false;
  1120. m_bFinalHDLCFrame = false;
  1121. m_bGotMCF = false;
  1122. m_bGotRNR = false;
  1123. m_bGotCRP = false;
  1124. m_bGotRTP = false;
  1125. m_bGotRTN = false;
  1126. m_dwRNRStart = 0;
  1127. }
  1128. else 
  1129. {
  1130. if( ++m_nLoopCtr >= 3 )
  1131. {
  1132. m_sLastError.assign( (char*)LoadString(GEN_SENT_PPS_3_TIMES_WITHOUT_RESPONSE).c_str() );
  1133. // SignalEvent( EVENT_ERROR );
  1134. SendHDLCFrame();
  1135. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1136. }
  1137. else
  1138. {
  1139. //OutputDebugString( "Error sending EOPn" );
  1140. SendHDLCFrame();
  1141. }
  1142. }
  1143. break;
  1146. case STATE_PAGE_FINISHED_SENT:
  1147. m_nPhaseState = STATE_WAIT_FOR_MCF;
  1148. EnableSoftFlowControl( false );
  1149. RecvHDLCFrame();
  1150. break;
  1152. case STATE_WAIT_FOR_MCF:
  1153. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  1154. {
  1155. if( m_bGotDCN )
  1156. {
  1157. m_sLastError.assign( (char*)LoadString(GEN_UNEXPECTED_DCN_RECEIVED).c_str() );
  1158. Terminate();
  1159. DoHangup();
  1160. }
  1161. else if( m_bFinalHDLCFrame && (m_bGotMCF || m_bGotPPR) )
  1162. {
  1163. EnableSoftFlowControl( true );
  1165. if( m_FaxFile.MorePages() == false && m_bGotPPR == false && m_FaxFile.GetPartialPage() == false )
  1166. {
  1167. m_FaxFile.IncrementPageCount();
  1168. m_bSuccessful = true;
  1169. SendHDLCFrame();
  1170. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1171. KillTimer( TIMER_MAXPAGERETRIES );
  1172. }
  1173. else
  1174. {
  1175. if( m_bGotPPR )
  1176. {
  1177. if( m_nPPRCtr > 3 )
  1178. {
  1179. m_nPPRCtr = 0;
  1180. m_nPhaseState = STATE_SEND_CTC;
  1181. DecrementSpeed();
  1182. SendHDLCFrame();
  1183. }
  1184. else
  1185. {
  1186. //OutputDebugString( "Sending bad framesn" );
  1187. m_FaxFile.ReadBadFrames( m_nClass1Speed );
  1188. // Send 75ms of silence
  1189. SendFormattedCommand( "FTS", 8 );
  1190. m_nPhaseState = STATE_SEND_SILENCE_BEFORE_PHASE_C;
  1191. }
  1192. }
  1193. else if ( m_FaxFile.GetPartialPage() )
  1194. {
  1195. // Send 75ms of silence
  1196. SendFormattedCommand( "FTS", 8 );
  1197. m_nPhaseState = STATE_SEND_SILENCE_BEFORE_PHASE_C;
  1199. //OutputDebugString( "Sending next blockn" );
  1200. m_nPPRCtr = 0;
  1201. if( m_FaxFile.ReadPage( m_bECM, m_nClass1Speed, m_wMinLineChars ) == false )
  1202. {
  1203. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  1204. // SignalEvent( EVENT_ERROR );
  1205. SendHDLCFrame();
  1206. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1207. }
  1208. }
  1209. else
  1210. {
  1211. // Send 75ms of silence
  1212. SendFormattedCommand( "FTS", 8 );
  1213. m_nPhaseState = STATE_SEND_SILENCE_BEFORE_PHASE_C;
  1215. m_nPPRCtr = 0;
  1217. if( m_FaxFile.ReadNextHeader() == false )
  1218. {
  1219. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  1220. // SignalEvent( EVENT_ERROR );
  1221. SendHDLCFrame();
  1222. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1223. }
  1224. else
  1225. {
  1226. if( m_FaxFile.ReadPage( m_bECM, m_nClass1Speed, m_wMinLineChars ) == false )
  1227. {
  1228. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  1229. // SignalEvent( EVENT_ERROR );
  1230. SendHDLCFrame();
  1231. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1232. }
  1233. }
  1234. }
  1235. }
  1236. }
  1237. else if( m_bFinalHDLCFrame && m_bGotCRP )
  1238. {
  1239. // repeat last command
  1240. m_nPhaseState = STATE_SEND_PAGE_FINISHED;
  1241. SendHDLCFrame();
  1242. }
  1243. else if( m_bFinalHDLCFrame && m_bGotRNR )
  1244. {
  1245. if( (GetTickCount() - m_dwRNRStart) > 60000 )
  1246. {
  1247. m_sLastError.assign( (char*)LoadString(GEN_T5_TIMEOUT).c_str() );
  1248. // SignalEvent( EVENT_ERROR );
  1249. SendHDLCFrame();
  1250. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1251. }
  1252. else
  1253. {
  1254. // receiver not ready
  1255. m_nPhaseState = STATE_SEND_RR;
  1256. SendHDLCFrame();
  1257. }
  1258. }
  1259. else if( m_bFinalHDLCFrame && m_bGotRTP )
  1260. {
  1261. EnableSoftFlowControl( true );
  1263. if( m_FaxFile.MorePages() == false && m_FaxFile.GetPartialPage() == false )
  1264. {
  1265. m_FaxFile.IncrementPageCount();
  1266. m_bSuccessful = true;
  1267. SendHDLCFrame();
  1268. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1269. KillTimer( TIMER_MAXPAGERETRIES );
  1270. }
  1271. else
  1272. {
  1273. if ( m_FaxFile.GetPartialPage() )
  1274. {
  1275. //OutputDebugString( "Sending next blockn" );
  1276. m_nPPRCtr = 0;
  1277. if( m_FaxFile.ReadPage( m_bECM, m_nClass1Speed, m_wMinLineChars ) == false )
  1278. {
  1279. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  1280. // SignalEvent( EVENT_ERROR );
  1281. SendHDLCFrame();
  1282. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1283. }
  1284. }
  1285. else
  1286. {
  1287. //OutputDebugString( "Sending next pagen" );
  1288. m_nPPRCtr = 0;
  1289. if( m_FaxFile.ReadNextHeader() == false )
  1290. {
  1291. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  1292. // SignalEvent( EVENT_ERROR );
  1293. SendHDLCFrame();
  1294. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1295. }
  1296. else
  1297. {
  1298. if( m_FaxFile.ReadPage( m_bECM, m_nClass1Speed, m_wMinLineChars ) == false )
  1299. {
  1300. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  1301. // SignalEvent( EVENT_ERROR );
  1302. SendHDLCFrame();
  1303. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1304. }
  1305. }
  1306. }
  1308. SendFormattedCommand( "FTS", 8 );
  1309. SetState( STATE_PHASE_B, STATE_SEND_SILENCE_BEFORE_TRAINING );
  1311. //  decrement speed and retrain
  1312. //DecrementSpeed();
  1313. //SendHDLCFrame();
  1314. //SetState( STATE_PHASE_B, STATE_SEND_DCS );
  1315. //m_bGotConnect = false;
  1316. }
  1317. }
  1318. else if( m_bFinalHDLCFrame && m_bGotRTN )
  1319. {
  1320. SendFormattedCommand( "FTS", 8 );
  1321. SetState( STATE_PHASE_B, STATE_SEND_SILENCE_BEFORE_TRAINING );
  1322. //DecrementSpeed();
  1323. //SendHDLCFrame();
  1324. //SetState( STATE_PHASE_B, STATE_SEND_DCS );
  1325. //m_bGotConnect = false;
  1326. }
  1327. else if( m_bRecvHDLCError )
  1328. {
  1329. if( ++m_nLoopCtr >= 3 )
  1330. {
  1331. m_sLastError.assign( (char*)LoadString(GEN_SENT_PPS_3_TIMES_WITHOUT_RESPONSE).c_str() );
  1332. // SignalEvent( EVENT_ERROR );
  1333. SendHDLCFrame();
  1334. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1335. }
  1336. else
  1337. {
  1338. SendHDLCFrame();
  1339. m_nPhaseState = STATE_SEND_PAGE_FINISHED;
  1340. }
  1341. }
  1342. else
  1343. {
  1344. RecvHDLCFrame();
  1345. }
  1346. }
  1347. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1348. {
  1349. m_bGotConnect = true;
  1350. // get ready for another HDLC frame
  1351. InitHDLC();
  1352. KillTimer( TIMER_HDLC_RECV );
  1353. }
  1354. else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
  1355. {
  1356. m_bRecvHDLCError = true;
  1357. }
  1358. else
  1359. {
  1360. if( ++m_nLoopCtr >= 3 )
  1361. {
  1362. m_sLastError.assign( (char*)LoadString(GEN_SENT_PPS_3_TIMES_WITHOUT_RESPONSE).c_str() );
  1363. // SignalEvent( EVENT_ERROR );
  1364. SendHDLCFrame();
  1365. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1366. }
  1367. else
  1368. {
  1369. SendHDLCFrame();
  1370. m_nPhaseState = STATE_SEND_PAGE_FINISHED;
  1371. }
  1372. }
  1373. break;
  1375. case STATE_SEND_RR:
  1376. if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1377. {
  1378. SendSimpleHDLCFrame( RR );
  1379. m_nPhaseState = STATE_PAGE_FINISHED_SENT;
  1380. m_bGotPPR = false;
  1381. m_bFinalHDLCFrame = false;
  1382. m_bGotMCF = false;
  1383. m_bGotRNR = false;
  1384. m_bGotCRP = false;
  1385. }
  1386. else 
  1387. {
  1388. SendHDLCFrame();
  1389. m_nPhaseState = STATE_SEND_PAGE_FINISHED;
  1390. }
  1391. break;
  1393. case STATE_SEND_CTC:
  1394. if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1395. {
  1396. // This is not a simple frame
  1397. SendCTC();
  1398. m_nPhaseState = STATE_CTC_SENT;
  1399. m_bGotCRP = false;
  1400. m_bFinalHDLCFrame = false;
  1401. }
  1402. else 
  1403. {
  1404. SendHDLCFrame();
  1405. m_nPhaseState = STATE_SEND_PAGE_FINISHED;
  1406. }
  1407. break;
  1409. case STATE_CTC_SENT:
  1410. m_nPhaseState = STATE_WAIT_FOR_CTR;
  1411. RecvHDLCFrame();
  1412. break;
  1414. case STATE_WAIT_FOR_CTR:
  1415. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  1416. {
  1417. if( m_bGotDCN )
  1418. {
  1419. m_sLastError.assign( (char*)LoadString(GEN_UNEXPECTED_DCN_RECEIVED).c_str() );
  1420. Terminate();
  1421. DoHangup();
  1422. }
  1423. else if( m_bGotCRP )
  1424. {
  1425. m_nPhaseState = STATE_SEND_CTC;
  1426. SendHDLCFrame();
  1427. }
  1428. else if( m_bFinalHDLCFrame )
  1429. {
  1430. //OutputDebugString( "Sending bad framesn" );
  1431. m_FaxFile.ReadBadFrames( m_nClass1Speed );
  1432. // Send 75ms of silence
  1433. SendFormattedCommand( "FTS", 8 );
  1434. m_nPhaseState = STATE_SEND_SILENCE_BEFORE_PHASE_C;
  1435. }
  1436. else if( m_bRecvHDLCError )
  1437. {
  1438. SendHDLCFrame();
  1439. m_nPhaseState = STATE_SEND_PAGE_FINISHED;
  1440. }
  1441. else
  1442. {
  1443. // ask for 
  1444. //OutputDebugString( "Waiting for CTRn" );
  1445. EnableSoftFlowControl( false );
  1446. RecvHDLCFrame();
  1447. }
  1448. }
  1449. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1450. {
  1451. m_bGotConnect = true;
  1452. // get ready for another HDLC frame
  1453. InitHDLC();
  1454. KillTimer( TIMER_HDLC_RECV );
  1455. }
  1456. else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
  1457. {
  1458. m_bRecvHDLCError = true;
  1459. }
  1460. else 
  1461. {
  1462. SendHDLCFrame();
  1463. m_nPhaseState = STATE_SEND_PAGE_FINISHED;
  1464. }
  1465. break;
  1468. case STATE_SEND_SILENCE_BEFORE_PHASE_C:
  1469. //if( stricmp( m_szLineBuff, "OK" ) != 0 )
  1470. //{
  1471. // OutputDebugString( "Error sending silencen" );
  1472. //}
  1473. SendShortTraining();
  1474. // change state
  1475. SetState( STATE_PHASE_C );
  1476. //OutputDebugString( "Going to Phase Cn" );
  1477. break;
  1479. // begin receiving states
  1481. case STATE_WAIT_FOR_EOP:
  1482. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  1483. {
  1484. if( m_bGotDCN )
  1485. {
  1486. m_sLastError.assign( (char*)LoadString(GEN_UNEXPECTED_DCN_RECEIVED).c_str() );
  1487. Terminate();
  1488. DoHangup();
  1489. }
  1490. else if( m_bFinalHDLCFrame )
  1491. {
  1492. m_nLoopCtr = 0;
  1493. SendHDLCFrame();
  1494. m_nPhaseState = STATE_SEND_MCF;
  1496. m_bSendPPR = false;
  1498. if( m_bECM )
  1499. {
  1500. if( m_FaxFile.IsECMBlockGood( m_ECMFrameCount ) )
  1501. {
  1502. m_nPPRCtr = 0;
  1503. m_FaxFile.NextECMBlock();
  1505. if( m_bGotEOP || m_bGotEOM || m_bGotMPS )
  1506. {
  1507. m_FaxFile.WriteIFD();
  1508. }
  1510. // Can't send RTN in ECM mode
  1511. m_bLastPageGood = true;
  1512. }
  1513. else
  1514. {
  1515. m_FaxFile.RedoECMBlock();
  1516. m_bSendPPR = true;
  1517. m_nPPRCtr++;
  1518. }
  1519. }
  1520. }
  1521. else
  1522. {
  1523. if( GetTickCount() - m_dwEOPWaitStart > 30000 )
  1524. {
  1525. m_sLastError.assign( (char*)LoadString(GEN_PPS_NOT_RECEIVED).c_str() );
  1526. // SignalEvent( EVENT_ERROR );
  1527. SendHDLCFrame();
  1528. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1529. }
  1530. else
  1531. {
  1532. // ask for 
  1533. //OutputDebugString( "Waiting for EOPn" );
  1534. //EnableSoftFlowControl( false );
  1535. RecvHDLCFrame();
  1536. }
  1537. }
  1538. }
  1539. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1540. {
  1541. m_bGotConnect = true;
  1542. // get ready for another HDLC frame
  1543. InitHDLC();
  1544. KillTimer( TIMER_HDLC_RECV );
  1545. }
  1546. else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
  1547. {
  1548. m_bRecvHDLCError = true;
  1549. }
  1550. else 
  1551. {
  1552. if( GetTickCount() - m_dwEOPWaitStart > 30000 )
  1553. {
  1554. m_sLastError.assign( (char*)LoadString(GEN_PPS_NOT_RECEIVED).c_str() );
  1555. // SignalEvent( EVENT_ERROR );
  1556. SendHDLCFrame();
  1557. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1558. }
  1559. else
  1560. {
  1561. //OutputDebugString( "Waiting for post-page signaln" );
  1562. RecvHDLCFrame();
  1563. }
  1564. }
  1565. break;
  1568. case STATE_SEND_MCF:
  1569. if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1570. {
  1571. SendMCF();
  1572. }
  1573. else 
  1574. {
  1575. if( ++m_nLoopCtr >= 3 )
  1576. {
  1577. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SENDING_MCF).c_str() );
  1578. // SignalEvent( EVENT_ERROR );
  1579. SendHDLCFrame();
  1580. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1581. }
  1582. else
  1583. {
  1584. //OutputDebugString( "Error sending MCFn" );
  1585. SendHDLCFrame();
  1586. }
  1587. }
  1588. break;
  1591. case STATE_MCF_SENT:
  1592. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  1593. {
  1594. if( m_bGotEOP && !m_bSendPPR )
  1595. {
  1596. m_bSuccessful = true;
  1597. //OutputDebugString( "Going to phase En" );
  1598. m_bFinalHDLCFrame = false;
  1599. RecvHDLCFrame();
  1600. SetState( STATE_PHASE_E, STATE_RECEIVE_DCN );
  1601. //SignalEvent( EVENT_END_PAGE );
  1602. }
  1603. else if( m_bGotEOM && !m_bSendPPR )
  1604. {
  1605. SendHDLCFrame();
  1606. SetState( STATE_PHASE_B, STATE_SEND_CSI );
  1607. m_nLoopCtr = 0;
  1608. //SignalEvent( EVENT_END_PAGE );
  1609. }
  1610. else if( m_bSendPPR && m_nPPRCtr > 3 )
  1611. {
  1612. //OutputDebugString( "Waiting for CTCn" );
  1613. m_bFinalHDLCFrame = false;
  1614. RecvHDLCFrame();
  1615. m_nPhaseState = STATE_WAIT_FOR_CTC;
  1616. m_bGotConnect = false;
  1617. m_bGotCTC = false;
  1618. m_bGotEOR = false;
  1619. m_bGotCRP = false;
  1620. }
  1621. else  /* default is to go back to phase C  */
  1622. {
  1623. //OutputDebugString( "Going back to phase Cn" );
  1624. RecvShortTraining();
  1625. SetState( STATE_PHASE_C );
  1626. }
  1627. }
  1628. else 
  1629. {
  1630. if( ++m_nLoopCtr >= 3 )
  1631. {
  1632. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SENDING_MCF).c_str() );
  1633. // SignalEvent( EVENT_ERROR );
  1634. SendHDLCFrame();
  1635. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1636. }
  1637. else
  1638. {
  1639. //OutputDebugString( "Error sending MCFn" );
  1640. SendHDLCFrame();
  1641. m_nPhaseState = STATE_SEND_MCF;
  1642. }
  1643. }
  1644. break;
  1647. case STATE_WAIT_FOR_CTC:
  1648. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  1649. {
  1650. if( m_bGotDCN )
  1651. {
  1652. m_sLastError.assign( (char*)LoadString(GEN_UNEXPECTED_DCN_RECEIVED).c_str() );
  1653. Terminate();
  1654. DoHangup();
  1655. }
  1656. else if( m_bGotCRP )
  1657. {
  1658. SendHDLCFrame();
  1659. m_nPhaseState = STATE_SEND_MCF;
  1660. }
  1661. else if( m_bFinalHDLCFrame && (m_bGotCTC || m_bGotEOR) )
  1662. {
  1663. m_nPPRCtr = 0;
  1664. SendHDLCFrame();
  1665. m_nPhaseState = STATE_SEND_CTR;
  1666. m_nLoopCtr = 0;
  1667. m_bGotConnect = false;
  1668. }
  1669. else
  1670. {
  1671. // ask for 
  1672. //OutputDebugString( "Waiting for CTCn" );
  1673. //EnableSoftFlowControl( false );
  1674. RecvHDLCFrame();
  1675. }
  1676. }
  1677. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1678. {
  1679. m_bGotConnect = true;
  1680. // get ready for another HDLC frame
  1681. InitHDLC();
  1682. KillTimer( TIMER_HDLC_RECV );
  1683. }
  1684. else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
  1685. {
  1686. m_bRecvHDLCError = true;
  1687. }
  1688. else 
  1689. {
  1690. //OutputDebugString( "Bad HDLC framen" );
  1691. RecvHDLCFrame();
  1692. }
  1693. break;
  1696. case STATE_SEND_CTR:
  1697. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  1698. {
  1699. if( m_bGotCTC )
  1700. {
  1701. //OutputDebugString( "Going back to phase Cn" );
  1702. RecvShortTraining();
  1703. SetState( STATE_PHASE_C );
  1704. }
  1705. else // The only alternative is EOR was received
  1706. {
  1707. m_nPPRCtr = 0;
  1708. m_FaxFile.NextECMBlock();
  1710. if( m_bGotEOP || m_bGotEOM || m_bGotMPS )
  1711. {
  1712. m_FaxFile.WriteIFD();
  1713. }
  1715. // Can't send RTN in ECM mode
  1716. m_bLastPageGood = true;
  1718. if( m_bGotEOP )
  1719. {
  1720. m_bSuccessful = true;
  1721. //OutputDebugString( "Going to phase En" );
  1722. m_bFinalHDLCFrame = false;
  1723. RecvHDLCFrame();
  1724. SetState( STATE_PHASE_E, STATE_RECEIVE_DCN );
  1725. }
  1726. else if( m_bGotEOM )
  1727. {
  1728. SendHDLCFrame();
  1729. SetState( STATE_PHASE_B, STATE_SEND_CSI );
  1730. m_nLoopCtr = 0;
  1731. }
  1732. else  /* default is to go back to phase C  */
  1733. {
  1734. //OutputDebugString( "Going back to phase Cn" );
  1735. RecvShortTraining();
  1736. SetState( STATE_PHASE_C );
  1737. }
  1738. }
  1739. }
  1740. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1741. {
  1742. m_bGotConnect = true;
  1743. SendCTR();
  1744. }
  1745. else 
  1746. {
  1747. if( ++m_nLoopCtr >= 3 )
  1748. {
  1749. m_sLastError.assign( (char*)LoadString(GEN_ERROR_SENDING_CTR).c_str() );
  1750. // SignalEvent( EVENT_ERROR );
  1751. SendHDLCFrame();
  1752. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  1753. }
  1754. else
  1755. {
  1756. //OutputDebugString( "Error sending CTRn" );
  1757. SendHDLCFrame();
  1758. }
  1759. }
  1760. break;
  1762. }
  1763. }
  1765. //////////////////////////////////////////////////////////////////////
  1766. // Phase E - Disconnect
  1767. //////////////////////////////////////////////////////////////////////
  1768. void CClassOne::PhaseE(void)
  1769. {
  1771. switch( m_nPhaseState )
  1772. {
  1773. case STATE_WAIT_FOR_OK:
  1774. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  1775. {
  1776. SendHDLCFrame();
  1777. m_nPhaseState = STATE_SEND_DCN;
  1778. }
  1779. break;
  1781. case STATE_SEND_DCN:
  1782. if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1783. {
  1784. SendDCN();
  1785. m_nPhaseState = STATE_DCN_SENT;
  1786. }
  1787. else /* if( stricmp( m_szLineBuff, "OK" ) == 0 ) */
  1788. {
  1789. Terminate();
  1790. DoHangup();
  1791. }
  1792. break;
  1794. case STATE_DCN_SENT:
  1795. Terminate();
  1796. DoHangup();
  1797. break;
  1799. case STATE_RECEIVE_DCN:
  1800. if( stricmp( m_szLineBuff, "OK" ) == 0 )
  1801. {
  1802. if( m_bGotDCN )
  1803. {
  1804. Terminate();
  1805. DoHangup();
  1806. }
  1807. else
  1808. {
  1809. // ask for 
  1810. //OutputDebugString( "Waiting for DCNn" );
  1811. //EnableSoftFlowControl( false );
  1812. //RecvHDLCFrame();
  1814. Terminate();
  1815. DoHangup();
  1816. }
  1817. }
  1818. else if( stricmp( m_szLineBuff, "CONNECT" ) == 0 )
  1819. {
  1820. m_bGotConnect = true;
  1821. // get ready for another HDLC frame
  1822. InitHDLC();
  1823. KillTimer( TIMER_HDLC_RECV );
  1824. }
  1825. else if ( m_szLineBuff[0] == DLE && m_szLineBuff[1] == ETX )
  1826. {
  1827. m_bRecvHDLCError = true;
  1828. }
  1829. else 
  1830. {
  1831. DoHangup();
  1832. Terminate();
  1833. }
  1834. break;
  1835. }
  1836. }
  1839. //////////////////////////////////////////////////////////////////////
  1840. // on DIS frame
  1841. //////////////////////////////////////////////////////////////////////
  1842. void CClassOne::OnDIS(void)
  1843. {
  1844. BOOL bSupported[MAX_CLS1SPEEDS];
  1845. int i;
  1847. m_bGotDIS = true;
  1849. for( i = 0; i < MAX_CLS1SPEEDS; i++ )
  1850. {
  1851. bSupported[i] = 0;
  1852. }
  1854. //OutputDebugString( "OnDISn" );
  1856. BYTE c1 = CFaxFile::s_FlipTable[ m_szHDLCBuff[4] ];
  1857. BYTE c2 = CFaxFile::s_FlipTable[ m_szHDLCBuff[5] ];
  1859. WORD wBitRate = (c1 & 0x3c) >> 2;
  1861. WORD wScanTime = (c2 & 0x0E) >> 1; 
  1863. m_DISParams.p.VertRes = (c1 & 0x02) >> 1;
  1865. WORD wWidth = (c2 & 0xc0) >> 6;
  1866. WORD wLength = (c2 & 0x30) >> 4;
  1867. m_b2D = (c1 & 0x01);
  1869. switch( wBitRate )
  1870. {
  1871. case DIS_V27_FALLBACK:
  1872. //OutputDebugString( "V.27 ter fallback supportedn" );
  1873. bSupported[0] = 1;
  1874. m_DISParams.p.BitRate = 0;
  1875. break;
  1877. case DIS_V27:
  1878. //OutputDebugString( "V.27 ter supportedn" );
  1879. bSupported[0] = 1;
  1880. bSupported[1] = 1;
  1881. m_DISParams.p.BitRate = 1;
  1882. break;
  1884. case DIS_V29:
  1885. //OutputDebugString( "V.29 supportedn" );
  1886. bSupported[2] = 1;
  1887. bSupported[3] = 1;
  1888. m_DISParams.p.BitRate = 3;
  1889. break;
  1891. case DIS_V27_V29:
  1892. //OutputDebugString( "V.27 ter and V.29 supportedn" );
  1893. for( i = 0; i < 4; i++ )
  1894. bSupported[i] = 1;
  1895. m_DISParams.p.BitRate = 3;
  1896. break;
  1898. case DIS_V27_V29_V33:
  1899. //OutputDebugString( "V.27 ter, V.29, and V.33 supportedn" );
  1900. for( i = 0; i < 6; i++ )
  1901. bSupported[i] = 1;
  1902. m_DISParams.p.BitRate = 5;
  1903. break;
  1905. case DIS_V27_V29_V33_V17:
  1906. //OutputDebugString( "V.27 ter, V.29, V.33, and V.17 supportedn" );
  1907. for( i = 0; i < 10; i++ )
  1908. bSupported[i] = 1;
  1909. m_DISParams.p.BitRate = 5;
  1910. break;
  1911. }
  1913. //char jbuf[256];
  1916. for( i = 9; i >= 0; i-- )
  1917. if( bSupported[i] && m_bSendSupported[i] && m_nSendBaud >= cls1Speeds[i].ndx )
  1918. break;
  1920. if( i >= 0 ) {
  1921. m_nClass1Speed = i;
  1922. }
  1923. else
  1924. {
  1925. m_nClass1Speed = 0;
  1926. }
  1928. if (!m_DISParams.p.VertRes)
  1929. {
  1930. //OutputDebugString( "Normal resolution supportedn" );
  1931. m_wScanTimeMs = Cls1ScanTimes_normal[wScanTime];
  1932. }
  1933. else
  1934. {
  1935. //OutputDebugString( "Fine resolution supportedn" );
  1936. m_wScanTimeMs = Cls1ScanTimes_fine[wScanTime];
  1937. }
  1939. switch( m_wScanTimeMs )
  1940. {
  1941. case 0:
  1942. m_DISParams.p.ScanTime = 0;
  1943. break;
  1945. case 5:
  1946. m_DISParams.p.ScanTime = 1;
  1947. break;
  1949. case 10:
  1950. m_DISParams.p.ScanTime = 3;
  1951. break;
  1953. case 20:
  1954. m_DISParams.p.ScanTime = 5;
  1955. break;
  1957. case 40:
  1958. m_DISParams.p.ScanTime = 7;
  1959. break;
  1960. }
  1962. //wsprintf( jbuf, "Minimum Scan Time: %dmsn", m_wScanTimeMs );
  1963. //OutputDebugString( jbuf );
  1965. m_DISParams.p.DataFormat = FAXAPI_ENC_CCITT_1D;
  1967. if( m_b2D )
  1968. {
  1969. //OutputDebugString( "Receiver supports 2D encodingn" );
  1970. m_DISParams.p.DataFormat = FAXAPI_ENC_CCITT_2D;
  1971. }
  1973. m_DISParams.p.PageLength = 0;
  1975. switch( wLength )
  1976. {
  1977. case 0:
  1978. //OutputDebugString( "Receiver supports A4 lengthn" );
  1979. break;
  1980. case 1:
  1981. //OutputDebugString( "Receiver supports unlimited lengthn" );
  1982. m_DISParams.p.PageLength = 2;
  1983. break;
  1984. case 2:
  1985. //OutputDebugString( "Receiver supports A4 and B4 lengthn" );
  1986. break;
  1987. case 3:
  1988. //OutputDebugString( "Invalid lengthn" );
  1989. break;
  1990. }
  1993. switch( wWidth )
  1994. {
  1995. case 0:
  1996. //OutputDebugString( "Receiver supports 1728 widthn" );
  1997. m_DISParams.p.PageWidth = 0;
  1998. break;
  1999. case 2:
  2000. //OutputDebugString( "Receiver supports 1728 or 2048 widthn" );
  2001. m_DISParams.p.PageWidth = 1;
  2002. break;
  2003. default:
  2004. //OutputDebugString( "Receiver supports 1728, 2048, or 2432 widthn" );
  2005. m_DISParams.p.PageWidth = 2;
  2006. break;
  2007. }
  2009. m_DISParams.p.ECM = 0;
  2011. m_bECM = false;
  2012. m_bT6Encoding = false;
  2014. if( (c2 & 0x01)  && // extension bit
  2015.         m_nHDLCBuffPtr > 6 )
  2016. {
  2017. BYTE c3 = CFaxFile::s_FlipTable[ m_szHDLCBuff[6] ];
  2019. //if( c3 & 0x80 )
  2020. //{
  2021. // OutputDebugString( "Receiver supports 2400bps handshakingn" );
  2022. //}
  2024. //if( c3 & 0x40 )
  2025. //{
  2026. // OutputDebugString( "Receiver supports uncompressed moden" );
  2027. //}
  2029. if( c3 & 0x20 )
  2030. {
  2031. m_bECM = true;
  2032. if( c3 & 0x10 )
  2033. {
  2034. m_FaxFile.SetECMFrameSize( 64 );
  2035. //OutputDebugString( "Receiver supports ECM w/ 64 octet framesn" );
  2036. m_DISParams.p.ECM = 1;
  2037. }
  2038. else
  2039. {
  2040. m_FaxFile.SetECMFrameSize( 256 );
  2041. //OutputDebugString( "Receiver supports ECM w/ 256 octet framesn" );
  2042. m_DISParams.p.ECM = 2;
  2043. }
  2044. }
  2046. //if( c3 & 0x08 )
  2047. //{
  2048. // OutputDebugString( "Receiver supports error limiting moden" );
  2049. //}
  2051. //if( c3 & 0x04 )
  2052. //{
  2053. // OutputDebugString( "Receiver supports G4 on PSTNn" );
  2054. //}
  2056. if( c3 & 0x02 )
  2057. {
  2058. //OutputDebugString( "Receiver supports T.6 encodingn" );
  2059. m_bT6Encoding = true;
  2060. m_DISParams.p.DataFormat = FAXAPI_ENC_CCITT_T6;
  2061. }
  2063. if( (c3 & 0x01)  && // extension bit
  2064. m_nHDLCBuffPtr > 7 )
  2065. {
  2066. BYTE c4 = CFaxFile::s_FlipTable[ m_szHDLCBuff[7] ];
  2068. // width expansion byte
  2070. if( (c4 & 0x01)  && // extension bit
  2071. m_nHDLCBuffPtr > 8 )
  2072. {
  2073. BYTE c5 = CFaxFile::s_FlipTable[ m_szHDLCBuff[8] ];
  2075. // more recent extensions
  2076. }
  2077. }
  2078. }
  2080. switch( m_FaxFile.GetSendEncoding() )
  2081. {
  2083. case (FAXAPI_ENC_CCITT_2D):
  2084. if( m_b2D )
  2085. {
  2086. m_FaxFile.SelectEncoding( m_FaxFile.GetSendEncoding() );
  2087. }
  2088. else
  2089. {
  2090. m_FaxFile.SelectEncoding( FAXAPI_ENC_CCITT_1D );
  2091. }
  2092. break;
  2094. case (FAXAPI_ENC_CCITT_T6):
  2095. if( m_b2D && m_bT6Encoding && m_bECM && m_bECMSupported )
  2096. {
  2097. m_FaxFile.SelectEncoding( m_FaxFile.GetSendEncoding() );
  2098. }
  2099. else if( m_b2D )
  2100. {
  2101. m_FaxFile.SelectEncoding( FAXAPI_ENC_CCITT_2D );
  2102. }
  2103. else
  2104. {
  2105. m_FaxFile.SelectEncoding( FAXAPI_ENC_CCITT_1D );
  2106. }
  2107. break;
  2109. default:
  2110. m_FaxFile.SelectEncoding( m_FaxFile.GetSendEncoding() );
  2111. break;
  2112. }
  2114. SignalEvent( EVENT_RECV_DIS );
  2115. }
  2118. //////////////////////////////////////////////////////////////////////
  2119. // on CSI frame
  2120. //////////////////////////////////////////////////////////////////////
  2121. void CClassOne::OnCSI(void)
  2122. {
  2123. char szCSI[21];
  2125. for( int i = 0; i < 20; i++ )
  2126. {
  2127. if( (22 - i) < m_nHDLCBuffPtr )
  2128. {
  2129. szCSI[i] = m_szHDLCBuff[ 22 - i ];
  2130. }
  2131. else
  2132. {
  2133. szCSI[i] = '';
  2134. }
  2135. }
  2136. szCSI[20] = '';
  2138. m_sRemoteCSID.assign( szCSI );
  2140. SignalEvent( EVENT_GOT_REMOTEID );
  2141. }
  2143. //////////////////////////////////////////////////////////////////////
  2144. // on CFR frame
  2145. //////////////////////////////////////////////////////////////////////
  2146. void CClassOne::OnCFR(void)
  2147. {
  2148. m_bGotCFR = true;
  2149. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_CFR).c_str() );
  2150. }
  2153. //////////////////////////////////////////////////////////////////////
  2154. // on MCF frame
  2155. //////////////////////////////////////////////////////////////////////
  2156. void CClassOne::OnMCF(void)
  2157. {
  2158. m_bGotMCF = true;
  2159. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_MCF).c_str() );
  2160. }
  2162. //////////////////////////////////////////////////////////////////////
  2163. // on RTP frame
  2164. //////////////////////////////////////////////////////////////////////
  2165. void CClassOne::OnRTP(void)
  2166. {
  2167. m_bGotRTP = true;
  2168. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_RTP).c_str() );
  2169. }
  2171. //////////////////////////////////////////////////////////////////////
  2172. // on RTN frame
  2173. //////////////////////////////////////////////////////////////////////
  2174. void CClassOne::OnRTN(void)
  2175. {
  2176. m_bGotRTN = true;
  2177. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_RTN).c_str() );
  2178. }
  2180. //////////////////////////////////////////////////////////////////////
  2181. // on Failure To Train frame
  2182. //////////////////////////////////////////////////////////////////////
  2183. void CClassOne::OnFTT(void)
  2184. {
  2185. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_FTT).c_str() );
  2186. m_bGotCFR = false;
  2187. }
  2190. //////////////////////////////////////////////////////////////////////
  2191. // on DCS
  2192. //////////////////////////////////////////////////////////////////////
  2193. void CClassOne::OnDCS(void)
  2194. {
  2195. int i;
  2197. m_bGotDCS = true;
  2199. // OutputDebugString( "OnDCSn" );
  2201. BYTE c1 = CFaxFile::s_FlipTable[ m_szHDLCBuff[4] ];
  2202. BYTE c2 = CFaxFile::s_FlipTable[ m_szHDLCBuff[5] ];
  2204. WORD wBitRate = (c1 & 0x3c) >> 2;
  2205. WORD wScanTime = (c2 & 0x0E) >> 1; 
  2206. WORD wWidth = (c2 & 0xc0) >> 6;
  2207. WORD wLength = (c2 & 0x30) >> 4;
  2209. m_DCSParams.p.VertRes = (c1 & 0x02) >> 1;
  2211. m_b2D = (c1 & 0x01);
  2213. m_nClass1Speed = 0;
  2214. m_bT6Encoding = false;
  2215. m_bECM = false;
  2217. for( i = 0; i < MAX_CLS1SPEEDS; i++ )
  2218. {
  2219. if( cls1Speeds[i].cDCSBits == wBitRate )
  2220. {
  2221. m_nClass1Speed = i;
  2222. break;
  2223. }
  2224. }
  2226. //char jbuf[256];
  2227. //wsprintf( jbuf, "Baud rate bits: %dn", wBitRate );
  2228. //OutputDebugString( jbuf );
  2229. //wsprintf( jbuf, "Selected baud rate: %dn", cls1Speeds[m_nClass1Speed].dwSpeed );
  2230. //OutputDebugString( jbuf );
  2232. m_DCSParams.p.BitRate = cls1Speeds[m_nClass1Speed].ndx;
  2234. if( m_DCSParams.p.VertRes )
  2235. {
  2236. //OutputDebugString( "Receiving fine qualityn" );
  2237. }
  2239. m_DCSParams.p.DataFormat = FAXAPI_ENC_CCITT_1D;
  2241. if( m_b2D )
  2242. {
  2243. m_DCSParams.p.DataFormat = FAXAPI_ENC_CCITT_2D;
  2244. //OutputDebugString( "Receiving 2Dn" );
  2245. }
  2247. switch( wLength )
  2248. {
  2249. case 0:
  2250. m_DCSParams.p.PageLength = 0;
  2251. break;
  2253. case 2:
  2254. m_DCSParams.p.PageLength = 1;
  2255. break;
  2257. default:
  2258. m_DCSParams.p.PageLength = 2;
  2259. break;
  2260. }
  2262. switch( wWidth )
  2263. {
  2264. case 0:
  2265. m_FaxFile.SetImageWidth( 1728 );
  2266. m_DCSParams.p.PageWidth = 0;
  2267. break;
  2269. case 1:
  2270. case 3:
  2271. m_FaxFile.SetImageWidth( 2432 );
  2272. m_DCSParams.p.PageWidth = 2;
  2273. break;
  2275. case 2:
  2276. m_FaxFile.SetImageWidth( 2048 );
  2277. m_DCSParams.p.PageWidth = 1;
  2278. break;
  2279. }
  2281. if (!m_DISParams.p.VertRes)
  2282. {
  2283. //OutputDebugString( "Normal resolution supportedn" );
  2284. m_wScanTimeMs = Cls1ScanTimes_normal[wScanTime];
  2285. }
  2286. else
  2287. {
  2288. //OutputDebugString( "Fine resolution supportedn" );
  2289. m_wScanTimeMs = Cls1ScanTimes_fine[wScanTime];
  2290. }
  2292. switch( m_wScanTimeMs )
  2293. {
  2294. case 0:
  2295. m_DCSParams.p.ScanTime = 0;
  2296. break;
  2298. case 5:
  2299. m_DCSParams.p.ScanTime = 1;
  2300. break;
  2302. case 10:
  2303. m_DCSParams.p.ScanTime = 3;
  2304. break;
  2306. case 20:
  2307. m_DCSParams.p.ScanTime = 5;
  2308. break;
  2310. case 40:
  2311. m_DCSParams.p.ScanTime = 7;
  2312. break;
  2313. }
  2315. m_DCSParams.p.ECM = 0;
  2317. if( (c2 & 0x01)  && // extension bit
  2318.         m_nHDLCBuffPtr > 6 )
  2319. {
  2320. BYTE c3 = CFaxFile::s_FlipTable[ m_szHDLCBuff[6] ];
  2322. //if( c3 & 0x80 )
  2323. //{
  2324. //OutputDebugString( "Receiving with 2400bps handshakingn" );
  2325. //}
  2327. //if( c3 & 0x40 )
  2328. //{
  2329. // OutputDebugString( "Receiving uncompressed moden" );
  2330. //}
  2332. if( c3 & 0x20 )
  2333. {
  2334. m_bECM = true;
  2335. if( c3 & 0x10 )
  2336. {
  2337. m_FaxFile.SetECMFrameSize( 64 );
  2338. //OutputDebugString( "Receiving ECM w/ 64 octet framesn" );
  2339. m_DCSParams.p.ECM = 1;
  2340. }
  2341. else
  2342. {
  2343. m_FaxFile.SetECMFrameSize( 256 );
  2344. //OutputDebugString( "Receiving ECM w/ 256 octet framesn" );
  2345. m_DCSParams.p.ECM = 2;
  2346. }
  2347. }
  2349. //if( c3 & 0x08 )
  2350. //{
  2351. // OutputDebugString( "Receiving with error limiting moden" );
  2352. //}
  2354. //if( c3 & 0x04 )
  2355. //{
  2356. // OutputDebugString( "Receiving G4 on PSTNn" );
  2357. //}
  2359. if( c3 & 0x02 )
  2360. {
  2361. //OutputDebugString( "Receiving T.6 encodingn" );
  2362. m_bT6Encoding = true;
  2363. m_DCSParams.p.DataFormat = FAXAPI_ENC_CCITT_T6;
  2364. }
  2366. if( (c3 & 0x01)  && // extension bit
  2367. m_nHDLCBuffPtr > 7 )
  2368. {
  2369. BYTE c4 = CFaxFile::s_FlipTable[ m_szHDLCBuff[7] ];
  2371. // width expansion byte
  2373. if( (c4 & 0x01)  && // extension bit
  2374. m_nHDLCBuffPtr > 8 )
  2375. {
  2376. BYTE c5 = CFaxFile::s_FlipTable[ m_szHDLCBuff[8] ];
  2378. // more recent extensions
  2379. }
  2380. }
  2381. }
  2383. m_FaxFile.SetImageRes( m_DCSParams.p.VertRes != 0 );
  2384. m_FaxFile.SetImageCompression( m_bT6Encoding ? 4 : 3 ); // Set to 4 for Group IV (T.6) encoding
  2385. m_FaxFile.SetT4Options( m_b2D ? 0x01 : 0x00 );
  2386. m_FaxFile.SetImageLength( 0 );
  2388. SignalEvent( EVENT_RECV_DCS );
  2390. }
  2394. //////////////////////////////////////////////////////////////////////
  2395. // on End of Page
  2396. //////////////////////////////////////////////////////////////////////
  2397. void CClassOne::OnEOP(void)
  2398. {
  2399. m_bGotEOP = true;
  2400. }
  2402. //////////////////////////////////////////////////////////////////////
  2403. // on End of Message
  2404. //////////////////////////////////////////////////////////////////////
  2405. void CClassOne::OnEOM(void)
  2406. {
  2407. m_bGotEOM = true;
  2408. }
  2410. //////////////////////////////////////////////////////////////////////
  2411. // on MPS
  2412. //////////////////////////////////////////////////////////////////////
  2413. void CClassOne::OnMPS(void)
  2414. {
  2415. m_bGotMPS = true;
  2416. }
  2418. //////////////////////////////////////////////////////////////////////
  2419. // on DCN
  2420. //////////////////////////////////////////////////////////////////////
  2421. void CClassOne::OnDCN(void)
  2422. {
  2423. m_bGotDCN = true;
  2424. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_DCN).c_str() );
  2425. }
  2427. //////////////////////////////////////////////////////////////////////
  2428. // on PPS
  2429. //////////////////////////////////////////////////////////////////////
  2430. void CClassOne::OnPPS(void)
  2431. {
  2432. // char szMsg[80];
  2433. // wsprintf( szMsg, "OnPPS FCF=%x, Pages=%d, Blocks=%d, Frames=%dn", 
  2434. //      m_szHDLCBuff[3], m_szHDLCBuff[4], m_szHDLCBuff[5], m_szHDLCBuff[6] );
  2435. // OutputDebugString( szMsg );
  2437. if( m_nPPRCtr == 0 )
  2438. {
  2439. m_ECMFrameCount = m_szHDLCBuff[6];
  2440. }
  2442. switch( m_szHDLCBuff[3] & 0xfe )
  2443. {
  2444. case 0: // partial page boundary
  2445. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_PPSNULL).c_str() );
  2446. break;
  2448. case EOP:
  2449. OnEOP();
  2450. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_PPSEOP).c_str() );
  2451. break;
  2453. case MPS:
  2454. OnMPS();
  2455. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_PPSMPS).c_str() );
  2456. break;
  2458. case EOM:
  2459. OnEOM();
  2460. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_PPSEOM).c_str() );
  2461. break;
  2462. }
  2464. }
  2467. //////////////////////////////////////////////////////////////////////
  2468. // on PPR
  2469. //////////////////////////////////////////////////////////////////////
  2470. void CClassOne::OnPPR(void)
  2471. {
  2472. m_bGotPPR = true;
  2474. m_nPPRCtr++;
  2476. // save the PPR FIF
  2477. memcpy( m_FaxFile.GetSeqMap(), m_szHDLCBuff + 3, SEQ_MAP_SIZE );
  2479. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_PPR).c_str() );
  2481. // make sure we have a bad frame - sometimes the receiving
  2482. // fax sends PPR with no bad bits when it should have sent MCF
  2484. int nBadFrames = 0;
  2485. int i,j;
  2486. BYTE b;
  2487. BYTE bit;
  2488. int nSeqNum = 0;
  2490. for(i = 0; i < SEQ_MAP_SIZE; i++ )
  2491. {
  2492. b = m_FaxFile.GetSeqMap()[i];
  2494. for(j = 0; j < 8; j++, b >>= 1 )
  2495. {
  2496. bit = (b & 0x01);
  2498. if( bit )
  2499. {
  2500. nBadFrames++;
  2501. }
  2503. nSeqNum++;
  2505. // Ignore any sequence numbers which we didn't transmit
  2506. if( nSeqNum > m_FaxFile.GetFrameCount() )
  2507. {
  2508. break;
  2509. }
  2510. }
  2511. if( nSeqNum > m_FaxFile.GetFrameCount() )
  2512. {
  2513. break;
  2514. }
  2515. }
  2517. if( nBadFrames == 0 )
  2518. {
  2519. m_bGotPPR = false;
  2520. m_bGotMCF = true;
  2521. }
  2523. }
  2526. //////////////////////////////////////////////////////////////////////
  2527. // on RNR - receive not ready
  2528. //////////////////////////////////////////////////////////////////////
  2529. void CClassOne::OnRNR(void)
  2530. {
  2531. m_bGotRNR = true;
  2533. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_RNR).c_str() );
  2535. if( m_dwRNRStart == 0 )
  2536. {
  2537. m_dwRNRStart = GetTickCount();
  2538. }
  2539. }
  2541. //////////////////////////////////////////////////////////////////////
  2542. // on RR - receive ready
  2543. //////////////////////////////////////////////////////////////////////
  2544. void CClassOne::OnRR(void)
  2545. {
  2546. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_RR).c_str() );
  2547. }
  2550. //////////////////////////////////////////////////////////////////////
  2551. // on CRP - command repeat
  2552. //////////////////////////////////////////////////////////////////////
  2553. void CClassOne::OnCRP(void)
  2554. {
  2555. m_bGotCRP = true;
  2556. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_CRP).c_str() );
  2557. }
  2559. //////////////////////////////////////////////////////////////////////
  2560. // on NSF - nonstandard facilities
  2561. //////////////////////////////////////////////////////////////////////
  2562. void CClassOne::OnNSF(void)
  2563. {
  2564. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_NSF).c_str() );
  2565. }
  2568. //////////////////////////////////////////////////////////////////////
  2569. // on CTC - Continue to correct
  2570. //////////////////////////////////////////////////////////////////////
  2571. void CClassOne::OnCTC(void)
  2572. {
  2573. // OutputDebugString( "OnCTCn" );
  2574. m_bGotCTC = true;
  2576. BYTE c1 = CFaxFile::s_FlipTable[ m_szHDLCBuff[4] ];
  2578. WORD wBitRate = (c1 & 0x3c) >> 2;
  2580. for( int i = 0; i < MAX_CLS1SPEEDS; i++ )
  2581. {
  2582. if( cls1Speeds[i].cDCSBits == wBitRate )
  2583. {
  2584. m_nClass1Speed = i;
  2585. break;
  2586. }
  2587. }
  2589. char jbuf[FAXAPI_MODEMMSG_INFOLEN];
  2591. wsprintf( jbuf, (char*)LoadString(GEN_RECEIVED_CTC).c_str(), cls1Speeds[m_nClass1Speed].dwSpeed );
  2592. SignalEventString( EVENT_INFO, jbuf );
  2593. }
  2595. //////////////////////////////////////////////////////////////////////
  2596. // on CTR - Continue to correct response
  2597. //////////////////////////////////////////////////////////////////////
  2598. void CClassOne::OnCTR(void)
  2599. {
  2600. m_bGotCTC = true;
  2601. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_CTR).c_str() );
  2602. }
  2604. //////////////////////////////////////////////////////////////////////
  2605. // on EOR - End of retransmission
  2606. //////////////////////////////////////////////////////////////////////
  2607. void CClassOne::OnEOR(void)
  2608. {
  2609. // OutputDebugString( "OnEORn" );
  2610. m_bGotEOR = true;
  2612. switch( m_szHDLCBuff[3] & 0xfe )
  2613. {
  2614. case 0: // partial page boundary
  2615. break;
  2617. case EOP:
  2618. OnEOP();
  2619. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_EOREOP).c_str() );
  2620. break;
  2622. case MPS:
  2623. OnMPS();
  2624. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_EORMPS).c_str() );
  2625. break;
  2627. case EOM:
  2628. OnEOM();
  2629. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_EOREOM).c_str() );
  2630. break;
  2631. }
  2633. }
  2635. //////////////////////////////////////////////////////////////////////
  2636. // on ERR - End of retransmission response
  2637. //////////////////////////////////////////////////////////////////////
  2638. void CClassOne::OnERR(void)
  2639. {
  2640. m_bGotEOR = true;
  2641. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_ERR).c_str() );
  2642. }
  2645. //////////////////////////////////////////////////////////////////////
  2646. // Handle wait timeout - do periodic processing
  2647. //////////////////////////////////////////////////////////////////////
  2648. bool CClassOne::OnWaitTimeout( void )
  2649. {
  2650. CModem::OnWaitTimeout();
  2651. /*
  2652. if( m_nState == STATE_INIT )
  2653. {
  2654. DWORD dwElapsed = GetTickCount() - m_nLastCommandTickCount;
  2656. // In case the modem doesn't respond with an OK
  2657. if( dwElapsed > 1000 )
  2658. {
  2659. if( m_nLastCommand == COMMAND_QUERY_SEND_SPEEDS )
  2660. {
  2661. SendCommand( COMMAND_QUERY_RECEIVE_SPEEDS );
  2662. }
  2663. else if( m_nLastCommand == COMMAND_QUERY_RECEIVE_SPEEDS )
  2664. {
  2665. SetState( STATE_IDLE );
  2666. }
  2667. }
  2669. if( dwElapsed > 4000 )
  2670. {
  2671. char szMsg[256];
  2672. wsprintf( szMsg, "Timeout: %d ms waiting for responsen", dwElapsed );
  2673. //OutputDebugString( szMsg );
  2675. OnDisconnectMsg();
  2676. }
  2677. }
  2678. */
  2679. return false;
  2680. }
  2683. void CClassOne::OnPartialHDLCFrame(void)
  2684. {
  2685. if( m_nState == STATE_PHASE_C && m_bReceiving )
  2686. {
  2687. if( m_bECM )
  2688. {
  2689. m_FaxFile.WriteECMBuffer( m_szHDLCBuff, m_nHDLCBuffPtr );
  2690. }
  2691. else
  2692. {
  2693. m_FaxFile.WriteBuffer( m_szHDLCBuff, m_nHDLCBuffPtr );
  2694. }
  2695. }
  2696. else
  2697. {
  2698. //OutputDebugString( "HDLC buffer overflow!n" );
  2699. }
  2700. }
  2703. void CClassOne::OnHDLCFrame(void)
  2704. {
  2705. // char szDigit[16];
  2706. // OutputDebugString( "CClassOne::OnHDLCFramen" );
  2708. if( m_nHDLCBuffPtr == 0 )
  2709. {
  2710. //OutputDebugString( "Empty HDLC Framen" );
  2711. m_bRecvHDLCError = true;
  2712. return;
  2713. }
  2715. // int i;
  2716. // for( i = 0; i < m_nHDLCBuffPtr; i++ )
  2717. // {
  2718. // wsprintf( szDigit, "%02.2x ", m_szHDLCBuff[i] );
  2719. // OutputDebugString( szDigit );
  2720. // }
  2721. // OutputDebugString( "n" );
  2724. if( m_nState == STATE_PHASE_C && m_bReceiving )
  2725. {
  2726. if( m_bECM )
  2727. {
  2728. m_FaxFile.WriteECMBuffer( m_szHDLCBuff, m_nHDLCBuffPtr );
  2729. }
  2730. else
  2731. {
  2732. m_FaxFile.WriteBuffer( m_szHDLCBuff, m_nHDLCBuffPtr );
  2733. }
  2734. }
  2735. else if( m_nPhaseState == STATE_RECEIVE_TRAINING )
  2736. {
  2737. int i;
  2738. bool bStart = false;
  2739. int nZeros = 0;
  2741. for( i = 0; i < m_nHDLCBuffPtr; i++ )
  2742. {
  2743. if( bStart == false )
  2744. {
  2745. if( m_szHDLCBuff[i] == 0 ) 
  2746. {
  2747. bStart = true;
  2748. nZeros = 1;
  2749. }
  2750. }
  2751. else
  2752. {
  2753. if( m_szHDLCBuff[i] == 0 ) 
  2754. {
  2755. nZeros++;
  2756. }
  2757. }
  2758. }
  2760. int nBytesExpected = (int)(((float)(cls1Speeds[m_nClass1Speed].dwSpeed / 8)) * 1.5) + 2;
  2762. m_nCorrect = (int)(100 * nZeros / nBytesExpected);
  2764. //char szMsg[180];
  2765. //wsprintf( szMsg, "Zeros: %d, Correct=%d%%, Total=%d, Expected=%dn", nZeros, m_nCorrect, m_nHDLCBuffPtr, nBytesExpected );
  2766. //OutputDebugString( szMsg );
  2767. }
  2768. else
  2769. {
  2771. if( (unsigned char)m_szHDLCBuff[0] != 0xff )
  2772. {
  2773. bool bFoundFrame = false;
  2775. for( int i = 1; i < m_nHDLCBuffPtr; i++ )
  2776. {
  2777. if( (unsigned char)m_szHDLCBuff[i] == 0xff )
  2778. {
  2779. memmove( m_szHDLCBuff, m_szHDLCBuff + i, m_nHDLCBuffPtr - i );
  2780. bFoundFrame = true;
  2781. }
  2782. }
  2784. if( bFoundFrame == false )
  2785. return;
  2786. }
  2788. if( m_szHDLCBuff[1] & 0x10 )
  2789. {
  2790. /// final frame
  2791. //OutputDebugString( "Final Framen" );
  2792. m_bFinalHDLCFrame = true;
  2793. }
  2795. switch( (m_szHDLCBuff[2] & 0xfe) )  // set LSB to zero
  2796. {
  2797. case DIS:
  2798. OnDIS();
  2799. break;
  2801. case CSI:
  2802. case TSI:
  2803. OnCSI();
  2804. break;
  2806. case CFR:
  2807. OnCFR();
  2808. break;
  2810. case MCF:
  2811. OnMCF();
  2812. break;
  2814. case RTP:
  2815. OnRTP();
  2816. break;
  2818. case RTN:
  2819. OnRTN();
  2820. break;
  2822. case FTT:
  2823. OnFTT();
  2824. break;
  2826. case DCS:
  2827. OnDCS();
  2828. break;
  2830. case EOP:
  2831. OnEOP();
  2832. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_EOP).c_str() );
  2833. break;
  2835. case EOM:
  2836. OnEOM();
  2837. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_EOM).c_str() );
  2838. break;
  2840. case MPS:
  2841. OnMPS();
  2842. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_RECEIVED_MPS).c_str() );
  2843. break;
  2845. case DCN:
  2846. OnDCN();
  2847. break;
  2849. case PPS:
  2850. OnPPS();
  2851. break;
  2853. case PPR:
  2854. OnPPR();
  2855. break;
  2857. case RR:
  2858. OnRR();
  2859. break;
  2861. case RNR:
  2862. OnRNR();
  2863. break;
  2865. case CRP:
  2866. OnCRP();
  2867. break;
  2869. case NSF:
  2870. OnNSF();
  2871. break;
  2873. case CTC:
  2874. OnCTC();
  2875. break;
  2877. case CTR:
  2878. OnCTR();
  2879. break;
  2881. case EOR:
  2882. OnEOR();
  2883. break;
  2885. case ERR:
  2886. OnERR();
  2887. break;
  2890. default:
  2891. {
  2892. //char szMsg[256];
  2893. //wsprintf( szMsg, "Unknown FCF: %dn", m_szHDLCBuff[2] );
  2894. //OutputDebugString( szMsg );
  2895. }
  2896. }
  2897. }
  2898. }
  2901. //////////////////////////////////////////////////////////////////////
  2902. // OnSendFaxMsg
  2903. //////////////////////////////////////////////////////////////////////
  2904. void CClassOne::OnSendFaxMsg(MSG* pMsg)
  2905. {
  2906. CModem::OnSendFaxMsg( pMsg );
  2908. if( !m_bConnected )
  2909. {
  2910. // Error!
  2911. return;
  2912. }
  2914. if( m_nState != STATE_IDLE )
  2915. {
  2916. // Error!
  2917. return;
  2918. }
  2920. m_FaxFile.SetSendEncoding( m_nSendEncoding );
  2922. int nRet = m_FaxFile.ReadFirstHeader();
  2924. if( nRet == 1 )
  2925. {
  2926. //OutputDebugString( "Error reading first headern" );
  2927. m_sLastError.assign( (char*)LoadString(GEN_ERROR_READING_TIFF_FILE).c_str() );
  2928. // SignalEvent( EVENT_ERROR );
  2929. SignalEvent( EVENT_TERMINATE );
  2930. SignalEvent( EVENT_IDLE );
  2931. return;
  2932. }
  2933. else if( nRet == 2 )
  2934. {
  2935. //OutputDebugString( "Error reading first headern" );
  2936. m_sLastError.assign( (char*)LoadString(GEN_ERROR_INCOMPAT_TIFF_FILE).c_str() );
  2937. // SignalEvent( EVENT_ERROR );
  2938. SignalEvent( EVENT_TERMINATE );
  2939. SignalEvent( EVENT_IDLE );
  2940. return;
  2941. }
  2943. m_dwRNRStart = 0;
  2944. m_bReceiving = false;
  2945. m_bHDLCMode = false;
  2946. m_bSuccessful = false;
  2947. SetState( STATE_PHASE_A );
  2949. EnableSoftFlowControl( false );
  2951. SendCommand( COMMAND_DIAL );
  2952. }
  2955. void CClassOne::OnRecvFaxMsg(MSG* pMsg)
  2956. {
  2957. CModem::OnRecvFaxMsg( pMsg );
  2959. if( m_nState == STATE_IDLE || m_nState == STATE_RINGING )
  2960. {
  2961. m_FaxFile.Clear();
  2963. m_FaxFile.SetSendEncoding( m_nSendEncoding );
  2965. m_bReceiving = true;
  2966. m_bSuccessful = false;
  2967. SendCommand( COMMAND_ANSWER );
  2968. SetState( STATE_PHASE_A );
  2969. }
  2970. }
  2973. void CClassOne::SendID(unsigned char octet)
  2974. {
  2975. // OutputDebugString( "SendIDn" );
  2977. HDLCFrameStart();
  2978. HDLCFrameAddByte( 0x03 ); // not final frame
  2979. HDLCFrameAddByte( GetFCF(octet) ); // TSI
  2981. for( int i = 20; i > 0; i-- )
  2982. {
  2983. HDLCFrameAddByte( (i > m_sLocalCSID.size() ) ? SPACE : m_sLocalCSID.at(i-1) );
  2984. }
  2986. HDLCFrameWrite();
  2988. string sMsg;
  2990. if( octet == TSI )
  2991. {
  2992. sMsg.assign( (char*)LoadString(GEN_SENT_TSI).c_str() );
  2993. }
  2994. else
  2995. {
  2996. sMsg.assign( (char*)LoadString(GEN_SENT_CSI).c_str() );
  2997. }
  2999. sMsg.append( m_sLocalCSID );
  3000. SignalEventString( EVENT_INFO, sMsg.c_str() );
  3001. }
  3004. void CClassOne::SendDCS(void)
  3005. {
  3006. // OutputDebugString( "SendDCSn" );
  3008. HDLCFrameStart();
  3009. HDLCFrameAddByte( 0x13 ); // final frame
  3010. HDLCFrameAddByte( GetFCF(DCS) ); // DCS
  3011. HDLCFrameAddByte( 0x00 ); // 
  3013. WORD c1 = 0x40;
  3014. WORD c2 = 0;
  3015. WORD c3 = 0;
  3017. // Set Speed
  3018. c1 |= cls1Speeds[m_nClass1Speed].cDCSBits << 2;
  3020. m_DCSParams.p.BitRate = cls1Speeds[m_nClass1Speed].ndx;
  3021. m_DCSParams.p.BFT = 0;
  3023. m_wMinLineChars = ((cls1Speeds[m_nClass1Speed].dwSpeed/8) * m_wScanTimeMs)/1000;
  3025. //char jbuf[256];
  3026. //wsprintf(jbuf, "Min Chars/Line: %dn", m_wMinLineChars );
  3027. //OutputDebugString( jbuf );
  3028. //wsprintf( jbuf, "Selected baud rate: %dn", cls1Speeds[m_nClass1Speed].dwSpeed );
  3029. //OutputDebugString( jbuf );
  3031. // Set Resolution
  3032. if( m_FaxFile.IsHiRes() && m_DISParams.p.VertRes ) // If High Res set 7/7mm bit
  3033. {
  3034. c1 |= 0x02;
  3035. m_DCSParams.p.VertRes = 1;
  3036. }
  3037. else
  3038. {
  3039. m_DCSParams.p.VertRes = 0; // low res
  3040. }
  3042. switch( m_wScanTimeMs )
  3043. {
  3044. case 0:
  3045. c2 |= 0x0E;
  3046. m_DCSParams.p.ScanTime = 0;
  3047. break;
  3049. case 5:
  3050. c2 |= 0x02;
  3051. m_DCSParams.p.ScanTime = 1;
  3052. break;
  3054. case 10:
  3055. c2 |= 0x04;
  3056. m_DCSParams.p.ScanTime = 3;
  3057. break;
  3059. case 20:
  3060. //c2 |= 0x00;
  3061. m_DCSParams.p.ScanTime = 5;
  3062. break;
  3064. case 40:
  3065. c2 |= 0x08;
  3066. m_DCSParams.p.ScanTime = 7;
  3067. break;
  3068. }
  3070. if( m_FaxFile.GetSendEncoding() > FAXAPI_ENC_CCITT_1D )
  3071. {
  3072. //OutputDebugString( "Sending 2Dn" );
  3073. c1 |= 0x01; // Set the 2D bit
  3074. }
  3076. // default is A4 (0x00), but set unlimited if found in DIS
  3077. if( m_DISParams.p.PageLength == 2 )
  3078. {
  3079. c2 |= 0x10;
  3080. m_DCSParams.p.PageLength = 2;
  3081. }
  3082. else
  3083. {
  3084. m_DCSParams.p.PageLength = 0;
  3085. }
  3087. // default is 1728 width (0x00)
  3088. m_DCSParams.p.PageWidth = 0;
  3090. c2 |= 0x01;  // set the extend bit
  3092. if( m_FaxFile.GetSendEncoding() == FAXAPI_ENC_CCITT_T6 )
  3093. {
  3094. c3 |= 0x02; // Set T.6 encoding
  3095. }
  3097. // Use ECM?
  3098. if( m_bECM && m_bECMSupported )
  3099. {
  3100. c3 |= 0x20;  // set the ECM bit
  3102. if( m_FaxFile.GetECMFrameSize() == 64 )
  3103. {
  3104. c3 |= 0x10; // 64 octet frames
  3105. m_DCSParams.p.ECM = 1;
  3106. }
  3107. else
  3108. {
  3109. m_DCSParams.p.ECM = 2;
  3110. }
  3111. }
  3112. else
  3113. {
  3114. m_bECM = false;
  3115. m_DCSParams.p.ECM = 0;
  3116. }
  3118. m_DCSParams.p.DataFormat = m_FaxFile.GetSendEncoding();
  3120. HDLCFrameAddByte( CFaxFile::s_FlipTable[ c1 ] );
  3121. HDLCFrameAddByte( CFaxFile::s_FlipTable[ c2 ] );
  3122. HDLCFrameAddByte( CFaxFile::s_FlipTable[ c3 ] );
  3123. HDLCFrameWrite();
  3125. SignalEvent( EVENT_SENT_DCS );
  3126. }
  3129. void CClassOne::SendTraining(void)
  3130. {
  3131. unsigned int nBytesToSend;
  3133. // OutputDebugString( "SendTrainingn" );
  3135. nBytesToSend = (int)(((float)(cls1Speeds[m_nClass1Speed].dwSpeed / 8)) * 1.5);
  3137. HDLCFrameStart();
  3139. for( int i = 0; i < nBytesToSend; i++ )
  3140. {
  3141. HDLCFrameAddByte( 0 );
  3142. }
  3144. HDLCFrameWrite();
  3147. //char szMsg[180];
  3148. //wsprintf( szMsg, "Zeros: %dn", nBytesToSend );
  3149. //OutputDebugString( szMsg );
  3150. }
  3153. void CClassOne::SendEOP(void)
  3154. {
  3155. if( m_bECM )
  3156. {
  3157. if( m_FaxFile.GetPartialPage() )
  3158. {
  3159. SendPPSHDLCFrame( 0 );
  3160. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_PPSNULL).c_str() );
  3161. }
  3162. else
  3163. {
  3164. if( m_FaxFile.MorePages() == false )
  3165. {
  3166. SendPPSHDLCFrame( EOP );
  3167. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_PPSEOP).c_str() );
  3168. }
  3169. else
  3170. {
  3171. SendPPSHDLCFrame( MPS );
  3172. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_PPSMPS).c_str() );
  3173. }
  3174. }
  3175. }
  3176. else
  3177. {
  3178. if( m_FaxFile.MorePages() == false )
  3179. {
  3180. SendSimpleHDLCFrame( EOP );
  3181. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_EOP).c_str() );
  3182. }
  3183. else
  3184. {
  3185. SendSimpleHDLCFrame( MPS );
  3186. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_MPS).c_str() );
  3187. }
  3188. }
  3189. }
  3191. void CClassOne::SendDCN(void)
  3192. {
  3193. SendSimpleHDLCFrame( DCN );
  3195. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_DCN).c_str() );
  3196. }
  3199. void CClassOne::SendDIS(void)
  3200. {
  3201. HDLCFrameStart();
  3202. HDLCFrameAddByte( 0x13 ); // final frame
  3203. HDLCFrameAddByte( GetFCF(DIS) ); // DIS
  3204. HDLCFrameAddByte( 0x00 ); // not used in Group 3
  3206. WORD c1 = 0x40; // can receive group 3  TODO: polling
  3207. WORD c2 = 0x01; // extend bit
  3208. WORD c3 = 0x00; // 
  3210. if( m_bRecvSupported[9] && m_nRecvBaud >= 5 )
  3211. {
  3212. c1 |= (DIS_V27_V29_V33_V17 << 2);
  3213. m_DISParams.p.BitRate = 5;
  3214. }
  3215. else if( m_bRecvSupported[8] && m_nRecvBaud >= 4 )
  3216. {
  3217. c1 |= (DIS_V27_V29_V33 << 2);
  3218. m_DISParams.p.BitRate = 4;
  3219. }
  3220. else if( m_bRecvSupported[3] && m_bRecvSupported[2] && m_bRecvSupported[1] && m_bRecvSupported[0] && m_nRecvBaud >= 3 )
  3221. {
  3222. c1 |= (DIS_V27_V29 << 2);
  3223. m_DISParams.p.BitRate = 3;
  3224. }
  3225. else if( m_bRecvSupported[3] && m_bRecvSupported[2] && m_nRecvBaud >= 2 )
  3226. {
  3227. c1 |= (DIS_V29 << 2);
  3228. m_DISParams.p.BitRate = 2;
  3229. }
  3230. else if( m_bRecvSupported[1] && m_nRecvBaud >= 1 )
  3231. {
  3232. c1 |= (DIS_V27 << 2);
  3233. m_DISParams.p.BitRate = 1;
  3234. }
  3235. else 
  3236. {
  3237. c1 |= (DIS_V27_FALLBACK << 2);
  3238. m_DISParams.p.BitRate = 0;
  3239. }
  3241. // Unlimited length and 1728 width
  3242. m_DISParams.p.PageWidth = 0;
  3243. m_DISParams.p.PageLength = 2;
  3245. // 1728 width is default
  3247. c2 |= 0x10; // unlimited length
  3249. c2 |= 0x0E; // 0 ms scan time
  3250. m_DISParams.p.ScanTime = 0;
  3252. c1 |= 0x02; // support hi res
  3253. m_DISParams.p.VertRes = 1;
  3255. if( m_nSendEncoding > FAXAPI_ENC_CCITT_1D )
  3256. {
  3257. c1 |= 0x01;         // support 2D coding
  3258. }
  3260. if( m_bECMSupported )
  3261. {
  3262. c3 |= 0x20; // support 256 octet ECM
  3263. }
  3265. //c3 |= 0x30; // support 64 octet ECM
  3267. if( m_nSendEncoding == FAXAPI_ENC_CCITT_T6 )
  3268. {
  3269. c3 |= 0x02; // support T.6 encoding
  3270. }
  3272. m_DISParams.p.ECM = m_bECMSupported ? 2 : 0;
  3273. m_DISParams.p.DataFormat = m_nSendEncoding;
  3275. HDLCFrameAddByte( CFaxFile::s_FlipTable[ c1 ] );
  3276. HDLCFrameAddByte( CFaxFile::s_FlipTable[ c2 ] );
  3277. HDLCFrameAddByte( CFaxFile::s_FlipTable[ c3 ] );
  3278. HDLCFrameWrite();
  3280. SignalEvent( EVENT_SENT_DIS );
  3281. }
  3284. void CClassOne::SendCFR(void)
  3285. {
  3286. // OutputDebugString( "SendCFRn" );
  3287. SendSimpleHDLCFrame( CFR );
  3288. }
  3290. void CClassOne::SendFTT(void)
  3291. {
  3292. // OutputDebugString( "SendFTTn" );
  3293. SendSimpleHDLCFrame( FTT );
  3294. }
  3296. void CClassOne::SendMCF(void)
  3297. {
  3298. if( m_bSendPPR )
  3299. {
  3300. SendPPR();
  3301. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_PPR).c_str() );
  3302. m_nPhaseState = STATE_MCF_SENT;
  3303. }
  3304. else
  3305. {
  3306. if( m_bLastPageGood )
  3307. {
  3308. SendSimpleHDLCFrame( MCF );
  3309. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_MCF).c_str() );
  3310. m_nPhaseState = STATE_MCF_SENT;
  3311. }
  3312. else
  3313. {
  3314. SendSimpleHDLCFrame( RTN );
  3315. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_RTN).c_str() );
  3316. SetState( STATE_PHASE_B, STATE_RECEIVE_TRAINING_DATA );
  3317. m_dwTrainingStart = GetTickCount();
  3318. SetTimer( TIMER_TRAINING, 4000 );
  3319. RecvLongTraining();
  3320. m_nCorrect = 0;
  3321. m_nHDLCBuffPtr = 0;
  3322. }
  3323. }
  3324. }
  3326. void CClassOne::SendPPR(void)
  3327. {
  3329. // OutputDebugString( "SendPPRn" );
  3331. HDLCFrameStart();
  3332. HDLCFrameAddByte( 0x13 ); // final frame
  3333. HDLCFrameAddByte( GetFCF(PPR) );
  3334. for( int i = 0; i < SEQ_MAP_SIZE; i++ )
  3335. {
  3336. HDLCFrameAddByte( m_FaxFile.GetSeqMap()[i] );
  3337. }
  3338. HDLCFrameWrite();
  3339. }
  3341. void CClassOne::SendCTR(void)
  3342. {
  3343. SendSimpleHDLCFrame( m_bGotCTC ? CTR : ERR );
  3345. SignalEventString( EVENT_INFO, m_bGotCTC ? (char*)LoadString(GEN_SENT_CTR).c_str() : (char*)LoadString(GEN_SENT_ERR).c_str() );
  3346. }
  3348. void CClassOne::SendCTC(void)
  3349. {
  3351. WORD c1 = 0x40;
  3353. // Set Speed
  3354. c1 |= cls1Speeds[m_nClass1Speed].cDCSBits << 2;
  3356. HDLCFrameStart();
  3357. HDLCFrameAddByte( 0x13 ); // final frame
  3358. HDLCFrameAddByte( GetFCF(CTC) );
  3359. HDLCFrameAddByte( 0x00 ); // not used in Group 3
  3360. HDLCFrameAddByte( CFaxFile::s_FlipTable[ c1 ] ); // 
  3361. HDLCFrameWrite();
  3363. SignalEventString( EVENT_INFO, (char*)LoadString(GEN_SENT_CTC).c_str() );
  3364. }
  3367. void CClassOne::SendSimpleHDLCFrame( unsigned char nFCF )
  3368. {
  3369. HDLCFrameStart();
  3370. HDLCFrameAddByte( 0x13 ); // final frame
  3371. HDLCFrameAddByte( GetFCF(nFCF) );
  3372. HDLCFrameWrite();
  3373. }
  3375. void CClassOne::SendPPSHDLCFrame( unsigned char nFCF )
  3376. {
  3377. HDLCFrameStart();
  3378. HDLCFrameAddByte( 0x13 ); // final frame
  3379. HDLCFrameAddByte( GetFCF(PPS) );
  3380. HDLCFrameAddByte( (nFCF == 0) ? 0 : GetFCF(nFCF) );
  3381. HDLCFrameAddByte( m_FaxFile.GetPageCount() ); // page count
  3382. HDLCFrameAddByte( m_FaxFile.GetBlockCount() ); // block count
  3383. HDLCFrameAddByte( m_FaxFile.GetFrameCount() ); // frame count
  3384. HDLCFrameWrite();
  3385. }
  3389. void CClassOne::SendFormattedCommand( char* szCMD, int nParam )
  3390. {
  3391. char szBuf[32];
  3392. wsprintf( szBuf, "AT+%s=%d", szCMD, nParam );
  3393. DoWrite( szBuf, strlen(szBuf), true );
  3395. //char szWorkBuffer[100];
  3396. //wsprintf( szWorkBuffer, "Sent Command: %sn", szBuf );
  3397. //OutputDebugString( szWorkBuffer );
  3398. }
  3401. void CClassOne::SetState( int nNewState, int nNewPhaseState )
  3402. {
  3403. /*
  3404. bool bSignalIt = false;
  3406. if( m_nState != nNewState )
  3407. {
  3408. bSignalIt = true;
  3409. }
  3410. */
  3412. m_nState = nNewState;
  3413. m_nPhaseState = nNewPhaseState;
  3415. if( nNewState == STATE_IDLE )
  3416. {
  3417. SignalEvent( EVENT_IDLE );
  3418. }
  3419. }
  3422. void CClassOne::DecrementSpeed( void )
  3423. {
  3424. int i;
  3425. long dwCurSpeed;
  3427. i = m_nClass1Speed - 1;
  3429. if( i < 0 )
  3430. return;
  3432. dwCurSpeed = cls1Speeds[m_nClass1Speed].dwSpeed;
  3434. while( i > 0 && cls1Speeds[i].dwSpeed >= dwCurSpeed )
  3435. i--;
  3437. m_nClass1Speed = i;
  3438. }
  3442. void CClassOne::HDLCFrameStart(void)
  3443. { 
  3444. m_szHDLCBuff[0] = 0xff; // address octet
  3445. m_nHDLCBuffPtr = 1; 
  3446. };
  3448. void CClassOne::HDLCFrameAddByte( unsigned char nOctet )
  3449. { 
  3450. m_szHDLCBuff[m_nHDLCBuffPtr++] = nOctet;
  3451. if( nOctet == DLE ) 
  3452. {
  3453. m_szHDLCBuff[m_nHDLCBuffPtr++] = nOctet;
  3454. } 
  3455. }
  3457. void CClassOne::HDLCFrameWrite(void)
  3458. {
  3459. m_szHDLCBuff[m_nHDLCBuffPtr++] = DLE;
  3460. m_szHDLCBuff[m_nHDLCBuffPtr++] = ETX;
  3462. DoWrite( (char*)m_szHDLCBuff, m_nHDLCBuffPtr, false );
  3463. }
  3466. void CClassOne::Abort( bool bUserCancelled )
  3467. {
  3468. char endofframe[2] = { DLE, ETX };
  3469. char byteCancel = CAN;
  3471. if( bUserCancelled ) 
  3472. {
  3473. m_sLastError.assign( (char*)LoadString(GEN_FAX_CANCELLED).c_str() );
  3474. }
  3476. Terminate();
  3478. m_bHDLCMode = false;
  3480. switch( m_nState )
  3481. {
  3482. case STATE_PHASE_A:
  3483. DoWrite( &byteCancel, 1, false );
  3484. m_nState = STATE_DISCONNECT;
  3485. break;
  3487. case STATE_PHASE_B:
  3488. switch( m_nPhaseState )
  3489. {
  3490. case STATE_WAIT_FOR_DIS:
  3491. case STATE_WAIT_FOR_CFR:
  3492. case STATE_WAIT_FOR_DCS:
  3493. case STATE_SENT_FTT_WAIT_FOR_DCS:
  3494. case STATE_RECEIVE_TRAINING_DATA:
  3495. if( m_bGotConnect == false )
  3496. {
  3497. DoWrite( &byteCancel, 1, false );
  3498. }
  3499. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  3500. break;
  3502. case STATE_SEND_DCS:
  3503. if( m_bGotConnect == false )
  3504. {
  3505. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  3506. }
  3507. else
  3508. {
  3509. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  3510. }
  3511. break;
  3513. case STATE_SEND_TIS:
  3514. case STATE_SEND_CSI:
  3515. case STATE_SEND_DIS:
  3516. case STATE_SEND_CFR:
  3517. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  3518. break;
  3520. case STATE_SEND_TRAINING_DATA:
  3521. DoWrite( endofframe, 2, false );
  3522. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  3523. break;
  3525.     case STATE_SENT_FTT:
  3526. case STATE_DIS_SENT:
  3527. case STATE_SEND_SILENCE_BEFORE_DATA:
  3528. case STATE_SEND_TRAINING:
  3529. case STATE_RECEIVE_TRAINING:
  3530. case STATE_SEND_RECV_DATA:
  3531. case STATE_SEND_SILENCE_BEFORE_TRAINING:
  3532. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  3533. break;
  3535. }
  3536. break;
  3538. case STATE_PHASE_C:
  3539. if ( m_bReceiving )
  3540. {
  3541. DoWrite( &byteCancel, 1, false );
  3542. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  3543. m_bHDLCMode = false;
  3544. }
  3545. else
  3546. {
  3547. DoWrite( endofframe, 2, false );
  3548. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  3549. }
  3550. break;
  3552.   case STATE_PHASE_D:
  3553. switch( m_nPhaseState )
  3554. {
  3555. case STATE_SEND_PAGE_FINISHED:
  3556. case STATE_SEND_RR:
  3557. case STATE_SEND_CTC:
  3558. case STATE_SEND_MCF:
  3559. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  3560. break;
  3562. case STATE_SEND_CTR:
  3563. if( m_bGotConnect == false )
  3564. {
  3565. SetState( STATE_PHASE_E, STATE_SEND_DCN );
  3566. }
  3567. else
  3568. {
  3569. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  3570. }
  3571. break;
  3573. case STATE_WAIT_FOR_CTC:
  3574. case STATE_WAIT_FOR_MCF:
  3575. case STATE_WAIT_FOR_CTR:
  3576. case STATE_WAIT_FOR_EOP:
  3577. if( m_bGotConnect == false )
  3578. {
  3579. DoWrite( &byteCancel, 1, false );
  3580. }
  3581. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  3582. break;
  3584. case STATE_MCF_SENT:
  3585. case STATE_SEND_SILENCE_BEFORE_PAGE_FINISHED:
  3586. case STATE_PAGE_FINISHED_SENT:
  3587. case STATE_SEND_SILENCE_BEFORE_PHASE_C:
  3588. case STATE_CTC_SENT:
  3589. SetState( STATE_PHASE_E, STATE_WAIT_FOR_OK );
  3590. break;
  3591. }
  3592. break;
  3594.     //case STATE_PHASE_E:
  3595. // break;
  3596. }
  3597. }
  3600. void CClassOne::OnTimer( UINT nID )
  3601. {
  3602. //OutputDebugString( "CClassOne::OnTimern" );
  3604. if( (nID == TIMER_COMMAND) && (m_nState == STATE_INIT) )
  3605. {
  3606. switch( m_nLastCommand )
  3607. {
  3608. case COMMAND_QUERY_SEND_SPEEDS:
  3609. SendCommand( COMMAND_QUERY_RECEIVE_SPEEDS );
  3610. break;
  3612. case COMMAND_QUERY_RECEIVE_SPEEDS:
  3613. SetState( STATE_IDLE );
  3614. KillTimer( TIMER_COMMAND );
  3615. break;
  3617. case COMMAND_HANGUP:
  3618. m_nState= STATE_IDLE;
  3619. SignalEvent( EVENT_IDLE );
  3620. m_nLoopCtr = 0; 
  3621. break;
  3623. default:
  3624. if( m_bGotOK )
  3625. {
  3626. m_nLoopCtr = 0;
  3627. KillTimer( TIMER_COMMAND );
  3628. SendCommand( COMMAND_SETUP_STRING );
  3629. }
  3630. else
  3631. {
  3632. if( ++m_nLoopCtr >= 3 )
  3633. {
  3634. KillTimer( TIMER_COMMAND );
  3635. m_sLastError.assign( (char*)LoadString(GEN_NO_RESPONSE_FROM_MODEM).c_str() );
  3636. // SignalEvent( EVENT_ERROR );
  3637. OnDisconnectMsg();
  3638. }
  3639. else
  3640. {
  3641. SendCommand( m_nLastCommand, (char*) m_LastCommandString.c_str() );
  3642. }
  3643. }
  3644. break;
  3645. }
  3646. }
  3647. else if( nID == TIMER_HDLC_RECV )
  3648. {
  3649. KillTimer( TIMER_HDLC_RECV );
  3650. char byteCancel = CAN;
  3651. DoWrite( &byteCancel, 1, false );
  3652. m_bRecvHDLCError = true;
  3653. }
  3654. else if( nID == TIMER_TRAINING )
  3655. {
  3656. KillTimer( TIMER_TRAINING );
  3657. char byteCancel = CAN;
  3658. DoWrite( &byteCancel, 1, false );
  3659. m_bRecvHDLCError = true;
  3660. m_bHDLCMode = false;
  3661. }
  3662. else if ( nID == TIMER_MAXPAGERETRIES )
  3663. {
  3664. m_sLastError.assign( "Max page retry timer expired" );
  3665. // SignalEvent( EVENT_ERROR );
  3666. Abort( false );
  3667. m_dwActivityTimer = GetTickCount();
  3668. }
  3669. }
  3672. void CClassOne::RecvHDLCFrame(void)
  3673. { 
  3674. SendFormattedCommand( "FRH", 3 ); 
  3675. m_bRecvHDLCError = false; 
  3676. SetTimer( TIMER_HDLC_RECV, 6000 );
  3677. m_bGotConnect = false;
  3678. };
  3681. void CClassOne::OnAbortFaxMsg(void)
  3682. {
  3683. Abort( true );
  3684. }
  3687. void CClassOne::CheckTimeouts( DWORD dwInActive )
  3688. {
  3690. switch( m_nState )
  3691. {
  3692. case STATE_PHASE_A:
  3693. if( dwInActive > 90000 )
  3694. {
  3695. m_sLastError.assign( (char*)LoadString(GEN_TIMEOUT_CONNECTING_TO_REMOTE_FAX).c_str() );
  3696. // SignalEvent( EVENT_ERROR );
  3697. Abort( false );
  3698. m_dwActivityTimer = GetTickCount();
  3699. }
  3700. break;
  3702. case STATE_PHASE_E:
  3703. if( dwInActive > 5000 )
  3704. {
  3705. Terminate();
  3706. DoHangup();
  3707. m_dwActivityTimer = GetTickCount();
  3708. }
  3709. break;
  3711. case STATE_DISCONNECT:
  3712. if( dwInActive > 1000 )
  3713. {
  3714. PhaseDisconnect();
  3715. }
  3716. break;
  3718. default:
  3719. if( m_nState > STATE_IDLE && m_nState != STATE_RINGING )
  3720. {
  3721. int nInActive = GetTickCount() - m_dwActivityTimer;
  3723. if( nInActive > 60000 )
  3724. {
  3725. m_sLastError.assign( (char*)LoadString(GEN_TIMEOUT_IN_SENDRECEIVE).c_str() );
  3726. // SignalEvent( EVENT_ERROR );
  3728. Abort( false );
  3729. m_dwActivityTimer = GetTickCount();
  3730. }
  3731. }
  3732. break;
  3733. }
  3735. }