connection.h

Go to the documentation of this file.

/*
 * connection.h
 *
 * Telephony connection abstraction
 *
 * Open Phone Abstraction Library (OPAL)
 * Formally known as the Open H323 project.
 *
 * Copyright (c) 2001 Equivalence Pty. 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 Equivalence Pty. Ltd.
 *
 * Contributor(s): Post Increment
 *     Portions of this code were written with the assistance of funding from
 *     US Joint Forces Command Joint Concept Development & Experimentation (J9)
 *     http://www.jfcom.mil/about/abt_j9.htm
 */

#ifndef OPAL_OPAL_CONNECTION_H
#define OPAL_OPAL_CONNECTION_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal_config.h>

#include <opal/mediafmt.h>
#include <opal/mediastrm.h>
#include <opal/mediasession.h>
#include <opal/guid.h>
#include <opal/transports.h>
#include <ptclib/dtmf.h>
#include <ptclib/mime.h>
#include <ptlib/safecoll.h>
#include <rtp/rtp.h>

#if OPAL_SCRIPT
// Inside #if so does not force loading of factories when statically linked.
#include <ptclib/script.h>
#endif


class OpalEndPoint;
class OpalCall;
class OpalConferenceState;
class OpalSilenceDetector;
class OpalEchoCanceler;
class OpalRFC2833Proto;
class OpalRFC2833Info;
class PURL;


#define OPAL_URL_PARAM_PREFIX           "OPAL-"
#define OPAL_MAKE_URL_PARAM(opt)        ";" OPAL_URL_PARAM_PREFIX opt
#define OPAL_MAKE_URL_PARAM2(opt, val)  OPAL_MAKE_URL_PARAM(opt) "=" val

#define OPAL_OPT_AUTO_START           "AutoStart"             
#define OPAL_OPT_CALL_IDENTIFIER      "Call-Identifier"       
#define OPAL_OPT_CALLING_PARTY_URL    "Calling-Party-URL"     
#define OPAL_OPT_CALLING_PARTY_NUMBER "Calling-Party-Number"  
#define OPAL_OPT_CALLING_PARTY_NAME   "Calling-Party-Name"    
#define OPAL_OPT_CALLING_PARTY_DOMAIN "Calling-Party-Domain"  
#define OPAL_OPT_CALLING_DISPLAY_NAME "Calling-Display-Name"  
#define OPAL_OPT_CALLED_PARTY_NAME    "Called-Party-Name"     
#define OPAL_OPT_CALLED_DISPLAY_NAME  "Called-Display-Name"   
#define OPAL_OPT_REDIRECTING_PARTY    "Redirecting-Party"     
#define OPAL_OPT_PRESENTATION_BLOCK   "Presentation-Block"    
#define OPAL_OPT_INTERFACE            "Interface"             
#define OPAL_OPT_USER_INPUT_MODE      "User-Input-Mode"       
#define OPAL_OPT_ENABLE_INBAND_DTMF   "EnableInbandDTMF"      
#define OPAL_OPT_ENABLE_INBAND_DTMF   "EnableInbandDTMF"      
#define OPAL_OPT_DETECT_INBAND_DTMF   "DetectInBandDTMF"      
#define OPAL_OPT_SEND_INBAND_DTMF     "SendInBandDTMF"        
#define OPAL_OPT_DTMF_MULT            "dtmfmult"
#define OPAL_OPT_DTMF_DIV             "dtmfdiv"
#define OPAL_OPT_DISABLE_JITTER       "Disable-Jitter"        
#define OPAL_OPT_MAX_JITTER           "Max-Jitter"            
#define OPAL_OPT_MIN_JITTER           "Min-Jitter"            
#define OPAL_OPT_RECORD_AUDIO         "Record-Audio"          
#define OPAL_OPT_ALERTING_TYPE        "Alerting-Type"         
#define OPAL_OPT_REMOVE_CODEC         "Remove-Codec"          


#define OPAL_OPT_SILENCE_DETECT_MODE  "Silence-Detect"

#define OPAL_OPT_CRYPTO_SUITES  "Crypto-Suites"

