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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
callermain.cxx
资源名称：Server_win_src.rar　[点击查看]
上传用户：wzkunzhan
上传日期：2022-04-23
资源大小：2618k
文件大小：41k
源码类别：

模拟服务器

开发平台：

Visual C++

callermain.cxx：源码内容
  1. /*
  2.  * main.cxx
  3.  *
  4.  * Main source for for OpenAM
  5.  *
  6.  * A H.323 answering machine application.
  7.  *
  8.  * Copyright (c) 1993-2001 Equivalence Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Portable Windows Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25.  * All Rights Reserved.
  26.  *
  27.  */
  29. #include <ptlib.h>
  30. #include <ptlib/pipechan.h>
  32. #include "version.h"
  33. #include "lpc10codec.h"
  34. #include "speexcodec.h"
  36. #include "mscodecs.h"
  37. #include "opalvxml.h"
  38. #include "callermain.h"
  40. //PCREATE_PROCESS(Caller);
  42. #define new PNEW
  44. #define DEFAULT_MSG_LIMIT 30
  45. #define DEFAULT_CALL_LOG "call_log.txt"
  47. #define G7231_SAMPLES_PER_BLOCK 240
  49. #define CHECK_PCM   1
  50. #define CHECK_G7231 2
  52. #define MENU_PREFIX "UserMenu-"
  54. static PMutex logMutex;
  55. static PTextFile logFile;
  56. static PFilePath logFilename = DEFAULT_CALL_LOG;
  58. extern PString G7231Ext;
  59. extern PString WAVExt;
  60. extern PString PCMExt;
  62. extern BOOL CheckWAVFileValid(PWAVFile *chan, int type);
  64. static void LogMessage(const PString & str)
  65. {
  66.   PTime now;
  67.   PString msg = now.AsString("hh:mm:ss dd/MM/yyyy") & str;
  68.   logMutex.Wait();
  70.   if (!logFile.IsOpen()) {
  71.     logFile.Open(logFilename, PFile::ReadWrite);
  72.     logFile.SetPosition(0, PFile::End);
  73.   }
  75.   logFile.WriteLine(msg);
  77.   logFile.Close();
  78.   
  79.   logMutex.Signal();
  80. }
  82. static void LogCall(const PFilePath & fn,
  83.                     const PString & from,
  84.                     const PString & user,
  85.                     unsigned len,
  86.                     const PString & codec,
  87.                     const PString & product)
  88. {
  89.   PString addr = from;
  90.   LogMessage(addr & """ + user + """ & PString(PString::Unsigned, len) & codec & """ + product + """ & """ + fn + """);
  91. }
  94. ///////////////////////////////////////////////////////////////
  95. /*
  96. Caller::Caller()
  97.   : PProcess("NCE VOIP Project", "Caller",
  98.              MAJOR_VERSION, MINOR_VERSION, BUILD_TYPE, BUILD_NUMBER)
  99. {
  100. }
  101. */
  103. Caller::Caller()
  104.   : PObject()
  105. {
  106. }
  108. Caller::~Caller()
  109. {
  110. }
  113. void Caller::CallerMain(PString Cargs)
  114. {
  115.  // cout << GetName()
  116.  //      << " Version " << GetVersion(TRUE)
  117.  //      << " by " << GetManufacturer()
  118.  //      << " on " << GetOSClass() << ' ' << GetOSName()
  119.  //      << " (" << GetOSVersion() << '-' << GetOSHardware() << ")nn";
  121. // cout <<"Inside the Caller..n";
  123.   //PConfigArgs args(GetArguments());
  124.    PConfigArgs args(Cargs);
  126.   args.Parse(
  127.              "D-disable:"
  128.              "d-directory:"
  129.              "g-gatekeeper:"         "n-no-gatekeeper."
  130.              "-g711-ulaw."           "-no-g711-ulaw."
  131.              "-g711-alaw."           "-no-g711-alaw."
  132.              "-g711message:"         "-no-g711message."
  133.              "-g7231."               "-no-g7231."
  134.              "-g7231message:"        "-no-g7231message."
  135.              "-gsm."                 "-no-gsm."
  136.              "-gsmmessage:"          "-no-gsmmessage."
  137.              "h-help."
  138.              "H-hangup."             "-no-hangup."
  139.              "i-interface:"          "-no-interface."
  140.              "k-kill."               "-no-kill."
  141.              "l-limit:"              "-no-limit."
  142.              "-listenport:"          "-no-listenport."
  143.              "-lpc10message:"        "-no-lpc10message."
  144.              "-speexmessage:"        "-no-speexmessage."
  145.              "m-message:"            "-no-message."
  146.              "-no-recordg7231."
  147. #if PTRACING
  148.              "o-output:"
  149. #endif
  150.              "P-prefer:"
  151.              "-pcm."                 "-no-pcm."
  152.              "-pcmmessage:"          "-no-pcmmessage."
  153.              "-port:"
  154.              "q-quicknet:"           "-no-quicknet:"
  155.              "r-run:"                "-no-run."
  156.      "-recordraw."
  157.              "-require-gatekeeper."  "-no-require-gatekeeper."
  158.              "-save."
  159. #if PMEMORY_CHECK
  160.              "-setallocationbreakpoint:"
  161. #endif
  162. #if PTRACING
  163.              "t-trace."
  164. #endif
  165.      "u-username:"           "-no-username."
  166.           , FALSE);
  168. #if PMEMORY_CHECK
  169.   if (args.HasOption("setallocationbreakpoint"))
  170.     PMemoryHeap::SetAllocationBreakpoint(args.GetOptionString("setallocationbreakpoint").AsInteger());
  171. #endif
  173. #if PTRACING
  174.   PTrace::Initialise(args.GetOptionCount('t'),
  175.                      args.HasOption('o') ? (const char *)args.GetOptionString('o') : NULL);
  176. #endif
  178.   if (args.HasOption('h')) {
  179.     cout << "Usage : " << "-d"<< " [options]n"
  180.             "Options:n"
  181.             "  -d --directory dir  : Put recorded mesages into dirn"
  182.             "  -l --limit secs     : Limit recorded messages to secs duration (default " << DEFAULT_MSG_LIMIT << ")n"
  183.             "  -m --pcmmessage fn  : Set outgoing message for PCM derived codecs (G.711/GSM) to fnn"
  184.             "  --g7231message fn   : Set outgoing message for G723.1 codec to fnn"
  185.             "  --g711message fn    : Set outgoing message for G711 codec to fnn"
  186.             "  --gsmmessage fn     : Set outgoing message for GSM codec to fnn"
  187.             "  --lpc10message fn   : Set outgoing message for LPC10 codec to fnn"
  188.             "  --speexmessage fn   : Set outgoing message for Speex codec to fnn"
  190.             "  --recordraw         : Record PCM audo in raw files (.sw) instead of .wavn"
  191.             "  -r --run cmd        : Run this command after each recorded messagen"
  192.             "  -k --kill           : Kill recorded files after user commandn"
  193.             "  -H --hangup         : hangup after playing messagen"
  194.             "  -u --username str   : Set the local endpoint name to strn"
  195.             "  -i --interface ip   : Bind to a specific interfacen"
  196.             "  --listenport port   : Listen on a specific portn"
  197.             "  -g --gatekeeper host: Specify gatekeeper host.n"
  198.             "  -n --no-gatekeeper  : Disable gatekeeper discovery.n"
  199.             "  --require-gatekeeper: Exit if gatekeeper discovery fails.n"
  200.             "  -D --disable codec  : Disable the specified codec (may be used multiple times)n"
  201.             "  -P --prefer codec   : Prefer the specified codec (may be used multiple times)n"
  202. #if PTRACING
  203.             "  -t --trace          : Enable trace, use multiple times for more detailn"
  204.             "  -o --output         : File for trace output, default is stderrn"
  205. #endif
  206.             "     --save           : Save arguments in configuration filen"
  207.             "  -h --help           : Display this help messagen";
  208.     return;
  209.   }
  211.   args.Save("save");
  213. #if HAS_IXJ
  214.   if (args.GetCount() > 0) {
  215.     if (args[0] *= "record") 
  216.       RecordFile(args);    
  217.     else if (args[0] *= "play") 
  218.       PlayFile(args);
  219.     else {
  220. //cout << "No Command -> assuming destination address." << endl;
  221. }
  222. //      cerr << "unknown command "" << args[0] << """ << endl;
  223. //    return;
  224.   }
  225. #endif
  227.   unsigned callLimit = DEFAULT_MSG_LIMIT;
  228.   if (args.HasOption('l')) {
  229.     callLimit = args.GetOptionString('l').AsInteger();
  230.     if (callLimit > 3600) {
  231.       cout << "warning: maximum call length " << callLimit << " is out of range. Using " << DEFAULT_MSG_LIMIT << " insteadn";
  232.       callLimit = DEFAULT_MSG_LIMIT;
  233.     } else if (callLimit == 0)
  234.       cout << "warning: recorded message call limit disabledn";
  235.   }
  238.  // cout << "Recorded messages limited to " << callLimit << " secondsn";
  239. cout <<"Duration of the test session is expected to be approximately 3-5 minutes. nPlease Be Patient...n";
  240.   PString runCmd;
  241.   if (args.HasOption('r')) {
  242.     runCmd = args.GetOptionString('r');
  243.     cout << "Executing "" << runCmd << "" after each message" << endl;
  244.   }
  246.   PDirectory dir;
  247.   if (args.HasOption('d'))
  248.     dir = args.GetOptionString('d');
  250.   int flags = 0;
  252.   if (args.HasOption("no-recordg7231")) {
  253.     cout << "Supressing recording of G723.1 messages" << endl;
  254.     flags |= C_MyH323EndPoint::NoRecordG7231;
  255.   }
  256.   if (args.HasOption('k')) {
  257.     cout << "Deleting recorded files after processing" << endl;
  258.     if (runCmd.IsEmpty()) 
  259.       cout << "WARNING: recorded files will be deleted even though no run command is present" << endl;
  260.     flags |= C_MyH323EndPoint::DeleteAfterRecord;
  261.   }
  263.   if (args.HasOption('H'))
  264.     flags |= C_MyH323EndPoint::HangupAfterPlay;
  265.   
  267. //  cout<<"before endpointn";
  268.   C_MyH323EndPoint endpoint(callLimit, runCmd, dir, flags);
  269. //  cout<<"After endpointn";
  271.  /* PString userName = "OpenH323 Answering Machine v" + GetVersion();
  272.   if (args.HasOption('u'))
  273.     userName = args.GetOptionString('u');
  274.   endpoint.SetLocalUserName(userName);*/
  276.   if (!endpoint.Initialise(args))
  277.     return;
  279.   // start the H.323 listener
  280. /* Codigo retirado do Openam para implementacao do Caller
  281.   H323ListenerTCP * listener;
  282.   PIPSocket::Address interfaceAddress(INADDR_ANY);
  283.   WORD listenPort = H323EndPoint::DefaultTcpPort;
  285.   if (args.HasOption("listenport"))
  286.     listenPort = (WORD)args.GetOptionString("listenport").AsInteger();
  288.   if (args.HasOption('i'))
  289.     interfaceAddress = PIPSocket::Address(args.GetOptionString('i'));
  291.   listener  = new H323ListenerTCP(endpoint, interfaceAddress, listenPort);
  293.   if (!endpoint.StartListener(listener)) {
  294.     cout <<  "Could not open H.323 listener port on "
  295.          << listener->GetListenerPort() << endl;
  296.     delete listener;
  297.     return;
  298.   }
  300. */
  301.   if (args.HasOption('g')) {
  302.     PString gkName = args.GetOptionString('g');
  303.     if (endpoint.SetGatekeeper(gkName, new H323TransportUDP(endpoint)))
  304.       cout << "Gatekeeper set: " << *endpoint.GetGatekeeper() << endl;
  305.     else {
  306.       cout << "Error registering with gatekeeper at "" << gkName << '"' << endl;
  307.       return;
  308.     }
  309.   }
  310.  /* else if (!args.HasOption('n')) {
  311.     cout << "Searching for gatekeeper..." << flush;
  312.     if (endpoint.DiscoverGatekeeper(new H323TransportUDP(endpoint)))
  313.       cout << "nGatekeeper found: " << *endpoint.GetGatekeeper() << endl;
  314.     else {
  315.       cout << "nNo gatekeeper found." << endl;
  316.       if (args.HasOption("require-gatekeeper"))
  317.         return;
  318.     }
  319.   }*/
  322. /*
  323.   cout << "Waiting for incoming calls for "" << endpoint.GetLocalUserName() << '"' << endl;
  325.   for (;;) 
  326.     PThread::Current()->Sleep(5000);
  327. */
  328.   if (endpoint.MakeOutgoingCall(args[0])) {
  329.           endpoint.AwaitTermination();
  330.   } else {
  331.           cout << "Sorry, Exiting..." << endl;
  332.           return;
  333.   }
  334. }
  337. ///////////////////////////////////////////////////////////////
  340. C_MyH323EndPoint::C_MyH323EndPoint(unsigned _callLimit,
  341.                                const PString & _runCmd,
  342.                                const PDirectory & _dir,
  343.                                int   _flags)
  344.   : callLimit(_callLimit), runCmd(_runCmd), dir(_dir), flags(_flags)
  345. {
  346. }
  348. // Caller - Novos Metodos - Cesar
  349. BOOL C_MyH323EndPoint::OnAlerting( H323Connection & _conn, const H323SignalPDU & _SPDU, const PString & _user)
  350. {
  351.         cout << "  Ringing to " << _user << endl;
  352.         return TRUE;
  353. }
  354. void C_MyH323EndPoint::OnConnectionEstablished( H323Connection & _conn , const PString & _token  )
  355. {
  356.   C_MyH323Connection & conn = (C_MyH323Connection &)_conn;
  357.   RTP_Session * session = conn.GetSession(RTP_Session::DefaultAudioSessionID);
  358.   session->SetReportTimeInterval(1000);
  359.   StateFlag=InCall;
  360. }
  362. void C_MyH323EndPoint::OnConnectionCleared( H323Connection & _conn, const PString & _token )
  363. {
  364.         StateFlag=CallClosed;
  365. }
  367. void C_MyH323EndPoint::AwaitTermination()
  368. {
  369.         for (;;)
  370.         {
  371.                 if (StateFlag!=CallClosed) PThread::Current()->Sleep(5000);
  372.                 else break;
  373.         }
  375. }
  376. BOOL  C_MyH323EndPoint::MakeOutgoingCall(const PString & _dest)
  377. {
  378.         PString fullAddress;
  379. //      WORD CallPort = H323ListenerTCP::DefaultSignalPort;
  380.         WORD CallPort = H323EndPoint::DefaultTcpPort;
  381.         fullAddress=_dest;
  382.         if ((fullAddress.Find(':') == P_MAX_INDEX))  fullAddress += psprintf(":%i", CallPort);
  384.         cout << "Initiating test to "" << fullAddress << '"' << endl;
  386.         if (!MakeCall(fullAddress, currentCallToken)) {
  387.                 cout << "Error making call to "" << fullAddress << '"' << endl;
  388.                 return FALSE;
  389.         }
  390.         StateFlag=CallInit;
  391.         return TRUE;
  392. }
  393. // Caller - Novos Metodos - Cesar
  397. BOOL C_MyH323EndPoint::OnIncomingCall(H323Connection & _conn,
  398.                                     const H323SignalPDU & setupPDU,
  399.                                     H323SignalPDU &)
  400. {
  401.   C_MyH323Connection & conn = (C_MyH323Connection &)_conn;
  403.   // see if incoming call is to a getway address
  404.   PString number;
  405.   if (setupPDU.GetDestinationE164(number)) 
  406.     conn.SetE164Number(number);
  408.   return TRUE;
  409. }
  411. H323Connection * C_MyH323EndPoint::CreateConnection(unsigned callReference)
  412. {
  413.   return new C_MyH323Connection(*this, callReference);
  414. }
  416. BOOL C_MyH323EndPoint::Initialise(PConfigArgs & args)
  417. {
  419. // cout<<"Inside CallerMain MyEndpoint Initialisen";
  420.   // format for record files, raw or wav
  421.   if (args.HasOption("recordraw")) 
  422.     SetRecordWav(FALSE);
  423.   else
  424.     SetRecordWav(TRUE);
  426.   // get G723.1 OGM
  427.   if (args.HasOption("g7231message"))
  428.     g7231Ogm = args.GetOptionString("g7231message");
  429.   else if (args.HasOption('m'))  {
  430.     if (PFile::Exists(args.GetOptionString('m') + "_g7231" + WAVExt)) {
  431.       g7231Ogm = args.GetOptionString('m') + "_g7231" + WAVExt;
  432.   cout<<"Message file is 0: "<<g7231Ogm<<"n";
  433.     }
  434.     else if (PFile::Exists(args.GetOptionString('m') + PCMExt)) {
  435.       g7231Ogm = args.GetOptionString('m') + G7231Ext;
  436.   cout<<"Message file is 1: "<<g7231Ogm<<"n";
  437.     }
  438.   }
  440.   if (!g7231Ogm.IsEmpty()) {
  441.     // check if the file exists. (do not check if filename contains %s)
  442.     if ((g7231Ogm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(g7231Ogm)) {
  443.       cout << "warning: cannot open G723.1 OGM file "" << g7231Ogm << """ << endl;
  444.       g7231Ogm = "";
  445.     } 
  446.   }
  448.   if (g7231Ogm.IsEmpty()) {
  449. //    cout << "No G.723.1 outgoing message setn";
  450.   }
  451.   else {
  452. //    cout << "Using "" << g7231Ogm << "" as G.723.1 outgoing messagen";
  453.   }
  456.   // Get the OGM message for the 'PCM' codecs
  457.   // Check if the file specified exists. If it does, use it.
  458.   // If it does not exist, try with .wav and .sw extensions.
  459.   if (args.HasOption("pcmmessage")) {
  460.     pcmOgm = args.GetOptionString("pcmmessage");
  461.   }
  462.   else if (args.HasOption('m')) {
  463.       if (PFile::Exists(args.GetOptionString('m'))) {
  464.         pcmOgm = args.GetOptionString('m');
  465.       }
  466.       else if (PFile::Exists(args.GetOptionString('m') + WAVExt)) {
  467.         pcmOgm = args.GetOptionString('m') + WAVExt;
  468.       }
  469.       else if (PFile::Exists(args.GetOptionString('m') + PCMExt)) {
  470.         pcmOgm = args.GetOptionString('m') + PCMExt;
  471.       }
  472.   }
  475.   // By default, use the pcmOgm for all the PCM codecs, but allow the user
  476.   // to override them.
  477.   gsmOgm   = pcmOgm;
  478.   g711Ogm  = pcmOgm;
  479.   lpc10Ogm = pcmOgm;
  480.   speexOgm = pcmOgm;
  483.   // We can set the filename for specific codecs.
  484.   if (args.HasOption("gsmmessage")) 
  485.     gsmOgm = args.GetOptionString("gsmmessage");
  487.   if (args.HasOption("g711message")) 
  488.     g711Ogm = args.GetOptionString("g711message");
  490.   if (args.HasOption("lpc10message")) 
  491.     lpc10Ogm = args.GetOptionString("lpc10message");
  493.   if (args.HasOption("speexmessage")) 
  494.     speexOgm = args.GetOptionString("speexmessage");
  496.   // Check GSM OGM message
  497.   if (!gsmOgm.IsEmpty()) {
  498.     if ((gsmOgm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(gsmOgm)) {
  499.       cout << "warning: cannot open GSM OGM file "" << gsmOgm << """ << endl;
  500.       gsmOgm = "";
  501.     }
  502.   } 
  503.   if (gsmOgm.IsEmpty()) {
  504. //    cout << "No GSM outgoing message setn";
  505.   }
  506.   else {
  507. //    cout << "Using "" << gsmOgm << "" as GSM outgoing messagen";
  508.   }
  510.   // Check G.711 OGM message 
  511.   if (!g711Ogm.IsEmpty()) {
  512.     if ((g711Ogm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(g711Ogm)) {
  513.       cout << "warning: cannot open G711 OGM file "" << g711Ogm << """ << endl;
  514.       g711Ogm = "";
  515.     }
  516.   } 
  517.   if (g711Ogm.IsEmpty()) {
  518. //    cout << "No G711 outgoing message setn";
  519.   }
  520.   else {
  521. //    cout << "Using "" << g711Ogm << "" as G.711 outgoing messagen";
  522.   }
  524.   // Check LPC10 OGM message 
  525.   if (!lpc10Ogm.IsEmpty()) {
  526.     if ((lpc10Ogm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(lpc10Ogm)) {
  527.       cout << "warning: cannot open LPC10 OGM file "" << lpc10Ogm << """ << endl;
  528.       lpc10Ogm = "";
  529.     }
  530.   } 
  531.   if (lpc10Ogm.IsEmpty()) {
  532. //    cout << "No LPC10 outgoing message setn";
  533.   }
  534.   else {
  535. //    cout << "Using "" << lpc10Ogm << "" as LPC10 outgoing messagen";
  536.   }
  538.   // Check Speex OGM message 
  539.   if (!speexOgm.IsEmpty()) {
  540.     // check if the file exists. (do not check if filename contains %s)
  541.     if ((speexOgm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(speexOgm)) {
  542.       cout << "warning: cannot open Speex OGM file "" << speexOgm << """ << endl;
  543.       speexOgm = "";
  544.     }
  545.   } 
  546.   if (speexOgm.IsEmpty()) {
  547. //    cout << "No Speex outgoing message setn";
  548.   }
  549.   else {
  550. //    cout << "Using "" << speexOgm << "" as Speex outgoing messagen";
  551.   }
  554.   if (g7231Ogm.IsEmpty() && gsmOgm.IsEmpty() && g711Ogm.IsEmpty()
  555.                          && lpc10Ogm.IsEmpty() 
  556.  && speexOgm.IsEmpty()
  557.  ) {
  558.     cerr << "Must specify at least one outgoing message" << endl;
  559.     return FALSE;
  560.   }
  562.  /* if (!g7231Ogm.IsEmpty())
  563.     SetCapability(0, 0, new G7231_File_Capability);
  565.   if (!gsmOgm.IsEmpty())
  566.     SetCapability(0, 0, new H323_GSM0610Capability);
  568.   if (!gsmOgm.IsEmpty())
  569.     SetCapability(0, 0, new MicrosoftGSMAudioCapability);
  571.   */
  573.   if (!g711Ogm.IsEmpty())
  574.     SetCapability(0, 0, new H323_G711Capability(H323_G711Capability::muLaw, H323_G711Capability::At64k));
  576.   if (!g711Ogm.IsEmpty())
  577.     SetCapability(0, 0, new H323_G711Capability(H323_G711Capability::ALaw, H323_G711Capability::At64k));
  579.   /* if (!lpc10Ogm.IsEmpty())
  580.     SetCapability(0, 0, new H323_LPC10Capability(*this));
  582.   if (!speexOgm.IsEmpty())
  583.     SetCapability(0, 0, new SpeexNarrow2AudioCapability());
  584.     SetCapability(0, 0, new SpeexNarrow3AudioCapability());
  585.     SetCapability(0, 0, new SpeexNarrow4AudioCapability());
  586.     SetCapability(0, 0, new SpeexNarrow5AudioCapability());
  587.     SetCapability(0, 0, new SpeexNarrow6AudioCapability());
  589.   */
  591.   capabilities.Remove(args.GetOptionString('D').Lines());
  592.   capabilities.Reorder(args.GetOptionString('P').Lines());
  594. //  cout << "Codecs (in preference order):n" << setprecision(2) << capabilities << endl;
  596.   return TRUE;
  597. }
  599. ///////////////////////////////////////////////////////////////
  601. C_PCM_RecordFile::C_PCM_RecordFile(C_MyH323Connection & _conn, const PFilePath & _fn, unsigned _callLimit)
  602.   : conn(_conn), fn(_fn), callLimit(_callLimit)
  603. {
  604.   recordStarted = FALSE;
  605.   timeLimitExceeded = FALSE;
  606.   closed        = FALSE;
  607.   dataWritten   = FALSE;
  609.   // If the file name ends in .wav then open the output as a WAV file.
  610.   // Otherwise open it as a raw file.
  611.   if ((_fn.Right(4)).ToLower() == ".wav")
  612.     fileclass = new PWAVFile(_fn, PFile::WriteOnly,
  613.      PFile::ModeDefault,PWAVFile::PCM_WavFile);
  614.   else
  615.     fileclass = new PFile(_fn, PFile::WriteOnly);
  616. }
  618. void C_PCM_RecordFile::StartRecording()
  619. {
  620.   PWaitAndSignal mutex(pcmrecordMutex);
  622.   if (recordStarted)
  623.     return;
  625.   PTRACE(1, "Starting recording to " << fn);
  627.   PTime now;
  628.   recordStarted = TRUE;
  629.   finishTime = now + (callLimit * 1000);
  630. }
  632. BOOL C_PCM_RecordFile::Close()
  633. {
  634.   PWaitAndSignal mutex(pcmrecordMutex);
  636.   closed = TRUE;
  637.   return fileclass->Close();
  638. }
  640. BOOL C_PCM_RecordFile::Write(const void * buf, PINDEX len)
  641. {
  642.   // Wait for the mutex, and Signal it at the end of this function
  643.   PWaitAndSignal mutex(pcmrecordMutex);
  645.   // If the record file has been closed, or if the time limit has
  646.   // been exceeded, then return immediatly.
  647.   if (closed || timeLimitExceeded)
  648.     return FALSE;
  650.   if (!recordStarted) {
  651.     DelayFrame(len);
  652.     return TRUE;
  653.   }
  655.   PTime now;
  656.   if ((callLimit != 0) && (now >= finishTime)) {
  657.     PTRACE(1, "Terminating call due to timeout");
  658.     conn.ClearCall();
  659.     timeLimitExceeded = TRUE;
  660.     return TRUE;
  661.   }
  663.   DelayFrame(len);
  665.   dataWritten = TRUE;
  667.   return WriteFrame(buf, len);
  668. }
  670. BOOL C_PCM_RecordFile::WriteFrame(const void * buf, PINDEX len)
  671. {
  672.   //cerr << "Writing PCM " << len << endl;
  673.   return  fileclass->Write(buf, len);
  674. }
  676. void C_PCM_RecordFile::DelayFrame(PINDEX len)
  677. {
  678.   delay.Delay(len/16);
  679. }
  681. C_PCM_RecordFile::~C_PCM_RecordFile()
  682. {
  683.   PWaitAndSignal mutex(pcmrecordMutex);
  685.   if (!dataWritten) {
  686.     PTRACE(1, "Deleting " << fn << " as no data recorded");
  687.     fileclass->Remove(fn);
  688.   }
  690.   delete fileclass;
  691. }
  693. ///////////////////////////////////////////////////////////////
  694. // Override some of the PCM_RecordFile functions to write
  695. // G723.1 data instead of PCM data.
  697. C_G7231_RecordFile::C_G7231_RecordFile(C_MyH323Connection & _conn, const PFilePath & _fn, unsigned _callLimit)
  698.   : C_PCM_RecordFile(_conn, _fn, _callLimit)
  699. {
  700.   // If the record file is a .wav file, we need to close the file
  701.   // that PCM_RecordFile will have opened, and reopen it as a G.723.1 Wav file.
  702.   if ((_fn.Right(4)).ToLower() == ".wav") {
  703.     fileclass->Remove(_fn);
  704.     delete fileclass;
  705.     fileclass = new PWAVFile(_fn, PFile::WriteOnly,
  706.      PFile::ModeDefault,PWAVFile::G7231_WavFile);
  707.   }
  708. }
  710. BOOL C_G7231_RecordFile::WriteFrame(const void * buf, PINDEX /*len*/)
  711. {
  712.   int frameLen = G7231_File_Codec::GetFrameLen(*(BYTE *)buf);
  713. //  cerr << "Writing G7231 " << frameLen << endl;
  714.   return fileclass->Write(buf, frameLen);
  715. }
  717. void C_G7231_RecordFile::DelayFrame(PINDEX /*len*/)
  718. {
  719.   // Ignore the len parameter as that is the compressed size.
  720.   // We must delay by the actual sample time.
  721.   delay.Delay((G7231_SAMPLES_PER_BLOCK*2)/16);
  722. }
  724. ///////////////////////////////////////////////////////////////
  726. static BOOL MatchString(const PString & str1, const PString str2)
  727. {
  728.   if (str1.GetLength() != str2.GetLength())
  729.     return FALSE;
  731.   PINDEX len = str1.GetLength();
  733.   PINDEX i;
  734.   for (i = 0; i < len; i++) 
  735.     if ((str1[i] != '?') && (str2[i] != '?') && (str1[i] != str2[i]))
  736.       return FALSE;
  738.   return TRUE;
  739. }
  741. static PINDEX FindMatch(const PStringList & list, const PString & key)
  742. {
  743.   PINDEX maxKeyLen = 0;
  744.   PINDEX i;
  746.   PINDEX keyLen = key.GetLength();
  747.   PINDEX listLen = list.GetSize();
  749.   for (i = 0; i < listLen; i++)
  750.     maxKeyLen = PMAX(maxKeyLen, list[i].GetLength());
  752.   if (keyLen == 0 || maxKeyLen == 0)
  753.     return P_MAX_INDEX;
  755.   if (keyLen > maxKeyLen)
  756.     return P_MAX_INDEX;
  758.   PINDEX len = 1;
  759.   while (len <= keyLen) {
  760.     PString subStr = key.Left(len);
  762.     PINDEX matches = 0;
  763.     PINDEX lastMatch = P_MAX_INDEX;
  764.     PINDEX i;
  766.     // look for a match to the substring
  767.     for (i = 0; i < list.GetSize(); i++) {
  768.       if ((list[i].GetLength() >= keyLen) && MatchString(list[i].Left(len), subStr)) {
  769.         matches++;
  770.         lastMatch = i;
  771.       }
  772.     }
  774.     // if we got ONE match, we have a winner
  775.     if (matches == 1)
  776.       return lastMatch+1;
  778.     // if we have no matches, then there is no point continuing
  779.     if (matches == 0)
  780.       return P_MAX_INDEX;
  782.     // if we have more than one match, try the next char
  783.     len++;
  784.   }
  786.   // too many matches
  787.   return 0;
  788. }
  791. C_MyH323Connection::C_MyH323Connection(C_MyH323EndPoint & _ep, unsigned callReference)
  792.   : H323Connection(_ep, callReference), ep(_ep)
  793. {
  794.   basename = psprintf("%04i%02i%02i_%02i%02i%02i", callStartTime.GetYear(), callStartTime.GetMonth(),  callStartTime.GetDay(),
  795.                                                    callStartTime.GetHour(), callStartTime.GetMinute(), callStartTime.GetSecond());
  796.   recordFile = NULL;
  797.   ogmChannel = NULL;
  799.   receiveCodecName = transmitCodecName = "none";
  800. // SetMaxAudioDelayJitter(150);
  802.   cout << "Opening connection" << endl;
  804.   currentMenu = 0;
  805.   digits = "";
  807.   PConfig config;
  808.   PStringList sections = config.GetSections();
  809.   PINDEX i;
  810.   for (i = 0; i < sections.GetSize(); i++) {
  811.     if (sections[i].Find(MENU_PREFIX) == 0) 
  812.       menuNames.AppendString(sections[i]);
  813.   }
  815. }
  817. C_MyH323Connection::~C_MyH323Connection()
  818. {
  819.   cout << "Closing connection" << endl;
  821.   PTime now;
  822.   PTimeInterval interval = now - recordStartTime;
  823.   PString addr = GetControlChannel().GetRemoteAddress();
  825.   PString codecStr = receiveCodecName + "/" + transmitCodecName;
  826.   unsigned duration = (unsigned)((interval.GetMilliSeconds()+999)/1000);
  828.   LogCall(recordFn, addr, GetRemotePartyName(), duration, codecStr, product);
  830.   if ((recordFile!= NULL) && (recordFile->WasRecordStarted()) && !ep.GetRunCmd().IsEmpty()) {
  831.     PString cmdStr = ep.GetRunCmd() &
  832.                      recordFn &
  833.                      "'" + addr + "'" &
  834.                      """ + GetRemotePartyName() + """ &
  835.                      PString(PString::Unsigned, duration) &
  836.                      """ + codecStr + """ &
  837.                      """ + product + """;
  838.     PTRACE(1, "Executing : " << cmdStr);
  839.     system((const char *)cmdStr);
  840.   } else {
  841.     PTRACE(1, "No action to perform at end of record");
  842.   }
  844.   if (ogmChannel != NULL)
  845.     delete ogmChannel;
  847.   if (recordFile != NULL)
  848.     delete recordFile;
  850.   if (ep.GetDeleteAfterRecord()) {
  851.     PTRACE(1, "Removing " << recordFn << " as requested by option");
  852.     PFile::Remove(recordFn);
  853.   }
  854. }
  856. H323Connection::AnswerCallResponse
  857.      C_MyH323Connection::OnAnswerCall(const PString & caller,
  858.                                     const H323SignalPDU & setupPDU,
  859.                                     H323SignalPDU & /*connectPDU*/)
  860. {
  861.   product = "Unknown";
  863.   const H225_Setup_UUIE & setup = setupPDU.m_h323_uu_pdu.m_h323_message_body;
  864.   const H225_EndpointType & epInfo = setup.m_sourceInfo;
  866.   if (epInfo.HasOptionalField(H225_EndpointType::e_vendor)) {
  867.     const H225_VendorIdentifier & vendorInfo = epInfo.m_vendor;
  868.     if (vendorInfo.HasOptionalField(H225_VendorIdentifier::e_productId))
  869.       product = vendorInfo.m_productId.AsString();
  870.     if (vendorInfo.HasOptionalField(H225_VendorIdentifier::e_versionId))
  871.       product = product + "/" + vendorInfo.m_versionId.AsString();
  872.   }
  873.   
  874.   cout << "Accepting call from " << caller << " using " << product << endl;
  876.   return AnswerCallNow;
  877. }
  879. BOOL C_MyH323Connection::OpenAudioChannel(BOOL isEncoding, 
  880.                                         unsigned /* bufferSize */, 
  881.                                         H323AudioCodec & codec)
  882. {
  883.   codec.SetSilenceDetectionMode(H323AudioCodec::NoSilenceDetection);
  884.   PStringStream codecName;
  885.   codecName << codec;
  887.   PString ogm;
  888.   BOOL isPCM = FALSE;
  890.   if (codec.IsDescendant(G7231_File_Codec::Class())) {
  891.     ogm   = ep.GetG7231OGM();
  892.     isPCM = FALSE;
  893.   } else if (codec.IsDescendant(H323_GSM0610Codec::Class())) {
  894.     ogm   = ep.GetGSMOGM();
  895.     isPCM = TRUE;
  896.   } else if (codec.IsDescendant(MicrosoftGSMCodec::Class())) {
  897.     ogm   = ep.GetGSMOGM();
  898.     isPCM = TRUE;
  899.   } else if (codec.IsDescendant(H323_muLawCodec::Class())) {
  900.     ogm   = ep.GetG711OGM();
  901.     isPCM = TRUE;
  902.   } else if (codec.IsDescendant(H323_ALawCodec::Class())) {
  903.     ogm   = ep.GetG711OGM();
  904.     isPCM = TRUE;
  905.   } else if (codec.IsDescendant(H323_LPC10Codec::Class())) {
  906.     ogm   = ep.GetLPC10OGM();
  907.     isPCM = TRUE;
  908.   } else if (codec.IsDescendant(SpeexCodec::Class())) {
  909.     ogm   = ep.GetSPEEXOGM();
  910.     isPCM = TRUE;
  911.   } else {
  912.     cerr << "Unknown codec "" << codecName << endl;
  913.     return FALSE;
  914.   }
  917.   PWaitAndSignal mutex(connMutex);
  919.   if ((recordFile == NULL) && (isEncoding == FALSE)) {
  920.     if (isPCM) {
  921.       if (ep.GetRecordWav() == TRUE)
  922.       recordFn = ep.GetDirectory() + (basename + ".wav");
  923.       else
  924.       recordFn = ep.GetDirectory() + (basename + ".sw");
  925.       recordFile = new C_PCM_RecordFile  (*this, recordFn, ep.GetCallLimit());
  926.     } else {
  927.       if (ep.GetRecordWav() == TRUE)
  928.       recordFn = ep.GetDirectory() + (basename + ".wav");
  929.       else
  930.       recordFn = ep.GetDirectory() + (basename + ".g723");
  931.       recordFile = new C_G7231_RecordFile(*this, recordFn, ep.GetCallLimit());
  932.     }
  933.   }
  935.   if ((ogmChannel == NULL) && (isEncoding == TRUE)) {
  936.     if (isPCM)
  937.       ogmChannel = new C_PCM_OGMChannel(*this);
  938.     else
  939.       ogmChannel = new C_G7231_OGMChannel(*this);
  940.   }
  942.   if (isEncoding) {
  944.     if (ep.GetHangupAfterPlay())
  945.       ogmChannel->SetPlayOnce();
  947.     if (ogm.Find("%s"))
  948.       ogm.Replace("%s", e164Number);
  950.     transmitCodecName = codecName;
  951.     if (!StartMenu(0)) {
  952.       if (!PFile::Exists(ogm))
  953.         cerr << "error: cannot find OGM "" << ogm << """ << endl;
  954.       else
  955.         ogmChannel->QueueFile(ogm);
  956.       if (!ep.GetNoRecordG7231())
  957.         ogmChannel->SetRecordTrigger();
  958.     }
  959.     codec.AttachChannel(ogmChannel, FALSE);
  960.   } else {
  961.     receiveCodecName = codecName;
  962.     codec.AttachChannel(recordFile, FALSE);
  963.   }
  965.   return TRUE;
  966. }
  968. BOOL C_MyH323Connection::OnStartLogicalChannel(H323Channel & channel)
  969. {
  970.   if (!H323Connection::OnStartLogicalChannel(channel))
  971.     return FALSE;
  973.   cout << "Started logical channel: ";
  975.   switch (channel.GetDirection()) {
  976.     case H323Channel::IsTransmitter :
  977.       cout << "sending ";
  978.       break;
  980.     case H323Channel::IsReceiver :
  981.       cout << "receiving ";
  982.       break;
  984.     default :
  985.       break;
  986.   }
  988.   cout << channel.GetCapability() << endl;
  990.   return TRUE;
  991. }
  993. void C_MyH323Connection::StartRecording()
  994. {
  995.   recordFile->StartRecording();
  996. }
  998. void C_MyH323Connection::OnUserInputString(const PString & value)
  999. {
  1000.   PINDEX i;
  1001.   for (i = 0; i < value.GetLength(); i++) {
  1002.     OnUserInputChar(value[i]);
  1003.   }
  1004. }
  1006. BOOL C_MyH323Connection::StartMenu(int menuNumber)
  1007. {
  1008.   digits = "";
  1009.   currentMenu = menuNumber;
  1010.   PString menuName = psprintf("%s%i", MENU_PREFIX, menuNumber);
  1011.   if (menuNames.GetStringsIndex(menuName) == P_MAX_INDEX) 
  1012.     return FALSE;
  1014.   PTRACE(1, "Starting menu " << menuNumber);
  1016.   PConfig menu(menuName);
  1017.   PString startCmd = menu.GetString("start");
  1019.   if (!startCmd.IsEmpty())
  1020.     ProcessMenuCmd(startCmd);
  1022.   return TRUE;
  1023. }
  1025. BOOL C_MyH323Connection::ProcessMenuCmd(const PString & cmdStr)
  1026. {
  1027.   PTRACE(1, "Processing menu cmd " << cmdStr);
  1028.   PStringArray tokens = cmdStr.Tokenise(" ", FALSE);
  1029.   int len = tokens.GetSize();
  1030.   if (len == 0)
  1031.     return TRUE;
  1033.   PString cmd = tokens[0];
  1035.   if ((len >= 2) && (cmd *= "play")) {
  1036.     ogmChannel->QueueFile(tokens[1]);
  1037.     if (len > 2) {
  1038.       cmd = "menu";
  1039.       tokens[1] = tokens[2];
  1040.     }
  1041.   }
  1043.   if ((len >= 2) && (cmd *= "menu")) {
  1044.     int newMenu = tokens[1].AsInteger();
  1045.     if (newMenu != currentMenu)
  1046.       StartMenu(newMenu);
  1047.   }
  1049.   else if (cmd *= "hangup")
  1050.     ogmChannel->SetHangupTrigger();
  1052.   else if (cmd *= "record")
  1053.     ogmChannel->SetRecordTrigger();
  1055.   return TRUE;
  1056. }
  1058. void C_MyH323Connection::OnUserInputChar(char ch)
  1059. {
  1060.   if (ch == '#') 
  1061.     digits += '$';
  1062.   else 
  1063.     digits += ch;
  1065.   PTRACE(1, "Processing digit string " << digits);
  1067.   ogmChannel->FlushQueue();
  1069.   PString menuName = psprintf("%s%i", MENU_PREFIX, currentMenu);
  1070.   if (menuNames.GetStringsIndex(menuName) == P_MAX_INDEX) {
  1071.     PTRACE(1, "Cannot find menu " << menuName);
  1072.     StartMenu(0);
  1073.     return;
  1074.   }
  1076.   PConfig menu(menuName);
  1077.   PStringList keys = menu.GetKeys();
  1078.   PINDEX keyMatch = FindMatch(keys, digits);
  1080.   // if key is still ambiguous, then keep collecting
  1081.   if (keyMatch == 0)
  1082.     return;
  1084.   PString cmd;
  1085.   if (keyMatch != P_MAX_INDEX) {
  1086.     PString key = keys[keyMatch-1];
  1087.     PTRACE(1, "Executing cmd for key " << key);
  1088.     cmd = menu.GetString(key);
  1089.   } else {
  1090.     PTRACE(1, "Cannot match cmd " << digits << " in menu " << menuName);
  1091.     cmd = menu.GetString("error", "menu 0");
  1092.   } 
  1094.   if (!cmd.IsEmpty()) {
  1095.     ProcessMenuCmd(cmd);
  1096.     digits = "";
  1097.   }
  1098. }
  1100. ///////////////////////////////////////////////////////////////
  1102. /*BOOL CheckWAVFileValid(PWAVFile *chan, int type) {
  1103.   // Check the wave file header
  1104.   if (!chan->IsValid()) {
  1105.     PTRACE(1, chan->GetName() << " wav file header invalid");
  1106.     return FALSE;
  1107.   }
  1110.   // Check the wave file format
  1111.   if ( (type == CHECK_PCM) && (chan->GetFormat() != 0x01) ){
  1112.     PTRACE(1, chan->GetName() << " is not a PCM format wav file");
  1113.     PTRACE(1, "It is format " << chan->GetFormat() );
  1114.     return FALSE;
  1115.   }
  1117.   if ( (type == CHECK_G7231) && 
  1118.        ((chan->GetFormat() != 0x42) && (chan->GetFormat() != 0x111)) ){
  1119.     PTRACE(1, chan->GetName() << " is not a G.723.1 format wav file");
  1120.     PTRACE(1, "It is format " << chan->GetFormat() );
  1121.     return FALSE;
  1122.   }
  1124.   // Check the sample rate for PCM wave files
  1125.   if ( (type == CHECK_PCM) &&
  1126.        ( (chan->GetSampleRate() != 8000)
  1127.        ||(chan->GetChannels() != 1)
  1128.        ||(chan->GetSampleSize() != 16) )
  1129.      ) {
  1130.     PTRACE(1, chan->GetName() << " is not a 16 Bit, Mono, 8000 Hz (8Khz) PCM wav file");
  1131.     PTRACE(1, "It is " << chan->GetSampleSize() << " bits, "
  1132.                        << (chan->GetChannels()==1 ? "mono " : "stereo ")
  1133.                        << chan->GetSampleRate() << " Hz");
  1134.     return FALSE;
  1135.   }
  1137.   return TRUE;
  1138. }*/
  1140. ///////////////////////////////////////////////////////////////
  1142. C_PCM_OGMChannel::C_PCM_OGMChannel(C_MyH323Connection & _conn)
  1143.   : conn(_conn)
  1144. {
  1145.   silentCount = 20;         // wait 20 frames before playing the OGM
  1146.   recordTrigger = FALSE;
  1147.   hangupTrigger = FALSE;
  1148.   closed        = FALSE;
  1149.   playOnce      = FALSE;
  1151.   frameLen = frameOffs = 0;
  1152. }
  1155. void C_PCM_OGMChannel::PlayFile(PFile * chan)
  1156. { 
  1157.   PWaitAndSignal mutex(chanMutex);
  1158. //  if (IsOpen())
  1159. //    Close();
  1161.   if (!chan->Open(PFile::ReadOnly)) {
  1162.     PTRACE(1, "Cannot open file "" << chan->GetName() << """);
  1163.     return;
  1164.   }
  1166.   PTRACE(1, "Playing file "" << chan->GetName() << """);
  1167.   totalData = 0;
  1168.   SetReadChannel(chan, TRUE);
  1169. }
  1172. BOOL C_PCM_OGMChannel::IsWAVFileValid(PWAVFile *chan) {
  1173.   // Check that this is a PCM wave file
  1174.   return CheckWAVFileValid(chan, CHECK_PCM);
  1175. }
  1178. BOOL C_PCM_OGMChannel::Read(void * buffer, PINDEX amount)
  1179. {
  1180.   PWaitAndSignal mutex(chanMutex);
  1182.   // if the channel is closed, then return error
  1183.   if (closed)
  1184.     return FALSE;
  1186.   // Create the frame buffer using the amount of bytes the codec wants to
  1187.   // read. Different codecs use different read sizes.
  1188.   frameBuffer.SetMinSize(1024);//amount);
  1190.   // assume we are returning silence
  1191.   BOOL doSilence = TRUE;
  1192.   BOOL frameBoundary = FALSE;
  1194.   // if still outputting a frame from last time, then keep doing it
  1195.   if (frameOffs < frameLen) {
  1196.     frameBoundary = AdjustFrame(buffer, amount);
  1197.     doSilence = FALSE;
  1199.   } else {
  1201.     // if we are returning silence frames, then 
  1202.     if (silentCount > 0) 
  1203.       silentCount--;
  1205.     // if a channel is already open, don't do silence
  1206.     else if (GetBaseReadChannel() != NULL)
  1207.       doSilence = FALSE;
  1209.     // If not in silence and no existing channel, open a new file.
  1210.     else {
  1211.       PString * str = playQueue.Dequeue();
  1212.       if (str != NULL) {
  1214.         // check the file extension and open a .wav or a raw (.sw or .g723) file
  1216.         if (((*str).Right(4)).ToLower() == ".wav") {
  1217.           PWAVFile *chan;
  1218.           chan = new PWAVFile(*str, PFile::ReadOnly);
  1219.           if (!chan->IsOpen()) {
  1220.             PTRACE(1, "Cannot open file "" << chan->GetName() << """);
  1221.             delete chan;
  1222.           } else {
  1223.           if (!IsWAVFileValid(chan) ){
  1224.               PTRACE(1, chan->GetName() << " is not a valid wav file");
  1225.               delete chan;
  1226.               cerr << "wave file is invalid" << endl;
  1227.             } else {
  1228.               PTRACE(1, "Playing file "" << chan->GetName() << """);
  1229.               totalData = 0;
  1230.               SetReadChannel(chan, TRUE);
  1231.               doSilence = FALSE;
  1232.             }
  1233.   }
  1235.         } else { // raw file (eg .sw)
  1236.           PFile *chan;
  1237.           chan = new PFile(*str);
  1238.           if (!chan->Open(PFile::ReadOnly)) {
  1239.             PTRACE(1, "Cannot open file "" << chan->GetName() << """);
  1240.             delete chan;
  1241.           } else {
  1242.             PTRACE(1, "Playing file "" << chan->GetName() << """);
  1243.             totalData = 0;
  1244.             SetReadChannel(chan, TRUE);
  1245.             doSilence = FALSE;
  1246.           }
  1247.         }
  1248.         delete str;
  1249.       }
  1250.     }
  1251.   
  1253.     // if not doing silence, try and read from the file
  1254.     if (!doSilence) {
  1255.   
  1256.       if (ReadFrame(amount)) {
  1257.         frameBoundary = AdjustFrame(buffer, amount);
  1258.         totalData += amount;
  1259.   
  1260.       } else {
  1262.         PTRACE(1, "Finished playing " << totalData << " bytes");
  1263.         //closed = TRUE;
  1264.   
  1265.         PIndirectChannel::Close();
  1266.         silentCount = 5;   // always do 5 frames of silence after every file
  1267.   
  1268.         // hangup if required
  1269.         if (hangupTrigger || playOnce) 
  1270.           conn.ClearCall();
  1271.   
  1272.         // trigger record if required
  1273.         else if (recordTrigger) {
  1274.           if ((playQueue.GetSize() == 0) && (GetBaseReadChannel() == NULL))
  1275.             conn.StartRecording();
  1276.       }
  1277.    
  1278.         // no silence
  1279.         doSilence = TRUE;
  1280.       }
  1281.     }
  1282.   }
  1283.   
  1284.   // start silence frame if required
  1285.   if (doSilence) {
  1286.     CreateSilenceFrame(amount);
  1287.     frameBoundary = AdjustFrame(buffer, amount);
  1288.   }
  1290.   // delay to synchronise to frame boundary
  1291.   if (frameBoundary)
  1292.     Synchronise(amount);
  1294.   return TRUE;
  1295. }
  1297. BOOL C_PCM_OGMChannel::Close()
  1298. {
  1299.   PWaitAndSignal mutex(chanMutex);
  1300.   closed = TRUE;
  1301.   PIndirectChannel::Close();
  1302.   return TRUE;
  1303. }
  1305. void C_PCM_OGMChannel::SetRecordTrigger()
  1306. {
  1307.   PWaitAndSignal mutex(chanMutex);
  1308.   recordTrigger = TRUE;
  1309.   if ((playQueue.GetSize() == 0) && (GetBaseReadChannel() == NULL))
  1310.     conn.StartRecording();
  1311. }
  1313. void C_PCM_OGMChannel::SetHangupTrigger()
  1314. {
  1315.   PWaitAndSignal mutex(chanMutex);
  1316.   hangupTrigger = TRUE;
  1317.   if (GetBaseReadChannel() == NULL)
  1318.     conn.ClearCall();
  1319. }
  1321. void C_PCM_OGMChannel::QueueFile(const PString & fn)
  1322. {
  1323.   PWaitAndSignal mutex(chanMutex);
  1324.   PTRACE(1, "Enqueueing file " << fn << " for playing");
  1325.   playQueue.Enqueue(new PString(fn));
  1326. }
  1328. void C_PCM_OGMChannel::FlushQueue()
  1329. {
  1330.   PWaitAndSignal mutex(chanMutex);
  1332.   if (GetBaseReadChannel() != NULL) {
  1333.     PIndirectChannel::Close();
  1334.     if (hangupTrigger) 
  1335.       conn.ClearCall();
  1336.     else if (recordTrigger) 
  1337.       conn.StartRecording();
  1338.   }
  1340.   PString * str;
  1341.   while ((str = playQueue.Dequeue()) != NULL)
  1342.     delete str;
  1343. }
  1345. BOOL C_PCM_OGMChannel::AdjustFrame(void * buffer, PINDEX amount)
  1346. {
  1347.   if ((frameOffs + amount) > frameLen) {
  1348.     cerr << "Reading past end of frame:offs=" << frameOffs << ",amt=" << amount << ",len=" << frameLen << endl;
  1349.     return TRUE;
  1350.   }
  1351.   //PAssert((frameOffs + amount) <= frameLen, "Reading past end of frame");
  1353.   memcpy(buffer, frameBuffer.GetPointer()+frameOffs, amount);
  1354.   frameOffs += amount;
  1356.   lastReadCount = amount;
  1358.   return frameOffs == frameLen;
  1359. }
  1361. void C_PCM_OGMChannel::Synchronise(PINDEX amount)
  1362. {
  1363.   ogm_delay.Delay(amount / 16);
  1364. }
  1366. BOOL C_PCM_OGMChannel::ReadFrame(PINDEX amount)
  1367. {
  1368.   frameOffs = 0;
  1369.   frameLen  = amount;
  1371.   BOOL result = PIndirectChannel::Read(frameBuffer.GetPointer(), frameLen);
  1373.   // if we did not read a full frame of audio, fill the end of the
  1374.   // frame with zeros.
  1375.   PINDEX count = GetLastReadCount();
  1376.   if (count < frameLen)
  1377.     memset(frameBuffer.GetPointer()+count, 0, frameLen-count);
  1379.   return result;
  1380. }
  1382. void C_PCM_OGMChannel::CreateSilenceFrame(PINDEX amount)
  1383. {
  1384.   frameOffs = 0;
  1385.   frameLen  = amount;
  1386.   memset(frameBuffer.GetPointer(), 0, frameLen);
  1387. }
  1389. ///////////////////////////////////////////////////////////////
  1391. C_G7231_OGMChannel::C_G7231_OGMChannel(C_MyH323Connection & conn)
  1392.   : C_PCM_OGMChannel(conn)
  1393. {
  1394. }
  1396. void C_G7231_OGMChannel::Synchronise(PINDEX /*amount*/)
  1397. {
  1398.   ogm_delay.Delay(30);
  1399. }
  1401. BOOL C_G7231_OGMChannel::ReadFrame(PINDEX /*amount*/)
  1402. {
  1403.   if (!PIndirectChannel::Read(frameBuffer.GetPointer(), 1))
  1404.     return FALSE;
  1406.   frameOffs = 0;
  1407.   frameLen = G7231_File_Codec::GetFrameLen(frameBuffer[0]);
  1409.   return PIndirectChannel::Read(frameBuffer.GetPointer()+1, frameLen-1);
  1410. }
  1412. void C_G7231_OGMChannel::CreateSilenceFrame(PINDEX /*amount*/)
  1413. {
  1414.   frameOffs = 0;
  1415.   frameLen  = 4;
  1417.   frameBuffer[0] = 2;
  1418.   memset(frameBuffer.GetPointer()+1, 0, 3);
  1419. }
  1421. BOOL C_G7231_OGMChannel::IsWAVFileValid(PWAVFile *chan) {
  1422.   // Check that this is a G.723.1 wave file
  1423.   return CheckWAVFileValid(chan, CHECK_G7231);
  1424. }
  1426. ///////////////////////////////////////////////////////////////