manager.h

Go to the documentation of this file.

/*
 * manager.h
 *
 * OPAL system manager.
 *
 * 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): ______________________________________.
 *
 * $Log: manager.h,v $
 * Revision 2.66  2007/09/21 01:34:09  rjongbloed
 * Rewrite of SIP transaction handling to:
 *   a) use PSafeObject and safe collections
 *   b) only one database of transactions, remove connection copy
 *   c) fix timers not always firing due to bogus deadlock avoidance
 *   d) cleaning up only occurs in the existing garbage collection thread
 *   e) use of read/write mutex on endpoint list to avoid possible deadlock
 *
 * Revision 2.65  2007/09/18 09:37:52  rjongbloed
 * Propagated call backs for RTP statistics through OpalManager and OpalCall.
 *
 * Revision 2.64  2007/07/20 05:49:57  rjongbloed
 * Added member variable for stun server name in OpalManager, so can be remembered
 *   in original form so change in IP address or temporary STUN server failures do not
 *   lose the server being selected by the user.
 *
 * Revision 2.63  2007/06/29 06:59:56  rjongbloed
 * Major improvement to the "product info", normalising H.221 and User-Agent mechanisms.
 *
 * Revision 2.62  2007/05/15 07:26:38  csoutheren
 * Remove deprecated  interface to STUN server in H323Endpoint
 * Change UseNATForIncomingCall to IsRTPNATEnabled
 * Various cleanups of messy and unused code
 *
 * Revision 2.61  2007/05/15 05:24:50  csoutheren
 * Add UseNATForIncomingCall override so applications can optionally implement their own NAT activation strategy
 *
 * Revision 2.60  2007/05/07 14:13:51  csoutheren
 * Add call record capability
 *
 * Revision 2.59  2007/04/18 00:00:44  csoutheren
 * Add hooks for recording call audio
 *
 * Revision 2.58  2007/03/13 00:32:16  csoutheren
 * Simple but messy changes to allow compile time removal of protocol
 * options such as H.450 and H.460
 * Fix MakeConnection overrides
 *
 * Revision 2.57  2007/03/01 03:37:37  csoutheren
 * Fix typo
 *
 * Revision 2.56  2007/01/25 11:48:10  hfriederich
 * OpalMediaPatch code refactorization.
 * Split into OpalMediaPatch (using a thread) and OpalPassiveMediaPatch
 * (not using a thread). Also adds the possibility for source streams
 * to push frames down to the sink streams instead of having a patch
 * thread around.
 *
 * Revision 2.55  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 2.54  2006/12/18 03:18:41  csoutheren
 * Messy but simple fixes
 *   - Add access to SIP REGISTER timeout
 *   - Ensure OpalConnection options are correctly progagated
 *
 * Revision 2.53  2006/12/08 04:22:06  csoutheren
 * Applied 1589261 - new release cause for fxo endpoints
 * Thanks to Frederic Heem
 *
 * Revision 2.52  2006/11/20 03:37:12  csoutheren
 * Allow optional inclusion of RTP aggregation
 *
 * Revision 2.51  2006/11/19 06:02:58  rjongbloed
 * Moved function that reads User Input into a destination address to
 *   OpalManager so can be easily overidden in applications.
 *
 * Revision 2.50  2006/10/10 07:18:18  csoutheren
 * Allow compilation with and without various options
 *
 * Revision 2.49  2006/09/28 07:42:17  csoutheren
 * Merge of useful SRTP implementation
 *
 * Revision 2.48  2006/06/21 23:43:27  csoutheren
 * Fixed comment on OpalManager::SetTranslationAddress
 *
 * Revision 2.47  2006/06/21 04:54:15  csoutheren
 * Fixed build with latest PWLib
 *
 * Revision 2.46  2006/04/20 16:52:22  hfriederich
 * Adding support for H.224/H.281
 *
 * Revision 2.45  2005/11/30 13:35:26  csoutheren
 * Changed tags for Doxygen
 *
 * Revision 2.44  2005/11/24 20:31:54  dsandras
 * Added support for echo cancelation using Speex.
 * Added possibility to add a filter to an OpalMediaPatch for all patches of a connection.
 *
 * Revision 2.43  2005/10/08 19:26:38  dsandras
 * Added OnForwarded callback in case of call forwarding.
 *
 * Revision 2.42  2005/09/20 07:25:43  csoutheren
 * Allow userdata to be passed from SetupCall through to Call and Connection constructors
 *
 * Revision 2.41  2005/08/24 10:43:51  rjongbloed
 * Changed create video functions yet again so can return pointers that are not to be deleted.
 *
 * Revision 2.40  2005/08/23 12:45:09  rjongbloed
 * Fixed creation of video preview window and setting video grab/display initial frame size.
 *
 * Revision 2.39  2005/07/14 08:51:18  csoutheren
 * Removed CreateExternalRTPAddress - it's not needed because you can override GetMediaAddress
 * to do the same thing
 * Fixed problems with logic associated with media bypass
 *
 * Revision 2.38  2005/07/11 06:52:16  csoutheren
 * Added support for outgoing calls using external RTP
 *
 * Revision 2.37  2005/07/11 01:52:24  csoutheren
 * Extended AnsweringCall to work for SIP as well as H.323
 * Fixed problems with external RTP connection in H.323
 * Added call to OnClosedMediaStream
 *
 * Revision 2.36  2005/07/09 06:57:20  rjongbloed
 * Changed SetSTUNServer so returns the determined NAT type.
 *
 * Revision 2.35  2005/06/13 23:13:53  csoutheren
 * Fixed various typos thanks to Julien PUYDT
 *
 * Revision 2.34  2005/05/25 17:04:08  dsandras
 * Fixed ClearAllCalls when being executed synchronously. Fixes a crash on exit when a call is in progress. Thanks Robert!
 *
 * Revision 2.33  2005/04/10 20:46:56  dsandras
 * Added callback that is called when a connection is put on hold (locally or remotely).
 *
 * Revision 2.32  2005/01/31 07:37:09  csoutheren
 * Fixed problem with compiling under gcc 3.4
 * Thanks to Peter Robinson
 *
 * Revision 2.31  2004/12/21 08:24:31  dsandras
 * The dictionnary key is a PString, not an OpalGloballyUniqueID. Fixes problem when doing several calls at the same time.
 *
 * Revision 2.30  2004/08/18 13:02:48  rjongbloed
 * Changed to make calling OPalManager::OnClearedCall() in override optional.
 *
 * Revision 2.29  2004/08/14 07:56:29  rjongbloed
 * Major revision to utilise the PSafeCollection classes for the connections and calls.
 *
 * Revision 2.28  2004/07/14 13:26:14  rjongbloed
 * Fixed issues with the propagation of the "established" phase of a call. Now
 *   calling an OnEstablished() chain like OnAlerting() and OnConnected() to
 *   finally arrive at OnEstablishedCall() on OpalManager
 *
 * Revision 2.27  2004/07/11 12:42:10  rjongbloed
 * Added function on endpoints to get the list of all media formats any
 *   connection the endpoint may create can support.
 *
 * Revision 2.26  2004/07/04 12:50:50  rjongbloed
 * Added some access functions to manager lists
 *
 * Revision 2.25  2004/06/05 14:34:44  rjongbloed
 * Added functions to set the auto start video tx/rx flags.
 *
 * Revision 2.24  2004/05/24 13:40:12  rjongbloed
 * Added default values for silence suppression parameters.
 *
 * Revision 2.23  2004/05/15 12:53:03  rjongbloed
 * Added default username and display name to manager, for all endpoints.
 *
 * Revision 2.22  2004/04/18 07:09:12  rjongbloed
 * Added a couple more API functions to bring OPAL into line with similar functions in OpenH323.
 *
 * Revision 2.21  2004/03/11 06:54:27  csoutheren
 * Added ability to disable SIP or H.323 stacks
 *
 * Revision 2.20  2004/02/24 11:37:01  rjongbloed
 * More work on NAT support, manual external address translation and STUN
 *
 * Revision 2.19  2004/02/19 10:47:01  rjongbloed
 * Merged OpenH323 version 1.13.1 changes.
 *
 * Revision 2.18  2004/01/18 15:36:07  rjongbloed
 * Added stun support
 *
 * Revision 2.17  2003/03/17 10:26:59  robertj
 * Added video support.
 *
 * Revision 2.16  2003/03/06 03:57:47  robertj
 * IVR support (work in progress) requiring large changes everywhere.
 *
 * Revision 2.15  2002/11/10 11:33:17  robertj
 * Updated to OpenH323 v1.10.3
 *
 * Revision 2.14  2002/09/16 02:52:35  robertj
 * Added #define so can select if #pragma interface/implementation is used on
 *   platform basis (eg MacOS) rather than compiler, thanks Robert Monaghan.
 *
 * Revision 2.13  2002/09/06 02:44:09  robertj
 * Added routing table system to route calls by regular expressions.
 *
 * Revision 2.12  2002/09/04 06:01:47  robertj
 * Updated to OpenH323 v1.9.6
 *
 * Revision 2.11  2002/07/01 04:56:31  robertj
 * Updated to OpenH323 v1.9.1
 *
 * Revision 2.10  2002/04/10 08:15:31  robertj
 * Added functions to set ports.
 *
 * Revision 2.9  2002/02/19 07:42:50  robertj
 * Restructured media bypass functions to fix problems with RFC2833.
 *
 * Revision 2.8  2002/02/11 07:38:55  robertj
 * Added media bypass for streams between compatible protocols.
 *
 * Revision 2.7  2002/01/22 05:04:58  robertj
 * Revamp of user input API triggered by RFC2833 support
 *
 * Revision 2.6  2001/12/07 08:56:19  robertj
 * Renamed RTP to be more general UDP port base, and TCP to be IP.
 *
 * Revision 2.5  2001/11/14 01:31:55  robertj
 * Corrected placement of adjusting media format list.
 *
 * Revision 2.4  2001/11/13 06:25:56  robertj
 * Changed SetUpConnection() so returns BOOL as returning
 *   pointer to connection is not useful.
 *
 * Revision 2.3  2001/08/23 05:51:17  robertj
 * Completed implementation of codec reordering.
 *
 * Revision 2.2  2001/08/17 08:23:59  robertj
 * Changed OnEstablished() to OnEstablishedCall() to be consistent.
 * Moved call end reasons enum from OpalConnection to global.
 *
 * Revision 2.1  2001/08/01 05:52:55  robertj
 * Moved media formats list from endpoint to connection.
 * Added function to adjust calls media formats list.
 *
 * Revision 2.0  2001/07/27 15:48:24  robertj
 * Conversion of OpenH323 to Open Phone Abstraction Library (OPAL)
 *
 */