#define OPAL_OPT_VIDUP_METHODS            "Video-Update-Picture-Method"
#define OPAL_OPT_VIDUP_METHOD_OOB         1
#define OPAL_OPT_VIDUP_METHOD_RTCP        2
#define OPAL_OPT_VIDUP_METHOD_PLI         4
#define OPAL_OPT_VIDUP_METHOD_FIR         8
#define OPAL_OPT_VIDUP_METHOD_PREFER_PLI 16
#define OPAL_OPT_VIDUP_METHOD_DEFAULT     3



class OpalProductInfo
{
  public:
    OpalProductInfo();

    OpalProductInfo(
      const char * vendor,
      const char * name,
      const char * version,
      BYTE t35CountryCode,
      WORD manufacturerCode,
      const char * oid
    );

    static const OpalProductInfo & Default();

    void operator=(const OpalProductInfo & other);
    bool operator==(const OpalProductInfo & other) const;
    __inline bool operator!=(const OpalProductInfo & other) const { return !operator==(other); }

    friend ostream & operator<<(ostream & strm, const OpalProductInfo & info);

    PCaselessString AsString() const;

    PCaselessString vendor;
    PCaselessString name;
    PCaselessString version;
    PCaselessString comments;

    BYTE t35CountryCode;
    BYTE t35Extension;
    WORD manufacturerCode;

    PString oid;
};


class OpalConnection : public PSafeObject
{
    PCLASSINFO(OpalConnection, PSafeObject);
  public:
    P_DECLARE_TRACED_ENUM_EX(CallEndReasonCodes,NumCallEndReasons,
      EndedByLocalUser,0,            
      EndedByNoAccept,               
      EndedByAnswerDenied,           
      EndedByRemoteUser,             
      EndedByRefusal,                
      EndedByNoAnswer,               
      EndedByCallerAbort,            
      EndedByTransportFail,          
      EndedByConnectFail,            
      EndedByGatekeeper,             
      EndedByNoUser,                 
      EndedByNoBandwidth,            
      EndedByCapabilityExchange,     
      EndedByCallForwarded,          
      EndedBySecurityDenial,         
      EndedByLocalBusy,              
      EndedByLocalCongestion,        
      EndedByRemoteBusy,             
      EndedByRemoteCongestion,       
      EndedByUnreachable,            
      EndedByNoEndPoint,             
      EndedByHostOffline,            
      EndedByTemporaryFailure,       
      EndedByQ931Cause,              
      EndedByDurationLimit,          
      EndedByInvalidConferenceID,    
      EndedByNoDialTone,             
      EndedByNoRingBackTone,         
      EndedByOutOfService,           
      EndedByAcceptingCallWaiting,   
      EndedByGkAdmissionFailed,      
      EndedByMediaFailed,            
      EndedByCallCompletedElsewhere, 
      EndedByCertificateAuthority,   
      EndedByIllegalAddress,         
      EndedByCustomCode              
    );

    struct CallEndReason {
      CallEndReason(
        CallEndReasonCodes reason = NumCallEndReasons,
        unsigned cause = 0
      ) : code(reason), q931(cause) { }
      explicit CallEndReason(
        long reason
      ) : code((CallEndReasonCodes)(reason&0xff)), q931((reason>>8)&0xff) { }

      __inline operator CallEndReasonCodes() const { return code; }

      __inline int AsInteger() const { return code|(q931<<8); }

      CallEndReasonCodes code:8;    // Normalised OPAL code
      union
      {
        unsigned         q931:16;   // PSTN Interworking code, actually Q.850
        unsigned         custom:16; // Custom code
      };
    };

#if PTRACING
    friend ostream & operator<<(ostream & o, CallEndReason reason);
#endif

    P_DECLARE_TRACED_ENUM(AnswerCallResponse,
      AnswerCallNow,               
      AnswerCallDenied,            
      AnswerCallPending,           
      AnswerCallDeferred,          
      AnswerCallAlertWithMedia,    
      AnswerCallDeferredWithMedia, 
      AnswerCallProgress,          
      AnswerCallNowAndReleaseCurrent 
    );

