callprocessor.h

Go to the documentation of this file.

/*
 *
 * Inter Asterisk Exchange 2
 * 
 * The core routine which determines the processing of packets for one call.
 * 
 * Open Phone Abstraction Library (OPAL)
 *
 * Copyright (c) 2005 Indranet Technologies Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Open Phone Abstraction Library.
 *
 * The Initial Developer of the Original Code is Indranet Technologies Ltd.
 *
 * The author of this code is Derek J Smithies
 *
 *
 *  $Log: callprocessor.h,v $
 *  Revision 1.9  2007/04/19 06:17:21  csoutheren
 *  Fixes for precompiled headers with gcc
 *
 *  Revision 1.8  2007/01/18 04:45:16  csoutheren
 *  Messy, but simple change to add additional options argument to OpalConnection constructor
 *  This allows the provision of non-trivial arguments for connections
 *
 *  Revision 1.7  2007/01/17 22:27:52  dereksmithies
 *  Correctly sends DTMF to remote node. Tidy up string handling.
 *
 *  Revision 1.6  2007/01/17 03:48:13  dereksmithies
 *  Tidy up comments, remove leaks, improve reporting of packet types.
 *
 *  Revision 1.5  2007/01/16 03:17:42  dereksmithies
 *  tidyup of comments. Remove unused variables.
 *  Guarantee that media frames are sent with a monotonically increasing timestamp
 *
 *  Revision 1.4  2007/01/11 03:02:15  dereksmithies
 *  Remove the previous audio buffering code, and switch to using the jitter
 *  buffer provided in Opal. Reduce the verbosity of the log mesasges.
 *
 *  Revision 1.3  2006/09/22 00:33:19  csoutheren
 *  Changed PAtomicInteger to PBoolean
 *
 *  Revision 1.2  2006/09/11 03:08:51  dereksmithies
 *  Add fixes from Stephen Cook (sitiveni@gmail.com) for new patches to
 *  improve call handling. Notably, IAX2 call transfer. Many thanks.
 *  Thanks also to the Google summer of code for sponsoring this work.
 *
 *  Revision 1.1  2006/08/09 03:46:39  dereksmithies
 *  Add ability to register to a remote Asterisk box. The iaxProcessor class is split
 *  into a callProcessor and a regProcessor class.
 *  Big thanks to Stephen Cook, (sitiveni@gmail.com) for this work.
 *
 *  Revision 1.7  2005/09/05 01:19:43  dereksmithies
 *  add patches from Adrian Sietsma to avoid multiple hangup packets at call end,
 *  and stop the sending of ping/lagrq packets at call end. Many thanks.
 *
 *  Revision 1.6  2005/08/26 03:07:38  dereksmithies
 *  Change naming convention, so all class names contain the string "IAX2"
 *
 *  Revision 1.5  2005/08/25 03:26:06  dereksmithies
 *  Add patch from Adrian Sietsma to correctly set the packet timestamps under windows.
 *  Many thanks.
 *
 *  Revision 1.4  2005/08/24 04:56:25  dereksmithies
 *  Add code from Adrian Sietsma to send FullFrameTexts and FullFrameDtmfs to
 *  the remote end.  Many Thanks.
 *
 *  Revision 1.3  2005/08/24 01:38:38  dereksmithies
 *  Add encryption, iax2 style. Numerous tidy ups. Use the label iax2, not iax
 *
 *  Revision 1.2  2005/08/04 08:14:17  rjongbloed
 *  Fixed Windows build under DevStudio 2003 of IAX2 code
 *
 *  Revision 1.1  2005/07/30 07:01:32  csoutheren
 *  Added implementation of IAX2 (Inter Asterisk Exchange 2) protocol
 *  Thanks to Derek Smithies of Indranet Technologies Ltd. for
 *  writing and contributing this code
 *
 *
 *
 *
 *
 *
 *
 */

#ifndef CALLPROCESSOR_H
#define CALLPROCESSOR_H

#ifndef _PTLIB_H
#include <ptlib.h>
#endif

#include <opal/connection.h>

#include <iax2/processor.h>
#include <iax2/frame.h>
#include <iax2/iedata.h>
#include <iax2/remote.h>
#include <iax2/safestrings.h>
#include <iax2/sound.h>

class IAX2Connection;

class IAX2CallProcessor : public IAX2Processor
{
  PCLASSINFO(IAX2CallProcessor, IAX2Processor);
  
 public:
  
  IAX2CallProcessor(IAX2EndPoint & ep);

  virtual ~IAX2CallProcessor(); 

  void AssignConnection(IAX2Connection * _con);
  