#ifndef __OPAL_MANAGER_H
#define __OPAL_MANAGER_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#include <opal/call.h>
#include <opal/connection.h> //OpalConnection::AnswerCallResponse
#include <opal/guid.h>
#include <opal/audiorecord.h>
#include <codec/silencedetect.h>
#include <codec/echocancel.h>
#include <ptclib/pstun.h>

#if OPAL_VIDEO
#include <ptlib/videoio.h>
#endif

class OpalEndPoint;
class OpalMediaPatch;
class OpalH224Handler;
class OpalH281Handler;


class OpalManager : public PObject
{
    PCLASSINFO(OpalManager, PObject);
  public:
    OpalManager();

    ~OpalManager();

    void AttachEndPoint(
      OpalEndPoint * endpoint
    );

    void DetachEndPoint(
      OpalEndPoint * endpoint
    );

    OpalEndPoint * FindEndPoint(
      const PString & prefix
    );

    const PList<OpalEndPoint> & GetEndPoints() const { return endpoints; }

    virtual BOOL SetUpCall(
      const PString & partyA,       
      const PString & partyB,       
      PString & token,              
      void * userData = NULL,       
      unsigned options = 0,         
      OpalConnection::StringOptions * stringOptions = NULL   
    );

    virtual void OnEstablishedCall(
      OpalCall & call   
    );