    enum Options {
      FastStartOptionDisable       = 0x0001,   // H.323 specific
      FastStartOptionEnable        = 0x0002,
      FastStartOptionMask          = 0x0003,

      H245TunnelingOptionDisable   = 0x0004,   // H.323 specific
      H245TunnelingOptionEnable    = 0x0008,
      H245TunnelingOptionMask      = 0x000c,

      H245inSetupOptionDisable     = 0x0010,   // H.323 specific
      H245inSetupOptionEnable      = 0x0020,
      H245inSetupOptionMask        = 0x0030,

      DetectInBandDTMFOptionDisable = 0x0040,  // SIP and H.323
      DetectInBandDTMFOptionEnable  = 0x0080,
      DetectInBandDTMFOptionMask    = 0x00c0,

      RTPAggregationDisable        = 0x0100,   // SIP and H.323
      RTPAggregationEnable         = 0x0200,
      RTPAggregationMask           = 0x0300,

      SendDTMFAsDefault            = 0x0000,   // SIP and H.323
      SendDTMFAsString             = 0x0400,
      SendDTMFAsTone               = 0x0800,
      SendDTMFAsRFC2833            = 0x0c00,
      SendDTMFMask                 = 0x0c00,

      SynchronousSetUp             = 0x1000
    };

    class StringOptions : public PStringOptions 
    {
      public:
        StringOptions() { }
        StringOptions(const PString & str) : PStringOptions(str) { }

        void ExtractFromURL(
          PURL & url
        );

        void ExtractFromString(
          PString & str
        );
    };

    OpalConnection(
      OpalCall & call,                         
      OpalEndPoint & endpoint,                 
      const PString & token,                   
      unsigned options = 0,                    
      OpalConnection::StringOptions * stringOptions = NULL 
    );  

    ~OpalConnection();

    void PrintOn(
      ostream & strm    
    ) const;

    virtual bool IsNetworkConnection() const = 0;

    P_DECLARE_STREAMABLE_ENUM(Phases,
      UninitialisedPhase,   
      SetUpPhase,           
      ProceedingPhase,      
      AlertingPhase,        
      ConnectedPhase,       
      EstablishedPhase,     
      ForwardingPhase,      
      ReleasingPhase,       
      ReleasedPhase         
    );

    __inline Phases GetPhase() const { PWaitAndSignal mutex(m_phaseMutex); return m_phase; }

    __inline bool IsEstablished() const { return GetPhase() == EstablishedPhase; }

    __inline bool IsReleased() const { return GetPhase() >= ReleasingPhase; }

    void SetPhase(
      Phases phaseToSet  
    );

    CallEndReason GetCallEndReason() const;

    static PString GetCallEndReasonText(CallEndReason reason);
    PString GetCallEndReasonText() const { return GetCallEndReasonText(GetCallEndReason()); }

    static void SetCallEndReasonText(CallEndReasonCodes reasonCode, const PString & newText);

    virtual void SetCallEndReason(
      CallEndReason reason        
    );

    void ClearCall(
      CallEndReason reason = EndedByLocalUser, 
      PSyncPoint * sync = NULL
    );

    virtual void ClearCallSynchronous(
      PSyncPoint * sync,                       
      CallEndReason reason = EndedByLocalUser  
    );

    unsigned GetQ931Cause() const { return m_callEndReason.q931; }

    void SetQ931Cause(unsigned v) { m_callEndReason.q931 = v; }

    virtual bool TransferConnection(
      const PString & remoteParty   
    );
    
    virtual bool HoldRemote(
      bool placeOnHold  
    );

    virtual bool IsOnHold(
      bool fromRemote  
    ) const;

    virtual void OnHold(
      bool fromRemote,               
      bool onHold                    
    );

    virtual PBoolean OnIncomingConnection(unsigned int options, OpalConnection::StringOptions * stringOptions);

    virtual PBoolean SetUpConnection();

    virtual PBoolean OnSetUpConnection();

    
    virtual void OnProceeding();

    virtual void OnAlerting(
      bool withMedia      
    );
    virtual void OnAlerting(); // For backward compatibility

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

    virtual AnswerCallResponse OnAnswerCall(
      const PString & callerName        
    );

