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
 *
 * $Revision: 30972 $
 * $Author: rjongbloed $
 * $Date: 2013-11-26 10:02:24 +1100 (Tue, 26 Nov 2013) $
 */

#ifndef OPAL_OPAL_CONNECTION_H
#define OPAL_OPAL_CONNECTION_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#include <opal/mediafmt.h>
#include <opal/mediastrm.h>
#include <opal/guid.h>
#include <opal/transports.h>
#include <ptclib/dtmf.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_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_ORIGINATOR_ADDRESS   "Originator-Address"    
#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_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_DEFAULT 3



class OpalProductInfo
{
  public:
    OpalProductInfo();

    static OpalProductInfo & Default();

    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;

  private:
    OpalProductInfo(bool);
};


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          
    );

    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
      unsigned           q931:8; // PSTN Interworking code, actually Q.850
    };

#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
    };

    class StringOptions : public PStringOptions 
    {
      public:
        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_TRACED_ENUM(Phases,
      UninitialisedPhase,   
      SetUpPhase,           
      ProceedingPhase,      
      AlertingPhase,        
      ConnectedPhase,       
      EstablishedPhase,     
      ForwardingPhase,      
      ReleasingPhase,       
      ReleasedPhase         
    );

    __inline Phases GetPhase() const { return m_phase; }

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

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

    void SetPhase(
      Phases phaseToSet  
    );

    CallEndReason GetCallEndReason() const { return callEndReason; }

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

    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 callEndReason.q931; }

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

    virtual bool TransferConnection(
      const PString & remoteParty   
    );
    
    virtual bool Hold(
      bool fromRemote,  
      bool placeOnHold  
    );

    virtual bool IsOnHold(
      bool fromRemote  
    );

    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();

    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 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 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;

    virtual PBoolean OnOpenMediaStream(
      OpalMediaStream & stream    
    );

    virtual void OnClosedMediaStream(
      const OpalMediaStream & stream     
    );

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

    virtual void OnStartMediaPatch(
      OpalMediaPatch & patch    
    );

    virtual void OnStopMediaPatch(
      OpalMediaPatch & patch    
    );

    virtual bool OnMediaFailed(
      unsigned sessionId,  
      bool source          
    );

    bool AllMediaFailed() const;

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

    virtual bool ExecuteMediaCommand(
      const OpalMediaCommand & command, 
      unsigned sessionID = 0,           
      const OpalMediaType & mediaType = OpalMediaType() 
    ) const;

#if P_NAT
    // Get Nat Method in use
    virtual PNatMethod * GetNatMethod(
      const PIPSocket::Address & remoteAddress = PIPSocket::GetDefaultIpAny()
    ) const;
#endif

    virtual bool GetMediaTransportAddresses(
      const OpalMediaType & mediaType,       
      OpalTransportAddressArray & transports 
    ) const;

#if OPAL_VIDEO

    virtual PBoolean CreateVideoInputDevice(
      const OpalMediaFormat & mediaFormat,  
      PVideoInputDevice * & device,         
      PBoolean & autoDelete                     
    );

    virtual PBoolean CreateVideoOutputDevice(
      const OpalMediaFormat & mediaFormat,  
      PBoolean preview,                         
      PVideoOutputDevice * & device,        
      PBoolean & autoDelete                     
    );

    virtual bool ChangeVideoInputDevice(
      const PVideoDevice::OpenArgs & device,  
      unsigned sessionID = 0                  
    );

    virtual bool ChangeVideoOutputDevice(
      const PVideoDevice::OpenArgs & device,  
      unsigned sessionID = 0,                 
      bool preview = false                    
    );

    virtual bool SendVideoUpdatePicture(
      unsigned sessionID = 0, 
      bool force = false      
    ) const;
    void SendVideoUpdatePictureCallback(unsigned sessionID, bool force) { SendVideoUpdatePicture(sessionID, force); }

    virtual void OnRxIntraFrameRequest(
      const OpalMediaSession & session,   
      bool force                          
    );