    virtual BOOL HasCall(
      const PString & token  
    ) { return activeCalls.FindWithLock(token, PSafeReference) != NULL; }

    virtual BOOL IsCallEstablished(
      const PString & token  
    );

    PSafePtr<OpalCall> FindCallWithLock(
      const PString & token,  
      PSafetyMode mode = PSafeReadWrite
    ) { return activeCalls.FindWithLock(token, mode); }

    virtual BOOL ClearCall(
      const PString & token,    
      OpalConnection::CallEndReason reason = OpalConnection::EndedByLocalUser, 
      PSyncPoint * sync = NULL  
    );

    virtual BOOL ClearCallSynchronous(
      const PString & token,    
      OpalConnection::CallEndReason reason = OpalConnection::EndedByLocalUser 
    );

    virtual void ClearAllCalls(
      OpalConnection::CallEndReason reason = OpalConnection::EndedByLocalUser, 
      BOOL wait = TRUE   
    );

    virtual void OnClearedCall(
      OpalCall & call   
    );

    virtual OpalCall * CreateCall();
    virtual OpalCall * CreateCall(
      void * userData            
    );

    virtual void DestroyCall(
      OpalCall * call
    );

    PString GetNextCallToken();

    virtual BOOL MakeConnection(
      OpalCall & call,                   
      const PString & party,             
      void * userData = NULL,            
      unsigned int options = 0,          
      OpalConnection::StringOptions * stringOptions = NULL
    );