    virtual void AnsweringCall(
      AnswerCallResponse response 
    );

    virtual void OnConnected();

    virtual PBoolean SetConnected();

    virtual void OnEstablished();

    virtual bool OnTransferNotify(
      const PStringToString & info, 
      const OpalConnection * transferringConnection
    );

    virtual void Release(
      CallEndReason reason = EndedByLocalUser, 
      bool synchronous = false                 
    );

    virtual void OnReleased();

    virtual PString GetDestinationAddress();

    virtual PBoolean ForwardCall(
      const PString & forwardParty   
    );

    PSafePtr<OpalConnection> GetOtherPartyConnection() const;

    template <class cls> PSafePtr<cls> GetOtherPartyConnectionAs() const { return PSafePtrCast<OpalConnection, cls>(GetOtherPartyConnection()); }

    virtual OpalMediaFormatList GetMediaFormats() const;

    virtual OpalMediaFormatList GetLocalMediaFormats();

    virtual void AdjustMediaFormats(
      bool local,                             
      const OpalConnection * otherConnection, 
      OpalMediaFormatList & mediaFormats      
    ) const;

    virtual PStringArray GetMediaCryptoSuites() const;

    virtual unsigned GetNextSessionID(
      const OpalMediaType & mediaType,   
      bool isSource                      
    );

    virtual bool RequireSymmetricMediaStreams() const;

    virtual OpalMediaType::AutoStartMode GetAutoStart(
      const OpalMediaType & mediaType  
    ) const;

    virtual void AutoStartMediaStreams(
      bool transfer = false 
    );

#if OPAL_T38_CAPABILITY

    virtual bool SwitchFaxMediaStreams(
      bool toT38  
    );

    virtual void OnSwitchedFaxMediaStreams(
      bool toT38,       
      bool success      
    );

    virtual bool OnSwitchingFaxMediaStreams(
      bool toT38   
    );
#endif // OPAL_T38_CAPABILITY

    virtual OpalMediaStreamPtr OpenMediaStream(
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      bool isSource                        
    );

    bool CloseMediaStream(
      unsigned sessionId,  
      bool source          
    );

    bool CloseMediaStream(
      OpalMediaStreamPtr stream 
    );

    bool RemoveMediaStream(
      OpalMediaStream & strm  
    );

    virtual void StartMediaStreams();
    
    virtual void CloseMediaStreams();
    
    virtual void PauseMediaStreams(
      bool paused  
    );

    virtual void OnPauseMediaStream(
      OpalMediaStream & strm,     
      bool paused                 
    );

    virtual OpalMediaStream * CreateMediaStream(
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      PBoolean isSource                        
    );

    OpalMediaStreamPtr GetMediaStream(
      const PString & streamID,  
      bool source                
    ) const;

    OpalMediaStreamPtr GetMediaStream(
      unsigned sessionId,  
      bool source          
    ) const;

    OpalMediaStreamPtr GetMediaStream(
      const OpalMediaType & mediaType,    
      bool source,                        
      OpalMediaStreamPtr previous = NULL  
    ) const;

#if OPAL_STATISTICS
    bool GetStatistics(
      const OpalMediaType & mediaType,    
      bool source,                        
      OpalMediaStatistics & statistics    
    ) const;
#endif // OPAL_STATISTICS

    virtual PBoolean OnOpenMediaStream(
      OpalMediaStream & stream    
    );

    virtual void OnClosedMediaStream(
      const OpalMediaStream & stream     
    );

    virtual void OnFailedMediaStream(
      bool fromRemote,           
      const PString & reason     
    );

    virtual void OnPatchMediaStream(
      PBoolean isSource,        
      OpalMediaPatch & patch    
    );

    virtual void OnStartMediaPatch(
      OpalMediaPatch & patch    
    );

    virtual void OnStopMediaPatch(
      OpalMediaPatch & patch    
    );

    virtual bool OnMediaFailed(
      unsigned sessionId   
    );

    bool AllMediaFailed() const;

    virtual bool OnMediaCommand(
      OpalMediaStream & stream,         
      const OpalMediaCommand & command  
    );

