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
 *
 * $Revision: 21283 $
 * $Author: rjongbloed $
 * $Date: 2008-10-11 07:10:58 +0000 (Sat, 11 Oct 2008) $
 */

#ifndef OPAL_IAX2_CALLPROCESSOR_H
#define OPAL_IAX2_CALLPROCESSOR_H

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

#include <opal/buildopts.h>

#if OPAL_IAX2

#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 // OPAL_IAX2

#endif // OPAL_IAX2_CALLPROCESSOR_H

---