    virtual BOOL OnIncomingConnection(
      OpalConnection & connection,   
      unsigned options,              
      OpalConnection::StringOptions * stringOptions
    );
    virtual BOOL OnIncomingConnection(
      OpalConnection & connection,   
      unsigned options               
    );
    virtual BOOL OnIncomingConnection(
      OpalConnection & connection   
    );

    virtual PString OnRouteConnection(
      OpalConnection & connection  
    );

    virtual void OnAlerting(
      OpalConnection & connection   
    );

    virtual OpalConnection::AnswerCallResponse
       OnAnswerCall(OpalConnection & connection,
                     const PString & caller
    );

    virtual void OnConnected(
      OpalConnection & connection   
    );

    virtual void OnEstablished(
      OpalConnection & connection   
    );

    virtual void OnReleased(
      OpalConnection & connection   
    );
    
    virtual void OnHold(
      OpalConnection & connection   
    );

    virtual BOOL OnForwarded(
      OpalConnection & connection,  
      const PString & remoteParty         
    );

    virtual void AdjustMediaFormats(
      const OpalConnection & connection,  
      OpalMediaFormatList & mediaFormats  
    ) const;

    virtual BOOL IsMediaBypassPossible(
      const OpalConnection & source,      
      const OpalConnection & destination, 
      unsigned sessionID                  
    ) const;

    virtual BOOL OnOpenMediaStream(
      OpalConnection & connection,  
      OpalMediaStream & stream    
    );

    virtual void OnRTPStatistics(
      const OpalConnection & connection,  
      const RTP_Session & session         
    );

    virtual void OnClosedMediaStream(
      const OpalMediaStream & stream     
    );

#if OPAL_VIDEO

    virtual void AddVideoMediaFormats(
      OpalMediaFormatList & mediaFormats, 
      const OpalConnection * connection = NULL  
    ) const;

    virtual BOOL CreateVideoInputDevice(
      const OpalConnection & connection,    
      const OpalMediaFormat & mediaFormat,  
      PVideoInputDevice * & device,         
      BOOL & autoDelete                     
    );

    virtual BOOL CreateVideoOutputDevice(
      const OpalConnection & connection,    
      const OpalMediaFormat & mediaFormat,  
      BOOL preview,                         
      PVideoOutputDevice * & device,        
      BOOL & autoDelete                     
    );
#endif

    virtual OpalMediaPatch * CreateMediaPatch(
      OpalMediaStream & source,         
      BOOL requiresPatchThread = TRUE
    );

    virtual void DestroyMediaPatch(
      OpalMediaPatch * patch
    );

    virtual BOOL OnStartMediaPatch(
      const OpalMediaPatch & patch     
    );

    virtual void OnUserInputString(
      OpalConnection & connection,  
      const PString & value         
    );

    virtual void OnUserInputTone(
      OpalConnection & connection,  
      char tone,                    
      int duration                  
    );

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

#if OPAL_T120DATA

    virtual OpalT120Protocol * CreateT120ProtocolHandler(
      const OpalConnection & connection  
    ) const;
#endif

#if OPAL_T38FAX

    virtual OpalT38Protocol * CreateT38ProtocolHandler(
      const OpalConnection & connection  
    ) const;
        
#endif

#if OPAL_H224

        virtual OpalH224Handler * CreateH224ProtocolHandler(
      OpalConnection & connection, unsigned sessionID
    ) const;
        
        virtual OpalH281Handler * CreateH281ProtocolHandler(
      OpalH224Handler & h224Handler
    ) const;
#endif

    class RouteEntry : public PObject
    {
        PCLASSINFO(RouteEntry, PObject);
      public:
        RouteEntry(const PString & pat, const PString & dest);
        void PrintOn(ostream & strm) const;
        PString            pattern;
        PString            destination;
        PRegularExpression regex;
    };
    PLIST(RouteTable, RouteEntry);