    virtual bool ExecuteMediaCommand(
      const OpalMediaCommand & command, 
      bool aync = false                 
    ) const;

    virtual bool GetMediaTransportAddresses(
      OpalConnection & otherConnection,      
      unsigned sessionId,                    
      const OpalMediaType & mediaType,       
      OpalTransportAddressArray & transports 
    ) const;

    virtual PBoolean SetAudioVolume(
      PBoolean source,        
      unsigned percentage     
    );

    virtual PBoolean GetAudioVolume(
      PBoolean source,       
      unsigned & percentage  
    );

    virtual bool SetAudioMute(
      bool source,        
      bool mute           
    );

    virtual bool GetAudioMute(
      bool source,        
      bool & mute         
    );

    virtual unsigned GetAudioSignalLevel(
      PBoolean source                   
    );

    OpalBandwidth GetBandwidthAvailable(
      OpalBandwidth::Direction dir   
    ) const;

    virtual bool SetBandwidthAvailable(
      OpalBandwidth::Direction dir,     
      OpalBandwidth availableBandwidth  
    );

    virtual bool SetBandwidthAllocated(
      OpalBandwidth::Direction dir,  
      OpalBandwidth newBandwidth     
    );

    virtual OpalBandwidth GetBandwidthUsed(
      OpalBandwidth::Direction dir   
    ) const;

    virtual bool SetBandwidthUsed(
      OpalBandwidth::Direction dir,     
      OpalBandwidth releasedBandwidth,  
      OpalBandwidth requiredBandwidth   
    );

    P_DECLARE_TRACED_ENUM(SendUserInputModes,
      SendUserInputAsQ931,
      SendUserInputAsString,
      SendUserInputAsTone,
      SendUserInputAsRFC2833,
      SendUserInputAsInlineRFC2833 = SendUserInputAsRFC2833, // For backward compatibility
      SendUserInputInBand,
      SendUserInputAsProtocolDefault
    );

    virtual void SetSendUserInputMode(SendUserInputModes mode);

    virtual SendUserInputModes GetSendUserInputMode() const { return m_sendUserInputMode; }

    virtual SendUserInputModes GetRealSendUserInputMode() const { return GetSendUserInputMode(); }

    virtual PBoolean SendUserInputString(
      const PString & value                   
    );

    virtual PBoolean SendUserInputTone(
      char tone,              
      unsigned duration = 0   
    );

    virtual void OnUserInputString(
      const PString & value   
    );
    void OnUserInputStringCallback(PString value) { OnUserInputString(value); }

    virtual void OnUserInputTone(
      char tone,          
      unsigned duration   
    );

    void SendUserInputHookFlash(
      unsigned duration = 500  
    ) { SendUserInputTone('!', duration); }

    virtual PString GetUserInput(
      unsigned timeout = 30   
    );

    virtual void SetUserInput(
      const PString & input     
    );

    virtual PString ReadUserInput(
      const char * terminators = "YX#\r\n", 
      unsigned lastDigitTimeout = 4,      
      unsigned firstDigitTimeout = 30     
    );

    virtual PBoolean PromptUserInput(
      PBoolean play   
    );

    virtual bool GetConferenceState(
      OpalConferenceState * state  
    ) const;

    virtual bool RequestPresentationRole(
      bool release   
    );

    virtual bool OnChangedPresentationRole(
      const PString & newChairURI,   
      bool request                   
    );

    virtual bool HasPresentationRole() const;

    virtual bool GarbageCollection();

    OpalEndPoint & GetEndPoint() const { return m_endpoint; }
    
    OpalCall & GetCall() const { return m_ownerCall; }

    const PString & GetToken() const { return m_callToken; }

    virtual void SetToken(
      const PString & newToken
    );

    PBoolean IsOriginating() const { return m_originating; }

    const PTime & GetPhaseTime(Phases phase) const { return m_phaseTime[phase]; }

    const PTime & GetSetupUpTime() const { return m_phaseTime[SetUpPhase]; }

    const PTime & GetAlertingTime() const { return m_phaseTime[AlertingPhase]; }

    const PTime & GetConnectionStartTime() const { return m_phaseTime[ConnectedPhase]; }