#endif

    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 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 endpoint; }
    
    OpalCall & GetCall() const { return ownerCall; }

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

    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 productInfo; }

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

    virtual PString GetPrefixName() const;

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

    virtual void SetLocalPartyName(const PString & name);

    virtual PString GetLocalPartyURL() const;

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

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

    virtual bool IsPresentationBlocked() const;

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

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

    const PString & GetRemotePartyNumber() const { return 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 remoteProductInfo.AsString(); }

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

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

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

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

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

    virtual PString GetCalledPartyURL();

    /* 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;

    unsigned GetMinAudioJitterDelay() const { return m_minAudioJitterDelay; }

    unsigned GetMaxAudioJitterDelay() const { return m_maxAudioJitterDelay; }

    void SetAudioJitterDelay(
      unsigned minDelay,   
      unsigned maxDelay    
    );

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

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

    virtual PString GetIdentifier() const;

    virtual PINDEX GetMaxRtpPayloadSize() const;

#if OPAL_STATISTICS

    unsigned GetVideoUpdateRequestsSent() const { return m_VideoUpdateRequestsSent; }
#endif


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

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

    virtual void OnApplyStringOptions();

#if OPAL_HAS_MIXER

    virtual void EnableRecording();
    virtual void DisableRecording();

#endif

  protected:
    void OnConnectedInternal();
    void InternalSetAsOriginating();

    void InternalOnReleased();

#if OPAL_HAS_MIXER
    PDECLARE_NOTIFIER(RTP_DataFrame, OpalConnection, OnRecordAudio);
#if OPAL_VIDEO
    PDECLARE_NOTIFIER(RTP_DataFrame, OpalConnection, OnRecordVideo);
#endif
    void OnStartRecording(OpalMediaPatch * patch);
    void OnStopRecording(OpalMediaPatch * patch);
#endif

  // Member variables
    OpalCall             & ownerCall;
    OpalEndPoint         & endpoint;

  private:
    PMutex               m_phaseMutex;
    Phases               m_phase;

  protected:
    PString              callToken;
    PBoolean             m_originating;
    OpalProductInfo      productInfo;
    PString              localPartyName;
    PString              displayName;
    PString              remotePartyName;
    PString              m_remotePartyURL;
    OpalProductInfo      remoteProductInfo;
    PString              remotePartyNumber;
    PString              m_redirectingParty;
    CallEndReason        callEndReason;
    PString              m_calledPartyNumber;
    PString              m_calledPartyName;

    SendUserInputModes    sendUserInputMode;
    PString               userInputString;
    PSyncPoint            userInputAvailable;

    OpalSilenceDetector * silenceDetector;
#if OPAL_AEC
    OpalEchoCanceler    * echoCanceler;
#endif
    OpalMediaFormat       m_filterMediaFormat;

    OpalMediaFormatList        m_localMediaFormats;
    PSafeList<OpalMediaStream> mediaStreams;

    unsigned            m_minAudioJitterDelay;
    unsigned            m_maxAudioJitterDelay;
    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;
    PMutex          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

#if OPAL_STATISTICS
    unsigned m_VideoUpdateRequestsSent;
#endif

    struct AutoStartInfo {
      unsigned preferredSessionId;  // preferred session ID (only used for originating)
      OpalMediaType::AutoStartMode autoStart;// Mode for this session when the call is started
    };

    class AutoStartMap : public std::map<OpalMediaType, AutoStartInfo>
    {
      public:
        AutoStartMap();
        void Initialise(const OpalConnection::StringOptions & stringOptions);
        OpalMediaType::AutoStartMode GetAutoStart(const OpalMediaType & mediaType) const;

      protected:
        void SetAutoStart(const PString & mediaType, OpalMediaType::AutoStartMode autoStart);

        PMutex m_mutex;
    };
    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::vector<bool> m_mediaSessionFailed;


  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);
};

#endif // OPAL_OPAL_CONNECTION_H


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