  void PutSoundPacketToNetwork(PBYTEArray *sund);
  
  IAX2Encryption & GetEncryptionInfo() { return encryption; }

  virtual void Release(OpalConnection::CallEndReason releaseReason = OpalConnection::EndedByLocalUser);

  void ClearCall(OpalConnection::CallEndReason releaseReason = OpalConnection::EndedByLocalUser);

  virtual void OnReleased();
  
  void SendDtmf(const PString & dtmfs);

  void SendText(const PString & text);

  virtual PBoolean SetUpConnection();

  PBoolean Matches(IAX2Frame *frame) { return remote == (frame->GetRemoteInfo()); }
  
  virtual void PrintOn(ostream & strm) const;
  
  void ReportStatistics();  

  PBoolean MatchingLocalCallNumber(PINDEX compare) { return (compare == remote.SourceCallNumber()); }  
  
  unsigned short GetSelectedCodec() { return (unsigned short) selectedCodec; }
  
  void AcceptIncomingCall();

  virtual PBoolean SetAlerting(
         const PString & calleeName,   
         PBoolean withMedia                
         ) ;

  void Hangup(PString messageToSend);

  PBoolean IsCallTerminating() { return callStatus & callTerminating; }
  
  void SendHold();

  void SendHoldRelease();
  
  void SetUserName(PString & inUserName) { userName = inUserName; };
  
  PString GetUserName() const;
  
  void SetPassword(PString & inPassword) { password = inPassword; };
  
  PString GetPassword() const { return password; };
  
  void SendTransfer(
    const PString & calledNumber,
    const PString & calledContext = PString::Empty());  

  void StartStatusCheckTimer(PINDEX msToWait = 10000 );
  
  virtual PBoolean IncomingMessageOutOfOrder(IAX2FullFrame *ff);

  void SendAnswerMessageToRemoteNode();

 protected:
  
  IAX2Connection * con;

  PBoolean RemoteSelectedCodecOk();
 
  void CheckForHangupMessages();
 
  void ProcessNetworkFrame(IAX2Frame * src);
  
  void ProcessNetworkFrame(IAX2MiniFrame * src);
  
  void ProcessNetworkFrame(IAX2FullFrame * src);
  
  void ProcessNetworkFrame(IAX2FullFrameDtmf * src);
  
  void ProcessNetworkFrame(IAX2FullFrameVoice * src);
  
  void ProcessNetworkFrame(IAX2FullFrameVideo * src);
  
  void ProcessNetworkFrame(IAX2FullFrameSessionControl * src);
  
  void ProcessNetworkFrame(IAX2FullFrameNull * src);
  
  virtual PBoolean ProcessNetworkFrame(IAX2FullFrameProtocol * src);
  
  void ProcessNetworkFrame(IAX2FullFrameText * src);
  
  void ProcessNetworkFrame(IAX2FullFrameImage * src);
  
  void ProcessNetworkFrame(IAX2FullFrameHtml * src);
  
  void ProcessNetworkFrame(IAX2FullFrameCng * src);
  
  virtual void ProcessLists();
    
  void ConnectToRemoteNode(PString & destination);
  
  void SendDtmfMessage(char message);
  
  void SendTextMessage(PString & message);

  void SendSoundMessage(PBYTEArray *sound);
  
  void SendTransferMessage();
  
  void SendQuelchMessage();
  
  void SendUnQuelchMessage();
  
  void IncAudioFramesSent()   { ++audioFramesSent; }
  
  void IncAudioFramesRcvd()   { ++audioFramesRcvd; }
  
  void IncVideoFramesSent()   { ++videoFramesSent; }
  
  void IncVideoFramesRcvd()   { ++videoFramesRcvd; }
  
  void RemoteNodeHasAnswered();
  
  void CallStopSounds();
  
  void ReceivedHookFlash();
  
  void RemoteNodeIsBusy();
  
  void ProcessIncomingAudioFrame(IAX2Frame *newFrame);
  
  void ProcessIncomingVideoFrame(IAX2Frame *newFrame);
  