    const PTime & GetConnectionEndTime() const { return m_phaseTime[ReleasingPhase]; }

    const OpalProductInfo & GetProductInfo() const { return m_productInfo; }

    void SetProductInfo(
      const OpalProductInfo & info
    ) { m_productInfo = info; }

    virtual PString GetPrefixName() const;

    const PString & GetLocalPartyName() const { return m_localPartyName; }

    virtual void SetLocalPartyName(const PString & name);

    virtual PString GetLocalPartyURL() const;

    const PString & GetDisplayName() const { return m_displayName; }

    void SetDisplayName(const PString & name) { m_displayName = name; }

    virtual bool IsPresentationBlocked() const;

    const PString & GetRemotePartyName() const { return m_remotePartyName; }

    void SetRemotePartyName(const PString & name) { m_remotePartyName = name; }

    const PString & GetRemotePartyNumber() const { return m_remotePartyNumber; }

    virtual OpalTransportAddress GetRemoteAddress() const { return OpalTransportAddress(); }

    virtual PString GetRemotePartyURL() const;

    virtual PString GetRemoteIdentity() const { return GetRemotePartyURL(); }

    // Deprecated - backward compatibility only
    P_DEPRECATED PString GetRemotePartyAddress() const { return GetRemotePartyURL(); }

    // Deprecated - backward compatibility only
    P_DEPRECATED const PString GetRemotePartyCallbackURL() const { return GetRemotePartyURL(); }

    PCaselessString GetRemoteApplication() const { return m_remoteProductInfo.AsString(); }

    const OpalProductInfo & GetRemoteProductInfo() const { return m_remoteProductInfo; }

    void SetRemoteProductInfo(const OpalProductInfo & info) { m_remoteProductInfo = info; }

    const PString & GetRedirectingParty() const { return m_redirectingParty; }

    void SetRedirectingParty(const PString & party) { m_redirectingParty = party; }

    const PString & GetCalledPartyName() const { return m_calledPartyName; }

    void SetCalledPartyName(const PString & name) { m_calledPartyName = name; }

    const PString & GetCalledPartyNumber() const { return m_calledPartyNumber; }

    virtual PString GetCalledPartyURL();

    virtual PMultiPartList GetExtraCallInfo() const { return PMultiPartList(); }

    /* Internal function to copy party names from "network" connection to
       "non-network" connection such as OpalPCSSConnection. This allows
       the non-network GetRemoteAddress() function and its ilk to return
       the intuitive value, i.e. the value from the OTHER connection.
     */
    void CopyPartyNames(const OpalConnection & other);


    virtual PString GetAlertingType() const;

    virtual bool SetAlertingType(const PString & info);

    virtual PString GetCallInfo() const;

    virtual PString GetSupportedFeatures() const;

    unsigned GetMinAudioJitterDelay() const { return m_jitterParams.m_minJitterDelay; }

    unsigned GetMaxAudioJitterDelay() const { return m_jitterParams.m_maxJitterDelay; }

    void SetAudioJitterDelay(
      unsigned minDelay,   
      unsigned maxDelay    
    );

    OpalSilenceDetector * GetSilenceDetector() const { return m_silenceDetector; }
    
#if OPAL_AEC

    OpalEchoCanceler * GetEchoCanceler() const { return m_echoCanceler; }
#endif

    virtual PString GetIdentifier() const;

    virtual PINDEX GetMaxRtpPayloadSize() const;

    const StringOptions & GetStringOptions() const { return m_stringOptions; }

    void SetStringOptions(
      const StringOptions & options,
      bool overwrite
    );

    virtual void OnApplyStringOptions();

#if OPAL_HAS_MIXER
    virtual void EnableRecording();
    virtual void DisableRecording();

    PDECLARE_NOTIFIER(RTP_DataFrame, OpalConnection, OnRecordAudio);
    void InternalOnRecordAudio(PString key, PAutoPtr<RTP_DataFrame> frame);
#if OPAL_VIDEO
    PDECLARE_NOTIFIER(RTP_DataFrame, OpalConnection, OnRecordVideo);
    void InternalOnRecordVideo(PString key, PAutoPtr<RTP_DataFrame> frame);
#endif