    virtual BOOL AddRouteEntry(
      const PString & spec  
    );

    BOOL SetRouteTable(
      const PStringArray & specs  
    );

    void SetRouteTable(
      const RouteTable & table  
    );

    const RouteTable & GetRouteTable() const { return routeTable; }

    virtual PString ApplyRouteTable(
      const PString & proto,
      const PString & addr
    );

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

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

    const PString & GetDefaultUserName() const { return defaultUserName; }

    void SetDefaultUserName(
      const PString & name
    ) { defaultUserName = name; }

    const PString & GetDefaultDisplayName() const { return defaultDisplayName; }

    void SetDefaultDisplayName(
      const PString & name
    ) { defaultDisplayName = name; }

#if OPAL_VIDEO

    BOOL CanAutoStartReceiveVideo() const { return autoStartReceiveVideo; }

    void SetAutoStartReceiveVideo(BOOL can) { autoStartReceiveVideo = can; }

    BOOL CanAutoStartTransmitVideo() const { return autoStartTransmitVideo; }

    void SetAutoStartTransmitVideo(BOOL can) { autoStartTransmitVideo = can; }

#endif

    virtual BOOL IsLocalAddress(
      const PIPSocket::Address & remoteAddress
    ) const;

    virtual BOOL TranslateIPAddress(
      PIPSocket::Address & localAddress,
      const PIPSocket::Address & remoteAddress
    );

    const PIPSocket::Address & GetTranslationAddress() const { return translationAddress; }

    void SetTranslationAddress(
      const PIPSocket::Address & address
    ) { translationAddress = address; }

    PSTUNClient * GetSTUN(
      const PIPSocket::Address & address = 0
    ) const;

    PSTUNClient::NatTypes SetSTUNServer(
      const PString & server
    );

    const PString & GetSTUNServer() const { return stunServer; }

    WORD GetTCPPortBase() const { return tcpPorts.base; }

    WORD GetTCPPortMax() const { return tcpPorts.max; }

    void SetTCPPorts(unsigned tcpBase, unsigned tcpMax);

    WORD GetNextTCPPort();

    WORD GetUDPPortBase() const { return udpPorts.base; }

    WORD GetUDPPortMax() const { return udpPorts.max; }

    void SetUDPPorts(unsigned udpBase, unsigned udpMax);

    WORD GetNextUDPPort();

    WORD GetRtpIpPortBase() const { return rtpIpPorts.base; }

    WORD GetRtpIpPortMax() const { return rtpIpPorts.max; }

    void SetRtpIpPorts(unsigned udpBase, unsigned udpMax);

    WORD GetRtpIpPortPair();

    BYTE GetRtpIpTypeofService() const { return rtpIpTypeofService; }

    void SetRtpIpTypeofService(unsigned tos) { rtpIpTypeofService = (BYTE)tos; }

    unsigned GetMinAudioJitterDelay() const { return minAudioJitterDelay; }

    unsigned GetMaxAudioJitterDelay() const { return maxAudioJitterDelay; }

    void SetAudioJitterDelay(
      unsigned minDelay,   
      unsigned maxDelay    
    );

    const PStringArray & GetMediaFormatOrder() const { return mediaFormatOrder; }

    void SetMediaFormatOrder(const PStringArray & order) { mediaFormatOrder = order; }

    const PStringArray & GetMediaFormatMask() const { return mediaFormatMask; }

    void SetMediaFormatMask(const PStringArray & mask) { mediaFormatMask = mask; }

    virtual void SetSilenceDetectParams(
      const OpalSilenceDetector::Params & params
    ) { silenceDetectParams = params; }

    const OpalSilenceDetector::Params & GetSilenceDetectParams() const { return silenceDetectParams; }
    
    virtual void SetEchoCancelParams(
      const OpalEchoCanceler::Params & params
    ) { echoCancelParams = params; }

    const OpalEchoCanceler::Params & GetEchoCancelParams() const { return echoCancelParams; }

#if OPAL_VIDEO

    virtual BOOL SetVideoInputDevice(
      const PVideoDevice::OpenArgs & deviceArgs 
    );

    const PVideoDevice::OpenArgs & GetVideoInputDevice() const { return videoInputDevice; }

    virtual BOOL SetVideoPreviewDevice(
      const PVideoDevice::OpenArgs & deviceArgs 
    );

    const PVideoDevice::OpenArgs & GetVideoPreviewDevice() const { return videoPreviewDevice; }