  void ProcessIaxCmdNew(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdAck(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdHangup(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdReject(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdAccept(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdAuthReq(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdAuthRep(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdInval(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdDpReq(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdDpRep(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdDial(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdTxreq(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdTxcnt(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdTxacc(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdTxready(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdTxrel(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdTxrej(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdQuelch(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdUnquelch(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdPage(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdMwi(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdUnsupport(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdTransfer(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdProvision(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdFwDownl(IAX2FullFrameProtocol *src);
  
  void ProcessIaxCmdFwData(IAX2FullFrameProtocol *src);
  
  PAtomicInteger audioFramesSent;
  
  PAtomicInteger audioFramesRcvd;
  
  PAtomicInteger videoFramesSent;
  
  PAtomicInteger videoFramesRcvd;
  
  SafeString remotePhoneNumber;
  
  SafeStrings callList;
  
  SafeString dtmfText;

  SafeStrings textList;

  SafeStrings dtmfNetworkList;

  SafeStrings hangList;
  
  PBoolean holdCall;
  
  PBoolean holdReleaseCall;
  
  IAX2SoundList   soundWaitingForTransmission;
  
  enum SoundBufferState {
    BufferToSmall, 
    Normal, 
    BufferToBig 
  };
  
  SoundBufferState soundBufferState;
  
  PINDEX lastFullFrameTimeStamp;
    
  PBoolean audioCanFlow;

  unsigned int selectedCodec;
  
  enum CallStatus {
    callNewed      =  1 << 0,   
    callSentRinging = 1 << 1,   
    callRegistered =  1 << 2,   
    callAuthorised =  1 << 3,   
    callAccepted   =  1 << 4,   
    callRinging    =  1 << 5,   
    callAnswered   =  1 << 6,   
    callTerminating = 1 << 7    
  };
  
  unsigned short callStatus;
  
  void SetCallSentRinging(PBoolean newValue = PTrue) 
    { if (newValue) callStatus |= callSentRinging; else callStatus &= ~callSentRinging; }
  
  void SetCallNewed(PBoolean newValue = PTrue) 
    { if (newValue) callStatus |= callNewed; else callStatus &= ~callNewed; }
  
  void SetCallRegistered(PBoolean newValue = PTrue) 
    { if (newValue) callStatus |= callRegistered; else callStatus &= ~callRegistered; }
  
  void SetCallAuthorised(PBoolean newValue = PTrue) 
    { if (newValue) callStatus |= callAuthorised; else callStatus &= ~callAuthorised; }
  
  void SetCallAccepted(PBoolean newValue = PTrue) 
    { if (newValue) callStatus |= callAccepted; else callStatus &= ~callAccepted; }
  
  void SetCallRinging(PBoolean newValue = PTrue) 
    { if (newValue) callStatus |= callRinging; else callStatus &= ~callRinging; }
  
  void SetCallAnswered(PBoolean newValue = PTrue) 
    { if (newValue) callStatus |= callAnswered; else callStatus &= ~callAnswered; }

  void SetCallTerminating(PBoolean newValue = PTrue) 
    { if (newValue) callStatus |= callTerminating; else callStatus &= ~callTerminating; }
  
  PBoolean IsCallHappening() { return callStatus > 0; }
  
  PBoolean IsCallNewed() { return callStatus & callNewed; }
  
  PBoolean IsCallSentRinging() { return callStatus & callSentRinging; }
  
  PBoolean IsCallRegistered() { return callStatus & callRegistered; }
  
  PBoolean IsCallAuthorised() { return callStatus & callAuthorised; }
  
  PBoolean IsCallAccepted() { return callStatus & callAccepted; }
  
  PBoolean IsCallRinging() { return callStatus & callRinging; }
  
  PBoolean IsCallAnswered() { return callStatus & callAnswered; }
       
#ifdef DOC_PLUS_PLUS

  void OnStatusCheck(PTimer &, INT);
#else
  PDECLARE_NOTIFIER(PTimer, IAX2CallProcessor, OnStatusCheck);
#endif
  
  void DoStatusCheck();
  
  void RemoteNodeIsRinging();

  void RingingWasAcked();

  void AnswerWasAcked();

  PBoolean firstMediaFrame;

  PBoolean answerCallNow;

  PBoolean statusCheckOtherEnd;

  PTimer statusCheckTimer;

  PINDEX audioFrameDuration;

  PINDEX audioCompressedBytes;

  PBoolean audioFramesNotStarted;

  void CheckForRemoteCapabilities(IAX2FullFrameProtocol *src);
  
  virtual void OnNoResponseTimeout();
  
  virtual void ProcessFullFrame(IAX2FullFrame & fullFrame);
  
  PString userName;
  
  PString password;
  
  PMutex transferMutex;
  
  PBoolean doTransfer;
  
  PString transferCalledNumber;
  
  PString transferCalledContext;    
};


/* The comment below is magic for those who use emacs to edit this file. */
/* With the comment below, the tab key does auto indent to 4 spaces.     */

/*
 * Local Variables:
 * mode:c
 * c-basic-offset:2
 * End:
 */


#endif // CALLPROCESSOR_H

---