    virtual void OnStartRecording(OpalMediaPatch * patch);
    virtual void OnStopRecording(OpalMediaPatch * patch);
#endif

    bool InternalOnConnected();
    bool InternalOnEstablished();
    void InternalSetAsOriginating();

    bool InternalRelease(CallEndReason reason);
    void InternalOnReleased();
    void InternalExecuteMediaCommand(OpalMediaCommand * command);

    void InternalCreatedMediaTransport(const OpalMediaTransportPtr & transport) { m_mediaTransports.Append(transport); }

  protected:
  // Member variables
    OpalCall           & m_ownerCall;
    OpalEndPoint       & m_endpoint;

  private:
    PDECLARE_MUTEX(      m_phaseMutex);
    Phases               m_phase;

  protected:
    PString              m_callToken;
    PBoolean             m_originating;
    OpalProductInfo      m_productInfo;
    PString              m_localPartyName;
    PString              m_displayName;
    PString              m_remotePartyName;
    PString              m_remotePartyURL;
    OpalProductInfo      m_remoteProductInfo;
    PString              m_remotePartyNumber;
    PString              m_redirectingParty;
    CallEndReason        m_callEndReason;
    PString              m_calledPartyNumber;
    PString              m_calledPartyName;

    SendUserInputModes   m_sendUserInputMode;
    PString              m_userInputString;
    PSyncPoint           m_userInputAvailable;

    OpalSilenceDetector * m_silenceDetector;
#if OPAL_AEC
    OpalEchoCanceler    * m_echoCanceler;
#endif
    OpalMediaFormat       m_filterMediaFormat;

    OpalMediaFormatList        m_localMediaFormats;

    struct StreamKey : PKey<uint64_t>
    {
      StreamKey(unsigned sessionID, bool isSource)
        : PKey<uint64_t>(sessionID + (isSource ? 0x100000000ULL : 0x200000000ULL))
      { }
      StreamKey(const OpalMediaStream & stream)
        : PKey<uint64_t>(stream.GetSessionID() + (stream.IsSource() ? 0x100000000ULL : 0x200000000ULL))
      { }
      PObject * Clone() const { return new StreamKey(*this); }
    };
    typedef PSafeDictionary<StreamKey, OpalMediaStream> StreamDict;
    StreamDict m_mediaStreams;

    PSafeList<OpalMediaTransport> m_mediaTransports;

    OpalJitterBuffer::Params m_jitterParams;

    OpalBandwidth       m_rxBandwidthAvailable;
    OpalBandwidth       m_txBandwidthAvailable;

    // The In-Band DTMF detector. This is used inside an audio filter which is
    // added to the audio channel.
#if OPAL_PTLIB_DTMF
    PDTMFDecoder m_dtmfDecoder;
    bool         m_detectInBandDTMF;
    unsigned     m_dtmfScaleMultiplier;
    unsigned     m_dtmfScaleDivisor;
    PNotifier    m_dtmfDetectNotifier;
    PDECLARE_NOTIFIER(RTP_DataFrame, OpalConnection, OnDetectInBandDTMF);

    bool            m_sendInBandDTMF;
    OpalMediaFormat m_dtmfSendFormat;
    PBYTEArray      m_inBandDTMF;
    PINDEX          m_emittedInBandDTMF;
    PDECLARE_MUTEX(m_inBandMutex);
    PNotifier       m_dtmfSendNotifier;
    PDECLARE_NOTIFIER(RTP_DataFrame, OpalConnection, OnSendInBandDTMF);
#endif

    StringOptions m_stringOptions;

#if OPAL_HAS_MIXER
    PString       m_recordingFilename;
    PNotifier     m_recordAudioNotifier;
#if OPAL_VIDEO
    PNotifier     m_recordVideoNotifier;
#endif
#endif