    virtual BOOL SetVideoOutputDevice(
      const PVideoDevice::OpenArgs & deviceArgs 
    );

    const PVideoDevice::OpenArgs & GetVideoOutputDevice() const { return videoOutputDevice; }

#endif

    BOOL DetectInBandDTMFDisabled() const
      { return disableDetectInBandDTMF; }

    void DisableDetectInBandDTMF(
      BOOL mode 
    ) { disableDetectInBandDTMF = mode; } 

    const PTimeInterval & GetNoMediaTimeout() const { return noMediaTimeout; }

    BOOL SetNoMediaTimeout(
      const PTimeInterval & newInterval  
    );

    const PString & GetDefaultILSServer() const { return ilsServer; }

    void SetDefaultILSServer(
      const PString & server
    ) { ilsServer = server; }

    // needs to be public for gcc 3.4
    void GarbageCollection();

    virtual void OnNewConnection(OpalConnection & conn);

    virtual void SetDefaultSecurityMode(const PString & v)
    { defaultSecurityMode = v; }

    virtual PString GetDefaultSecurityMode() const 
    { return defaultSecurityMode; }

    virtual BOOL UseRTPAggregation() const;

    OpalRecordManager & GetRecordManager()
    { return recordManager; }

    virtual BOOL StartRecording(const PString & callToken, const PFilePath & fn);
    virtual void StopRecording(const PString & callToken);

    virtual BOOL IsRTPNATEnabled(
      OpalConnection & conn, 
      const PIPSocket::Address & localAddr, 
      const PIPSocket::Address & peerAddr,
      const PIPSocket::Address & sigAddr,
      BOOL incoming
    );

  protected:
    // Configuration variables
    OpalProductInfo productInfo;

    PString       defaultUserName;
    PString       defaultDisplayName;

#if OPAL_VIDEO
    BOOL          autoStartReceiveVideo;
    BOOL          autoStartTransmitVideo;
#endif

    BYTE          rtpIpTypeofService;
    unsigned      minAudioJitterDelay;
    unsigned      maxAudioJitterDelay;
    PStringArray  mediaFormatOrder;
    PStringArray  mediaFormatMask;
    BOOL          disableDetectInBandDTMF;
    PTimeInterval noMediaTimeout;
    PString       ilsServer;

    OpalSilenceDetector::Params silenceDetectParams;
    OpalEchoCanceler::Params echoCancelParams;

#if OPAL_VIDEO
    PVideoDevice::OpenArgs videoInputDevice;
    PVideoDevice::OpenArgs videoPreviewDevice;
    PVideoDevice::OpenArgs videoOutputDevice;
#endif

    struct PortInfo {
      void Set(
        unsigned base,
        unsigned max,
        unsigned range,
        unsigned dflt
      );
      WORD GetNext(
        unsigned increment
      );

      PMutex mutex;
      WORD   base;
      WORD   max;
      WORD   current;
    } tcpPorts, udpPorts, rtpIpPorts;

    PIPSocket::Address translationAddress;
    PString            stunServer;
    PSTUNClient      * stun;

    RouteTable routeTable;
    PMutex     routeTableMutex;

    // Dynamic variables
    PList<OpalEndPoint> endpoints;
    PReadWriteMutex     endpointsMutex;

    PAtomicInteger lastCallTokenID;

    class CallDict : public PSafeDictionary<PString, OpalCall>
    {
      public:
        CallDict(OpalManager & mgr) : manager(mgr) { }
        virtual void DeleteObject(PObject * object) const;
        OpalManager & manager;
    } activeCalls;

    BOOL         clearingAllCalls;
    PSyncPoint   allCallsCleared;
    PThread    * garbageCollector;
    PSyncPoint   garbageCollectExit;
    PDECLARE_NOTIFIER(PThread, OpalManager, GarbageMain);

    PString defaultSecurityMode;

#if OPAL_RTP_AGGREGATE
    BOOL useRTPAggregation; 
#endif

    OpalRecordManager recordManager;

    friend OpalCall::OpalCall(OpalManager & mgr);
    friend void OpalCall::OnReleased(OpalConnection & connection);
};


PString  OpalGetVersion();
unsigned OpalGetMajorVersion();
unsigned OpalGetMinorVersion();
unsigned OpalGetBuildNumber();


#endif // __OPAL_MANAGER_H


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

---