    OpalMediaType::AutoStartMap m_autoStartInfo;

#if OPAL_SCRIPT
    PString m_scriptTableName;
    PDECLARE_ScriptFunctionNotifier(OpalConnection, ScriptRelease);
    PDECLARE_ScriptFunctionNotifier(OpalConnection, ScriptSetOption);
    PDECLARE_ScriptFunctionNotifier(OpalConnection, ScriptGetLocalPartyURL);
    PDECLARE_ScriptFunctionNotifier(OpalConnection, ScriptGetRemotePartyURL);
    PDECLARE_ScriptFunctionNotifier(OpalConnection, ScriptGetCalledPartyURL);
    PDECLARE_ScriptFunctionNotifier(OpalConnection, ScriptGetRedirectingParty);
#endif // OPAL_SCRIPT

    // A version of PTime where default constructor creates invalid times
    class ZeroTime : public PTime
    {
      public:
        ZeroTime() : PTime(0) { }
    };
    ZeroTime m_phaseTime[NumPhases];

    std::set<unsigned> m_mediaSessionFailed;
    PDECLARE_MUTEX(    m_mediaSessionFailedMutex);


  private:
    P_REMOVE_VIRTUAL(PBoolean, OnIncomingConnection(unsigned int), false);
    P_REMOVE_VIRTUAL(PBoolean, OnIncomingConnection(), false);
    P_REMOVE_VIRTUAL(PBoolean, IsConnectionOnHold(), false);
    P_REMOVE_VIRTUAL_VOID(OnMediaPatchStart(unsigned, bool));
    P_REMOVE_VIRTUAL_VOID(OnMediaPatchStop(unsigned, bool));
    P_REMOVE_VIRTUAL_VOID(AdjustMediaFormats(OpalMediaFormatList &) const);
    P_REMOVE_VIRTUAL_VOID(AdjustMediaFormats(OpalMediaFormatList &, OpalConnection *) const);
    P_REMOVE_VIRTUAL_VOID(AdjustMediaFormats(bool,OpalMediaFormatList &,OpalConnection *) const);
    P_REMOVE_VIRTUAL_VOID(PreviewPeerMediaFormats(const OpalMediaFormatList &));
    P_REMOVE_VIRTUAL(bool, HoldConnection(), false);
    P_REMOVE_VIRTUAL(bool, RetrieveConnection(), false);
    P_REMOVE_VIRTUAL(bool, IsConnectionOnHold(bool), false);
    P_REMOVE_VIRTUAL_VOID(ApplyStringOptions(OpalConnection::StringOptions &));
    P_REMOVE_VIRTUAL(PBoolean, IsMediaBypassPossible(unsigned) const, false);
    P_REMOVE_VIRTUAL(bool, OnTransferNotify(const PStringToString &), false);
    P_REMOVE_VIRTUAL(OpalMediaSession *, CreateMediaSession(unsigned, const OpalMediaType &), NULL);
    P_REMOVE_VIRTUAL(PBoolean, SetBandwidthAvailable(unsigned, PBoolean), false);
    P_REMOVE_VIRTUAL(unsigned, GetBandwidthUsed() const, 0);
    P_REMOVE_VIRTUAL(PBoolean, SetBandwidthUsed(unsigned, unsigned), false);
    P_REMOVE_VIRTUAL_VOID(OnSwitchedFaxMediaStreams(bool));
    P_REMOVE_VIRTUAL(bool, CloseMediaStream(OpalMediaStream &),false);
    P_REMOVE_VIRTUAL(bool,GetMediaTransportAddresses(const OpalMediaType&,OpalTransportAddressArray&) const,false);
    P_REMOVE_VIRTUAL(bool,GetMediaTransportAddresses(OpalConnection&,const OpalMediaType&,OpalTransportAddressArray &) const,false);
#if OPAL_PTLIB_NAT
    P_REMOVE_VIRTUAL(PNatMethod *, GetNatMethod(const PIPSocket::Address &) const,NULL);
#endif
    P_REMOVE_VIRTUAL(bool,Hold(bool,bool),false);
    P_REMOVE_VIRTUAL(bool,ExecuteMediaCommand(const OpalMediaCommand &,unsigned,const OpalMediaType &) const,0);
    P_REMOVE_VIRTUAL(bool,OnMediaFailed(unsigned,bool),false);
};

#endif // OPAL_OPAL_CONNECTION_H


// End of File ///////////////////////////////////////////////////////////////