sipXtapi.h

Go to the documentation of this file.

//
// Copyright (C) 2005-2021 SIPez LLC.  All rights reserved.
//
// Copyright (C) 2007 Robert J. Andreasen, Jr.
// Licensed to SIPfoundry under a Contributor Agreement. 
//
// Copyright (C) 2004-2009 SIPfoundry Inc.
// Licensed by SIPfoundry under the LGPL license.
//
// Copyright (C) 2004-2006 Pingtel Corp.  All rights reserved.
// Licensed to SIPfoundry under a Contributor Agreement.
//
// $$

#ifndef _sipXtapi_h_
#define _sipXtapi_h_

#include <memory.h>
#include <string.h>
#include <stddef.h>       // size_t

// SYSTEM INCLUDES
#ifdef DIRECT_SHOW_RENDER
#include <windows.h>
#include <Unknwn.h>
#    if !defined __strmif_h__
#        include <strmif.h>
#    endif 
#endif

// APPLICATION INCLUDES

// DEFINES

#ifdef SIPX_USE_STDCALL
#define SIPX_CALLING_CONVENTION __stdcall
#else
#define SIPX_CALLING_CONVENTION
#endif 

#define DEFAULT_UDP_PORT        5060    
#define DEFAULT_TCP_PORT        5060    
#define DEFAULT_TLS_PORT        5061    
#define DEFAULT_RTP_START_PORT  9000    
#define DEFAULT_STUN_PORT       3478    
#define DEFAULT_CONNECTIONS     32      
#define DEFAULT_IDENTITY        "sipx"  
#define DEFAULT_BIND_ADDRESS    "0.0.0.0" 
#define GAIN_MIN                0       
#define GAIN_MAX                100     
#define GAIN_DEFAULT            70      
#define VOLUME_MIN              0       
#define VOLUME_MAX              100     
#define VOLUME_DEFAULT          70      
#define MAX_AUDIO_DEVICES       64      
#define MAX_VIDEO_DEVICES       8       
#define MAX_VIDEO_DEVICE_LENGTH 256     
#define CONF_MAX_CONNECTIONS    32      
#define SIPX_MAX_IP_ADDRESSES   32      
#define SIPX_MAX_CALLS          64      
#define SIPX_PORT_DISABLE       -1      
#define SIPX_PORT_AUTO          -2      
#define SIPXTAPI_VERSION_STRING "sipXtapi SDK %s.%s %s (built %s)" 
#define SIPXTAPI_VERSION        "3.3.0"      
#define SIPXTAPI_BUILDNUMBER "0"             
#define SIPXTAPI_BUILD_WORD 3,3,0,0          
#define SIPXTAPI_FULL_VERSION "3.3.0.0"      
#define SIPXTAPI_BUILDDATE "0000-00-00"      
#define SIPX_MAX_ADAPTER_NAME_LENGTH 256         
#if defined(_WIN32)
#  ifdef SIPXTAPI_EXPORTS
#    define SIPXTAPI_API extern "C" __declspec(dllexport)  
#  elif defined(SIPXTAPI_STATIC)
#    define SIPXTAPI_API extern "C"  
#  else
#    define SIPXTAPI_API extern "C" __declspec(dllimport)  
#  endif
#else
#  define SIPXTAPI_API extern "C"   
#endif

// MACROS
// EXTERNAL FUNCTIONS
// EXTERNAL VARIABLES
// CONSTANTS

// FORWARD DECLARATIONS
class securityHelper;

// STRUCTS

// TYPEDEFS
typedef enum MEDIA_TYPE
{
    AUDIO_MEDIA,
    VIDEO_MEDIA
} MEDIA_TYPE;

typedef enum SPEAKER_TYPE
{
    SPEAKER,    
    RINGER      
} SPEAKER_TYPE ;

typedef enum SIPX_AUDIO_BANDWIDTH_ID
{
    AUDIO_CODEC_BW_VARIABLE=0,   
    AUDIO_CODEC_BW_LOW,          
    AUDIO_CODEC_BW_NORMAL,       
    AUDIO_CODEC_BW_HIGH,         
    AUDIO_CODEC_BW_CUSTOM,               
    AUDIO_CODEC_BW_DEFAULT       
} SIPX_AUDIO_BANDWIDTH_ID;


typedef enum SIPX_VIDEO_BANDWIDTH_ID
{
    VIDEO_CODEC_BW_VARIABLE=0,   
    VIDEO_CODEC_BW_LOW,          
    VIDEO_CODEC_BW_NORMAL,       
    VIDEO_CODEC_BW_HIGH,         
    VIDEO_CODEC_BW_CUSTOM,       
    VIDEO_CODEC_BW_DEFAULT       
} SIPX_VIDEO_BANDWIDTH_ID;

typedef enum SIPX_VIDEO_QUALITY_ID
{
    VIDEO_QUALITY_LOW=1,         
    VIDEO_QUALITY_NORMAL=2,      
    VIDEO_QUALITY_HIGH=3         
} SIPX_VIDEO_QUALITY_ID;

typedef enum SIPX_VIDEO_FORMAT
{
    VIDEO_FORMAT_CIF=0,          
    VIDEO_FORMAT_QCIF,           
    VIDEO_FORMAT_SQCIF,          
    VIDEO_FORMAT_QVGA            
} SIPX_VIDEO_FORMAT;


typedef enum SIPX_AUDIO_DATA_FORMAT
{
    RAW_PCM_16=0                 
} SIPX_AUDIO_DATA_FORMAT;


typedef void (*sipxLogCallback)(const char* szPriority,
                                const char* szSource,
                                const char* szMsg);

typedef enum SIPX_RESULT 
{
    SIPX_RESULT_SUCCESS = 0,         
    SIPX_RESULT_FAILURE,             
    SIPX_RESULT_NOT_IMPLEMENTED,     
    SIPX_RESULT_OUT_OF_MEMORY,       
    SIPX_RESULT_INVALID_ARGS,        
    SIPX_RESULT_BAD_ADDRESS,         
    SIPX_RESULT_OUT_OF_RESOURCES,    
    SIPX_RESULT_INSUFFICIENT_BUFFER, 
    SIPX_RESULT_EVAL_TIMEOUT,        
    SIPX_RESULT_BUSY,                
    SIPX_RESULT_INVALID_STATE,       
    SIPX_RESULT_MISSING_RUNTIME_FILES,
    SIPX_RESULT_TLS_DATABASE_FAILURE, 
    SIPX_RESULT_TLS_BAD_PASSWORD,     
    SIPX_RESULT_TLS_TCP_IMPORT_FAILURE, 
    SIPX_RESULT_NSS_FAILURE,          
    SIPX_RESULT_NOT_SUPPORTED,        
    SIPX_RESULT_NETWORK_FAILURE,      
    SIPX_RESULT_LIB_NOT_FOUND,        
    SIPX_RESULT_OS_PLATFORM_UNSUPPORTED
} SIPX_RESULT ;

typedef enum SIPX_TONE_ID
{
        ID_DTMF_INVALID            = 0,     
    ID_DTMF_0              = '0',   
    ID_DTMF_1              = '1',   
    ID_DTMF_2              = '2',   
    ID_DTMF_3              = '3',   
    ID_DTMF_4              = '4',   
    ID_DTMF_5              = '5',   
    ID_DTMF_6              = '6',   
    ID_DTMF_7              = '7',   
    ID_DTMF_8              = '8',   
    ID_DTMF_9              = '9',   
    ID_DTMF_STAR           = '*',   
    ID_DTMF_POUND          = '#',   
    ID_DTMF_FLASH          = '!',   
    ID_TONE_DIALTONE  = 512,        
    ID_TONE_BUSY,                   
    ID_TONE_RINGBACK,               
    ID_TONE_RINGTONE,               
    ID_TONE_CALLFAILED,             
    ID_TONE_SILENCE,                
    ID_TONE_BACKSPACE,              
    ID_TONE_CALLWAITING,            
    ID_TONE_CALLHELD,               
    ID_TONE_LOUD_FAST_BUSY          
} SIPX_TONE_ID ;                 

typedef SIPX_TONE_ID TONE_ID  ;         
typedef enum SIPX_AUDIO_FILE_FORMAT
{
    SIPX_UNKNOWN_FORMAT = 0,
    SIPX_WAVE_PCM_16,        
    SIPX_WAVE_GSM,           
    SIPX_OGG_OPUS            
} SIPX_AUDIO_FILE_FORMAT;

typedef enum SIPX_LOG_LEVEL
{
    LOG_LEVEL_DEBUG,     
    LOG_LEVEL_INFO,      
    LOG_LEVEL_NOTICE,    
    LOG_LEVEL_WARNING,   
    LOG_LEVEL_ERR,       
    LOG_LEVEL_CRIT,      
    LOG_LEVEL_ALERT,     
    LOG_LEVEL_EMERG,     
    LOG_LEVEL_NONE,      
} SIPX_LOG_LEVEL ;

#define MAX_SRTP_KEY_LENGTH   31        
#define MAX_SMIME_KEY_LENGTH  2048      
#define MAX_PKCS12_KEY_LENGTH 4096      
#define MAX_PASSWORD_LENGTH   32        
enum SIPX_SRTP_LEVEL
{
    SRTP_LEVEL_NONE=0,
    SRTP_LEVEL_ENCRYPTION,
    SRTP_LEVEL_AUTHENTICATION,
    SRTP_LEVEL_ENCRYPTION_AND_AUTHENTICATION
};

class SIPX_SECURITY_ATTRIBUTES
{
  public:
    friend class SecurityHelper;    
    SIPX_SECURITY_ATTRIBUTES() 
    {
        nSrtpKeyLength = 0 ;
        nSmimeKeyLength = 0 ;
        nSrtpLevel = SRTP_LEVEL_NONE ;
        memset(szSrtpKey, 0, sizeof(szSrtpKey));
        memset(szSmimeKeyDer, 0, sizeof(szSmimeKeyDer));
        memset(dbLocation, 0, sizeof(dbLocation));
        memset(szMyCertNickname, 0, sizeof(szMyCertNickname));
        memset(szCertDbPassword, 0, sizeof(szCertDbPassword));
    }    
    SIPX_SECURITY_ATTRIBUTES(const SIPX_SECURITY_ATTRIBUTES& ref)
    {
        copyData(ref);
    }    
    virtual ~SIPX_SECURITY_ATTRIBUTES() { }    
    SIPX_SECURITY_ATTRIBUTES& operator=(const SIPX_SECURITY_ATTRIBUTES& ref)
    {
        if (this == &ref) return *this;
        copyData(ref);
        return *this;
    }    
    void setSrtpKey(const char* szKey, const int length)
    {
        int safeLen = (length < (int) sizeof(szSrtpKey)) ? length : (int) sizeof(szSrtpKey);
        memcpy(szSrtpKey, szKey, safeLen);
        nSrtpKeyLength = safeLen;
    }    
    void setSmimeKey(const char* szKey, const int length)
    {
        int safeLen = (length < (int) sizeof(szSmimeKeyDer)) ? length : (int) sizeof(szSmimeKeyDer);
        memcpy(szSmimeKeyDer, szKey, safeLen);
        nSmimeKeyLength = safeLen;
    }
    void setSecurityLevel(SIPX_SRTP_LEVEL security) { nSrtpLevel = security; }
    const char* getSrtpKey() const  { return szSrtpKey; }    
    const char* getSmimeKey() const { return szSmimeKeyDer; }
    const int getSrtpKeyLength() const  { return nSrtpKeyLength; }
    const int getSmimeKeyLength() const { return nSmimeKeyLength; }
    const int getSecurityLevel() const {return nSrtpLevel;}
    const char* getCertDbLocation() const { return dbLocation; }
  private:
    SIPX_SRTP_LEVEL nSrtpLevel;
    char szSrtpKey[MAX_SRTP_KEY_LENGTH];
    int  nSrtpKeyLength;    
    char szSmimeKeyDer[MAX_SMIME_KEY_LENGTH];
    int  nSmimeKeyLength; 
    // internally set private member, use sipxConfigSetSecurityParameters
    char dbLocation[256];                         
    // internally set private member, use sipxConfigSetSecurityParameters
    char szMyCertNickname[32];   
    // internally set private member, use sipxConfigSetSecurityParameters
    char szCertDbPassword[MAX_PASSWORD_LENGTH];   
    void copyData(const SIPX_SECURITY_ATTRIBUTES& ref)
    {
        nSrtpLevel = ref.nSrtpLevel;
        nSrtpKeyLength = ref.nSrtpKeyLength;
        nSmimeKeyLength = ref.nSmimeKeyLength;
        memcpy(szSrtpKey, ref.szSrtpKey, ref.nSrtpKeyLength);
        memcpy(szSmimeKeyDer, ref.szSmimeKeyDer, ref.nSmimeKeyLength);
        strncpy(dbLocation, ref.dbLocation, sizeof(dbLocation) - 1);
        strncpy(szMyCertNickname, ref.szMyCertNickname, sizeof(szMyCertNickname) - 1);
        strncpy(szCertDbPassword, ref.szCertDbPassword, sizeof(szCertDbPassword) - 1);
    }
};

typedef enum
{
    CONTACT_LOCAL,      
    CONTACT_NAT_MAPPED, 
    CONTACT_RELAY,      
    CONTACT_CONFIG,     
    CONTACT_AUTO = -1,  
    CONTACT_ALL = -2
} SIPX_CONTACT_TYPE ;

typedef enum
{
    TRANSPORT_UDP = 1,  
    TRANSPORT_TCP = 0,  
    TRANSPORT_TLS = 3,  
    TRANSPORT_CUSTOM = 4 
} SIPX_TRANSPORT_TYPE;

typedef void* SIPX_WINDOW_HANDLE;

typedef enum SIPX_VIDEO_DISPLAY_TYPE
{
    SIPX_WINDOW_HANDLE_TYPE,     
    DIRECT_SHOW_FILTER           
} SIPX_VIDEO_DISPLAY_TYPE;

struct SIPX_VIDEO_DISPLAY
{
    SIPX_VIDEO_DISPLAY()
    {
        cbSize = sizeof(SIPX_VIDEO_DISPLAY);
        type = SIPX_WINDOW_HANDLE_TYPE;
        handle = NULL;
    }
    ~SIPX_VIDEO_DISPLAY()
    {
        if (type == DIRECT_SHOW_FILTER)
        {
#ifdef DIRECT_SHOW_RENDER
            if (handle) ((IUnknown*)handle)->Release();
#endif              
        }
    }
    SIPX_VIDEO_DISPLAY(const SIPX_VIDEO_DISPLAY& ref)
    {
        copy(ref);
    }
    SIPX_VIDEO_DISPLAY& operator=(const SIPX_VIDEO_DISPLAY& ref)
    {
        // check for assignment to self
        if (this == &ref) return *this;
        copy(ref);
        return *this;
    }    
    int cbSize;                                         
    SIPX_VIDEO_DISPLAY_TYPE type;       
    union
    {
                SIPX_WINDOW_HANDLE handle;      
#ifdef DIRECT_SHOW_RENDER
                IBaseFilter* filter;            
#endif
    };
private:
    void copy(const SIPX_VIDEO_DISPLAY& ref)
    {
        cbSize = ref.cbSize;
        type = ref.type;
        handle = ref.handle;
        if (type == DIRECT_SHOW_FILTER)
        {
#ifdef DIRECT_SHOW_RENDER
            // we should addRef here.
            if (handle) ((IBaseFilter*)handle)->AddRef();
#endif            
        }
    }
    
};

typedef int SIPX_CONTACT_ID; 

struct SIPX_CONTACT_ADDRESS
{
    SIPX_CONTACT_ADDRESS()
    {
        cbSize = sizeof(SIPX_CONTACT_ADDRESS);
        memset((void*)cInterface, 0, sizeof(cInterface));
        memset((void*)cIpAddress, 0, sizeof(cIpAddress));
        memset((void*)cCustomTransportName, 0, sizeof(cCustomTransportName));
        memset((void*)cCustomRouteID, 0, sizeof(cCustomRouteID));
        eContactType = CONTACT_AUTO;
        eTransportType = TRANSPORT_UDP ;
        id = 0;
        iPort = -1;
    }
    SIPX_CONTACT_ADDRESS(const SIPX_CONTACT_ADDRESS& ref)
    {
        cbSize = sizeof(SIPX_CONTACT_ADDRESS);
        strncpy(cInterface, ref.cInterface, sizeof(cInterface));
        strncpy(cIpAddress, ref.cIpAddress, sizeof(cIpAddress));
        eContactType = ref.eContactType;
        eTransportType = ref.eTransportType;
        id = ref.id;
        iPort = ref.iPort;
        if (ref.cbSize == sizeof(SIPX_CONTACT_ADDRESS))
        {
        strncpy(cCustomTransportName, ref.cCustomTransportName, 32);
        strncpy(cCustomRouteID, ref.cCustomRouteID, sizeof(cCustomRouteID));
    }
        else
        {
            memset((void*)cCustomTransportName, 0, sizeof(cCustomTransportName));
            memset((void*)cCustomRouteID, 0, sizeof(cCustomRouteID));
        }
    }

    SIPX_CONTACT_ADDRESS& operator=(const SIPX_CONTACT_ADDRESS& ref)
    {
        // check for assignment to self
        if (this == &ref) return *this;
        strncpy(cInterface, ref.cInterface, sizeof(cInterface));
        strncpy(cIpAddress, ref.cIpAddress, sizeof(cIpAddress));
        eContactType = ref.eContactType;
        eTransportType = ref.eTransportType;
        id = ref.id;
        iPort = ref.iPort;
        if (cbSize == sizeof(SIPX_CONTACT_ADDRESS))
        {
            strncpy(cCustomTransportName, ref.cCustomTransportName, sizeof(cCustomTransportName));
            strncpy(cCustomRouteID, ref.cCustomRouteID, sizeof(cCustomRouteID));
        }
        return *this;
    }    
    SIPX_CONTACT_ID     id;              
    SIPX_CONTACT_TYPE   eContactType ;   
    SIPX_TRANSPORT_TYPE eTransportType ; 
    char                cInterface[32] ; 
    char                cIpAddress[28] ; 
    int                 cbSize;          
    int                 iPort ;          
    char                cCustomTransportName[32]; 
    char                cCustomRouteID[64] ; 
/*
    NOTE: I've carved a cbSize out of the cIpAddress to allow binary backwards 
          compatibility with older version of the DLL.  If the cbSize isn't 
          want we expected, we should not touch data members.
*/
};


typedef struct 
{
#define SIPXTAPI_CODEC_NAMELEN 32       
    char              cName[SIPXTAPI_CODEC_NAMELEN];  
    SIPX_AUDIO_BANDWIDTH_ID iBandWidth; 
    int               iPayloadType;     
} SIPX_AUDIO_CODEC ;


typedef struct 
{
    int cbSize;                                         
        unsigned short fraction_lost;   
        unsigned long cum_lost;         
        unsigned long ext_max;          
        unsigned long jitter;           
        int RTT;                        
        int bytesSent;                  
        int packetsSent;                
        int bytesReceived;              
        int packetsReceived;            
} SIPX_RTCP_STATS ;

typedef struct 
{
#define SIPXTAPI_CODEC_NAMELEN 32        
    char              cName[SIPXTAPI_CODEC_NAMELEN];  
    SIPX_VIDEO_BANDWIDTH_ID iBandWidth;  
    int               iPayloadType;      
} SIPX_VIDEO_CODEC ;


typedef struct
{
    SIPX_AUDIO_CODEC audioCodec;     
    SIPX_VIDEO_CODEC videoCodec;     
    bool bIsEncrypted;               
} SIPX_CODEC_INFO;


enum SIPX_RTP_TRANSPORT
{
   SIPX_RTP_TRANSPORT_UNKNOWN   = 0x00000000,
   SIPX_RTP_TRANSPORT_UDP       = 0x00000001,
   SIPX_RTP_TRANSPORT_TCP       = 0x00000002,
   SIPX_RTP_TCP_ROLE_ACTIVE     = 0x00000004,
   SIPX_RTP_TCP_ROLE_PASSIVE    = 0x00000008,
   SIPX_RTP_TCP_ROLE_ACTPASS    = 0x00000010,
   SIPX_RTP_TCP_ROLE_CONNECTION = 0x00000020,
};

typedef struct 
{
    int cbSize;                          
    SIPX_AUDIO_BANDWIDTH_ID bandwidthId; 
    bool sendLocation;                   
    SIPX_CONTACT_ID contactId;           
    SIPX_RTP_TRANSPORT rtpTransportFlags; 
    /*
     * NOTE: When adding new data to this structure, please always add it to
     *       the end.  This will allow us to maintain some drop-in 
     *       backwards compatibility between releases.
     */
} SIPX_CALL_OPTIONS;


typedef void* SIPX_INST ;         
const SIPX_INST SIPX_INST_NULL = 0; 
typedef unsigned int SIPX_LINE ;
const SIPX_LINE SIPX_LINE_NULL = 0; 
typedef unsigned int SIPX_CALL ;
const SIPX_CALL SIPX_CALL_NULL = 0; 
typedef unsigned long SIPX_CONF ;
const SIPX_CONF SIPX_CONF_NULL = 0; 
typedef unsigned long SIPX_INFO;

typedef unsigned long SIPX_PUB;

const SIPX_PUB SIPX_PUB_NULL = 0; 
typedef unsigned long SIPX_SUB ;


typedef unsigned long SIPX_TRANSPORT ;
const SIPX_TRANSPORT SIPX_TRANSPORT_NULL = 0; 
typedef bool (SIPX_CALLING_CONVENTION *SIPX_TRANSPORT_WRITE_PROC)(
        SIPX_TRANSPORT hTransport,
        const char*    szDestinationIp,
        const int      iDestPort,
        const char*    szLocalIp,
        const int      iLocalPort,
        const void*    pData,
        const size_t   nData,
        const void*    pUserData) ;

typedef void (*fnMicAudioHook)(const int nSamples, short* pSamples) ;

typedef void (*fnSpkrAudioHook)(const int nSamples, short* pSamples) ;


typedef enum
{
    SIPX_KEEPALIVE_CRLF,        
    SIPX_KEEPALIVE_STUN,        
    SIPX_KEEPALIVE_SIP_PING,    
    SIPX_KEEPALIVE_SIP_OPTIONS, 
} SIPX_KEEPALIVE_TYPE ;

typedef enum SIPX_AEC_MODE
{
    SIPX_AEC_DISABLED,   
    SIPX_AEC_SUPPRESS,   
    SIPX_AEC_CANCEL,     
    SIPX_AEC_CANCEL_AUTO,
} SIPX_AEC_MODE ;


typedef enum SIPX_NOISE_REDUCTION_MODE
{
    SIPX_NOISE_REDUCTION_DISABLED,  
    SIPX_NOISE_REDUCTION_LOW,       
    SIPX_NOISE_REDUCTION_MEDIUM,    
    SIPX_NOISE_REDUCTION_HIGH,      
} SIPX_NOISE_REDUCTION_MODE ;

/* ============================ FUNCTIONS ================================= */



SIPXTAPI_API SIPX_RESULT sipxInitialize(SIPX_INST* phInst,
                                        const int udpPort = DEFAULT_UDP_PORT,
                                        const int tcpPort = DEFAULT_TCP_PORT,
                                        const int tlsPort = DEFAULT_TLS_PORT,
                                        const int rtpPortStart = DEFAULT_RTP_START_PORT,
                                        const int maxConnections = DEFAULT_CONNECTIONS,
                                        const char* szIdentity = DEFAULT_IDENTITY,
                                        const char* szBindToAddr = DEFAULT_BIND_ADDRESS,
                                        bool      bUseSequentialPorts = false,
                                        const char* szTLSCertificateNickname = NULL,
                                        const char* szTLSCertificatePassword = NULL,
                                        const char* szDbLocation = NULL,
                                        bool        bEnableLocalAudio = true,
                                        const int   internalSamplerate = 8000,
                                        const int   devicesSamplerate = 48000,
                                        const int   internalFrameSizeMs = 10,
                                        const char *callInputDeviceName = "",
                                        const char *callOutputDeviceName = "") ;


SIPXTAPI_API SIPX_RESULT sipxReInitialize(SIPX_INST* phInst,
                                        const int udpPort = DEFAULT_UDP_PORT,
                                        const int tcpPort = DEFAULT_TCP_PORT,
                                        const int tlsPort = DEFAULT_TLS_PORT,
                                        const int rtpPortStart = DEFAULT_RTP_START_PORT,
                                        const int maxConnections = DEFAULT_CONNECTIONS,
                                        const char* szIdentity = DEFAULT_IDENTITY,
                                        const char* szBindToAddr = DEFAULT_BIND_ADDRESS,
                                        bool      bUseSequentialPorts = false,
                                        const char* szTLSCertificateNickname = NULL,
                                        const char* szTLSCertificatePassword = NULL,
                                        const char* szDbLocation = NULL) ;

SIPXTAPI_API SIPX_RESULT sipxUnInitialize(SIPX_INST hInst, bool bForceShutdown = false);



SIPXTAPI_API SIPX_RESULT sipxCallAccept(const SIPX_CALL hCall, 
                                        SIPX_VIDEO_DISPLAY* const pDisplay = NULL,
                                        SIPX_SECURITY_ATTRIBUTES* const pSecurity = NULL,
                                        SIPX_CALL_OPTIONS* options = NULL,
                                        bool bSendEarlyMedia = false);


SIPXTAPI_API SIPX_RESULT sipxCallReject(const SIPX_CALL hCall,
                                        const int errorCode = 400,
                                        const char* szErrorText = "Bad Request") ;


SIPXTAPI_API SIPX_RESULT sipxCallRedirect(const SIPX_CALL hCall,
                                          const char* szForwardURL) ;

SIPXTAPI_API SIPX_RESULT sipxCallAnswer(const SIPX_CALL hCall, 
                                        bool  bTakeFocus = true) ;


SIPXTAPI_API SIPX_RESULT sipxCallCreate(const SIPX_INST hInst, 
                                        const SIPX_LINE hLine,
                                        SIPX_CALL*  phCall) ;

SIPXTAPI_API SIPX_RESULT sipxCallConnect(const SIPX_CALL hCall,
                                         const char* szAddress,
                                         SIPX_CONTACT_ID contactId = 0,
                                         SIPX_VIDEO_DISPLAY* const pDisplay = NULL,
                                         SIPX_SECURITY_ATTRIBUTES* const pSecurity = NULL,
                                         bool bTakeFocus = true,
                                         SIPX_CALL_OPTIONS* options = NULL,
                                         const char* szCallId = NULL);

SIPXTAPI_API SIPX_RESULT sipxCallHold(const SIPX_CALL hCall, 
                                      bool bStopRemoteAudio = true) ;


SIPXTAPI_API SIPX_RESULT sipxCallUnhold(const SIPX_CALL hCall) ;


SIPXTAPI_API SIPX_RESULT sipxCallDestroy(SIPX_CALL& hCall) ;


SIPXTAPI_API SIPX_RESULT sipxCallGetID(const SIPX_CALL hCall,
                                       char* szId, 
                                       const size_t iMaxLength) ;

SIPXTAPI_API SIPX_RESULT sipxCallGetLocalID(const SIPX_CALL hCall, 
                                            char* szId, 
                                            const size_t iMaxLength) ;

SIPXTAPI_API SIPX_RESULT sipxCallGetLine(const SIPX_CALL hCall,
                                        SIPX_LINE& hLine);

SIPXTAPI_API SIPX_RESULT sipxCallGetRemoteID(const SIPX_CALL hCall, 
                                             char* szId, 
                                             const size_t iMaxLength) ;

SIPXTAPI_API SIPX_RESULT sipxCallGetContactID(const SIPX_CALL hCall, 
                                              char* szId, 
                                              const size_t iMaxLength) ;

SIPXTAPI_API SIPX_RESULT sipxCallGetConnectionId(const SIPX_CALL hCall,
                                                 int& connectionId);


SIPXTAPI_API SIPX_RESULT sipxCallGetConference(const SIPX_CALL hCall,
                                               SIPX_CONF&      hConf) ;
                                                 

SIPXTAPI_API SIPX_RESULT sipxCallGetRequestURI(const SIPX_CALL hCall, 
                                               char* szUri, 
                                               const size_t iMaxLength) ;


                                                           
SIPXTAPI_API SIPX_RESULT sipxCallGetRemoteContact(const SIPX_CALL hCall, 
                                                  char* szContact, 
                                                  const size_t iMaxLength) ;

                                                           
SIPXTAPI_API SIPX_RESULT sipxCallGetRemoteUserAgent(const SIPX_CALL hCall,
                                                    char* szAgent, 
                                                    const size_t iMaxLength) ;

SIPXTAPI_API SIPX_RESULT sipxCallGetInviteHeader(const SIPX_CALL hCall, 
                                                 const char* headerName, 
                                                 char* headerValue, 
                                                 const size_t maxValueLength,
                                                 bool* inviteFromRemote,
                                                 const size_t headerInstanceIndex = 0);

SIPXTAPI_API SIPX_RESULT sipxCallStartTone(const SIPX_CALL hCall, 
                                           const SIPX_TONE_ID toneId,
                                           const bool bLocal,
                                           const bool bRemote) ;

SIPXTAPI_API SIPX_RESULT sipxCallStopTone(const SIPX_CALL hCall) ;


SIPXTAPI_API SIPX_RESULT sipxCallAudioPlayFileStart(const SIPX_CALL hCall, 
                                                    const char* szFile,
                                                    const bool bRepeat,
                                                    const bool bLocal,
                                                    const bool bRemote,
                                                    const bool bMixWithMicrophone = false,
                                                    const float fVolumeScaling = 1.0) ;

SIPXTAPI_API SIPX_RESULT sipxCallAudioPlayFileStop(const SIPX_CALL hCall) ; 


SIPXTAPI_API SIPX_RESULT sipxCallAudioRecordFileStart(const SIPX_CALL hCall,
                                                      const char* szFile,
                                                      const SIPX_AUDIO_FILE_FORMAT recordFormat = SIPX_WAVE_PCM_16,
                                                      const bool appendToFile = false,
                                                      const int numChannels = 1);

SIPXTAPI_API SIPX_RESULT sipxCallAudioRecordPause(const SIPX_CALL hCall);

SIPXTAPI_API SIPX_RESULT sipxCallAudioRecordResume(const SIPX_CALL hCall);

SIPXTAPI_API SIPX_RESULT sipxCallAudioRecordFileStop(const SIPX_CALL hCall) ;


SIPXTAPI_API SIPX_RESULT sipxCallAudioRecordBufferStart(const SIPX_CALL hCall,
                                                        const char* pBuffer,
                                                        const int bufferSize,
                                                        const int bufferType = RAW_PCM_16,
                                                        const int maxRecordTime = -1,
                                                        const int maxSilence = -1) ;

SIPXTAPI_API SIPX_RESULT sipxCallAudioRecordBufferStop(const SIPX_CALL hCall) ;


SIPXTAPI_API SIPX_RESULT sipxCallPlayBufferStart(const SIPX_CALL hCall,
                                                 const char* szBuffer,
                                                 const int  bufSize,
                                                 const int  bufType,
                                                 const bool bRepeat,
                                                 const bool bLocal,
                                                 const bool bRemote) ;


SIPXTAPI_API SIPX_RESULT sipxCallPlayBufferStop(const SIPX_CALL hCall) ; 


SIPXTAPI_API SIPX_RESULT sipxCallSetMediaPassThrough(const SIPX_CALL hCall,
                                                     MEDIA_TYPE mediaType,
                                                     int mediaTypeStreamIndex,
                                                     const char* streamReceiveAddress,
                                                     int rtpPort,
                                                     int rtcpPort);


SIPXTAPI_API SIPX_RESULT sipxCallSubscribe(const SIPX_CALL hCall,
                                           const char* szEventType,
                                           const char* szAcceptType,
                                           SIPX_SUB* phSub,
                                           bool bRemoteContactIsGruu = false);

SIPXTAPI_API SIPX_RESULT sipxCallUnsubscribe(const SIPX_SUB hSub) ;


SIPXTAPI_API SIPX_RESULT sipxCallSendInfo(SIPX_INFO* phInfo,
                                          const SIPX_CALL hCall,
                                          const char* szContentType,
                                          const char* szContent,
                                          const size_t nContentLength);

SIPXTAPI_API SIPX_RESULT sipxCallBlindTransfer(const SIPX_CALL hCall, 
                                               const char* szAddress) ;

SIPXTAPI_API SIPX_RESULT sipxCallTransfer(const SIPX_CALL hSourceCall,
                                          const SIPX_CALL hTargetCall) ;



SIPXTAPI_API SIPX_RESULT sipxCallUpdateVideoWindow(const SIPX_CALL hCall, const SIPX_WINDOW_HANDLE hWnd);


SIPXTAPI_API SIPX_RESULT sipxCallResizeWindow(const SIPX_CALL hCall, const SIPX_WINDOW_HANDLE hWnd);


SIPXTAPI_API SIPX_RESULT sipxCallGetEnergyLevels(const SIPX_CALL hCall,
                                                 int&            iInputEnergyLevel,
                                                 int&            iOutputEnergyLevel,
                                                 const size_t    nMaxContributors,
                                                 unsigned int    CCSRCs[],
                                                 int             iEnergyLevels[],
                                                 size_t&         nActualContributors) ;

SIPXTAPI_API SIPX_RESULT sipxCallGetAudioRtpSourceIds(const SIPX_CALL hCall,
                                                      unsigned int& iSendSSRC,
                                                      unsigned int& iReceiveSSRC)  ;

SIPXTAPI_API SIPX_RESULT sipxCallGetAudioRtcpStats(const SIPX_CALL hCall,
                                                   SIPX_RTCP_STATS* pStats) ;

SIPXTAPI_API SIPX_RESULT sipxCallLimitCodecs(const SIPX_CALL hCall,
                                             const char* codecNames);

SIPXTAPI_API SIPX_RESULT sipxCallLimitCodecPreferences(const SIPX_CALL hCall,
                                                       const SIPX_AUDIO_BANDWIDTH_ID audioBandwidth,
                                                       const SIPX_VIDEO_BANDWIDTH_ID videoBandwidth,
                                                       const char* szVideoCodecName);

SIPXTAPI_API SIPX_RESULT sipxCallSetMicGain(const SIPX_CALL hCall,
                                            float gain);

SIPXTAPI_API SIPX_RESULT sipxCallSetMixOutputGain(const SIPX_CALL hCall,
                                                  int bridgeOutputIndex,
                                                  float gain);




SIPXTAPI_API SIPX_RESULT sipxPublisherCreate(const SIPX_INST hInst, 
                                             SIPX_PUB* phPub,
                                             const char* szResourceId,
                                             const char* szEventType,
                                             const char* szContentType,
                                             const char* pContent,
                                             const size_t nContentLength);

SIPXTAPI_API SIPX_RESULT sipxPublisherDestroy(const SIPX_PUB hPub,
                                              const char* szContentType,
                                              const char* pFinalContent,
                                              const size_t nContentLength);

SIPXTAPI_API SIPX_RESULT sipxPublisherUpdate(const SIPX_PUB hPub,
                                             const char* szContentType,
                                             const char* pContent,
                                             const size_t nContentLength);




SIPXTAPI_API SIPX_RESULT sipxConferenceCreate(const SIPX_INST hInst,
                                              SIPX_CONF* phConference) ;

SIPXTAPI_API SIPX_RESULT sipxConferenceJoin(const SIPX_CONF hConf,
                                            const SIPX_CALL hCall) ;

SIPXTAPI_API SIPX_RESULT sipxConferenceSplit(const SIPX_CONF hConf,
                                             const SIPX_CALL hCall) ;

SIPXTAPI_API SIPX_RESULT sipxConferenceAdd(const SIPX_CONF hConf,
                                           const SIPX_LINE hLine,
                                           const char* szAddress,
                                           SIPX_CALL* phNewCall,
                                           SIPX_CONTACT_ID contactId = 0,
                                           SIPX_VIDEO_DISPLAY* const pDisplay = NULL,
                                           SIPX_SECURITY_ATTRIBUTES* const pSecurity = NULL,
                                           bool bTakeFocus = true,
                                           SIPX_CALL_OPTIONS* options = NULL);

SIPXTAPI_API SIPX_RESULT sipxConferenceRemove(const SIPX_CONF hConf,
                                              const SIPX_CALL hCall) ;


SIPXTAPI_API SIPX_RESULT sipxConferenceGetCalls(const SIPX_CONF hConf,
                                                SIPX_CALL calls[], 
                                                const size_t iMax, 
                                                size_t& nActual) ;

SIPXTAPI_API SIPX_RESULT sipxConferenceHold(const SIPX_CONF hConf,
                                            bool bBridging = true);
                                            
SIPXTAPI_API SIPX_RESULT sipxConferenceUnhold(const SIPX_CONF hConf);


SIPXTAPI_API SIPX_RESULT sipxConferencePlayAudioFileStart(const SIPX_CONF hConf, 
                                                          const char* szFile,
                                                          const bool bRepeat,
                                                          const bool bLocal,
                                                          const bool bRemote,
                                                          const bool bMixWithMicrophone = false,
                                                          const float fVolumeScaling = 1.0) ;

/*
 * Stop playing a file started with sipxConferencePlayAudioFileStart
 * If a sipxConferenceDestroy is attempted while an audio file is playing,
 * sipxConferenceDestroy will fail with a SIPX_RESULT_BUSY return code.
 * Call sipxConferencePlayAudioFileStop before making the call to
 * sipxConferenceDestroy.
 * 
 * @param hConf Conference handle obtained by calling sipxConferenceCreate.
 */
SIPXTAPI_API SIPX_RESULT sipxConferencePlayAudioFileStop(const SIPX_CONF hConf) ;


SIPXTAPI_API SIPX_RESULT sipxConferenceDestroy(SIPX_CONF hConf) ;


SIPXTAPI_API SIPX_RESULT sipxConferenceGetEnergyLevels(const SIPX_CONF hConf,
                                                       int&            iInputEnergyLevel,
                                                       int&            iOutputEnergyLevel) ;



SIPXTAPI_API SIPX_RESULT sipxConferenceLimitCodecPreferences(const SIPX_CONF hConf,
                                                             const SIPX_AUDIO_BANDWIDTH_ID audioBandwidth,
                                                             const SIPX_VIDEO_BANDWIDTH_ID videoBandwidth,
                                                             const char* szVideoCodecName) ;

SIPXTAPI_API SIPX_RESULT sipxMediaConnectionCreate(const SIPX_CONF hConf,
                                                   int& connectionId);

SIPXTAPI_API SIPX_RESULT sipxMediaConnectionRtpSetDestination(const SIPX_CONF hConf,
                                                              int connectionId,
                                                              MEDIA_TYPE mediaType,
                                                              int mediaTypeStreamIndex,
                                                              const char* streamSendAddress,
                                                              int rtpPort,
                                                              int rtcpPort);

SIPXTAPI_API SIPX_RESULT sipxMediaConnectionRtpStartSend(const SIPX_CONF hConf,
                                                         int connectionId,
                                                         int numTokens,
                                                         const char* codecTokens[],
                                                         int payloadIds[]);

SIPXTAPI_API SIPX_RESULT sipxMediaConnectionRtpStopSend(const SIPX_CONF hConf,
                                                        int connectionId);



SIPXTAPI_API SIPX_RESULT sipxAudioSetGain(const SIPX_INST hInst,
                                          const int iLevel) ;


SIPXTAPI_API SIPX_RESULT sipxAudioGetGain(const SIPX_INST hInst,
                                          int& iLevel) ;


SIPXTAPI_API SIPX_RESULT sipxAudioMute(const SIPX_INST hInst,
                                       const bool bMute) ;


SIPXTAPI_API SIPX_RESULT sipxAudioIsMuted(const SIPX_INST hInst,
                                          bool &bMuted) ;


SIPXTAPI_API SIPX_RESULT sipxAudioEnableSpeaker(const SIPX_INST hInst,
                                                const SPEAKER_TYPE type) ;


SIPXTAPI_API SIPX_RESULT sipxAudioGetEnabledSpeaker(const SIPX_INST hInst,
                                                    SPEAKER_TYPE& type) ;


SIPXTAPI_API SIPX_RESULT sipxAudioSetVolume(const SIPX_INST hInst,
                                            const SPEAKER_TYPE type, 
                                            const int iLevel) ;


SIPXTAPI_API SIPX_RESULT sipxAudioGetVolume(const SIPX_INST hInst,
                                            const SPEAKER_TYPE type, 
                                            int& iLevel) ;


SIPXTAPI_API SIPX_RESULT sipxAudioSetAECMode(const SIPX_INST hInst,
                                             const SIPX_AEC_MODE mode) ;


SIPXTAPI_API SIPX_RESULT sipxAudioGetAECMode(const SIPX_INST hInst,
                                             SIPX_AEC_MODE&  mode) ;


SIPXTAPI_API SIPX_RESULT sipxAudioSetAGCMode(const SIPX_INST hInst,
                                             const bool bEnable) ;

SIPXTAPI_API SIPX_RESULT sipxAudioGetAGCMode(const SIPX_INST hInst,
                                             bool& bEnabled) ;


SIPXTAPI_API SIPX_RESULT sipxAudioSetNoiseReductionMode(const SIPX_INST hInst,
                                                        const SIPX_NOISE_REDUCTION_MODE mode) ;


SIPXTAPI_API SIPX_RESULT sipxAudioGetNoiseReductionMode(const SIPX_INST hInst,
                                                        SIPX_NOISE_REDUCTION_MODE& mode) ;
 
SIPXTAPI_API SIPX_RESULT sipxAudioGetNumInputDevices(const SIPX_INST hInst,
                                                     size_t& numDevices) ;

SIPXTAPI_API SIPX_RESULT sipxAudioGetInputDevice(const SIPX_INST hInst,
                                                 const int index,
                                                 const char*& szDevice); 


SIPXTAPI_API SIPX_RESULT sipxAudioGetCurrentInputDevice(const SIPX_INST hInst,
                                                        int& index,
                                                        const char*& szDevice);

SIPXTAPI_API SIPX_RESULT sipxAudioGetNumOutputDevices(const SIPX_INST hInst,
                                                      size_t& numDevices) ;

SIPXTAPI_API SIPX_RESULT sipxAudioGetOutputDevice(const SIPX_INST hInst,
                                                  const int index,
                                                  const char*& szDevice) ;

SIPXTAPI_API SIPX_RESULT sipxAudioGetCurrentOutputDevice(const SIPX_INST hInst,
    int& index,
    const char*& szDevice);

SIPXTAPI_API SIPX_RESULT sipxAudioSetCallInputDevice(const SIPX_INST hInst,
                                                     const char* szDevice) ;

SIPXTAPI_API SIPX_RESULT sipxAudioSetRingerOutputDevice(const SIPX_INST hInst,
                                                        const char* szDevice) ;


SIPXTAPI_API SIPX_RESULT sipxAudioSetCallOutputDevice(const SIPX_INST hInst,
                                                      const char* szDevice) ;





SIPXTAPI_API SIPX_RESULT sipxLineAdd(const SIPX_INST hInst,
                                     const char* szLineURL,
                                     SIPX_LINE* phLine,
                                     SIPX_CONTACT_ID contactId = 0) ;

SIPXTAPI_API SIPX_RESULT sipxLineAddAlias(const SIPX_LINE hLine, const char* szLineURL) ;

SIPXTAPI_API SIPX_RESULT sipxLineRegister(const SIPX_LINE hLine, const bool bRegister);

SIPXTAPI_API SIPX_RESULT sipxLineRemove(SIPX_LINE hLine) ;

SIPXTAPI_API SIPX_RESULT sipxLineAddCredential(const SIPX_LINE hLine,                                                 
                                               const char* szUserID,
                                               const char* szPasswd,
                                               const char* szRealm) ;

SIPXTAPI_API SIPX_RESULT sipxLineGet(const SIPX_INST hInst,
                                     SIPX_LINE lines[],
                                     const size_t max,
                                     size_t& actual) ;

SIPXTAPI_API SIPX_RESULT sipxLineGetURI(const SIPX_LINE hLine,
                                        char*  szBuffer,
                                        const size_t nBuffer,
                                        size_t& nActual) ;

SIPXTAPI_API SIPX_RESULT sipxLineGetContactId(const SIPX_LINE  hLine,
                                              SIPX_CONTACT_ID& contactId) ;


SIPXTAPI_API SIPX_RESULT sipxLineFindByURI(const SIPX_INST hInst,
                                           const char* szURI,
                                           SIPX_LINE&  hLine) ;




SIPXTAPI_API SIPX_RESULT sipxConfigSetLogLevel(SIPX_LOG_LEVEL logLevel) ;


SIPXTAPI_API SIPX_RESULT sipxConfigSetLogFile(const char *szFilename) ;


SIPXTAPI_API SIPX_RESULT sipxConfigSetLogCallback(sipxLogCallback pCallback);


SIPXTAPI_API SIPX_RESULT sipxConfigEnableGIPSTracing(SIPX_INST hInst, 
                                                     bool bEnable) ;

SIPXTAPI_API SIPX_RESULT sipxConfigSetMicAudioHook(fnMicAudioHook hookProc) ;


SIPXTAPI_API SIPX_RESULT sipxConfigSetSpkrAudioHook(fnSpkrAudioHook hookProc) ;

/*
 * Set the period of time between stream (e.g. mic, RTP) energy
 * level notifications.
 *
 @ param 
 */
SIPXTAPI_API SIPX_RESULT sipxConfigSetEnergyLevelNotificationPeriod(const SIPX_INST hInst,
                                                                    int periodMs);

SIPXTAPI_API SIPX_RESULT sipxConfigSetUserAgentName(const SIPX_INST hInst, 
                                                    const char* szName, 
                                                    const bool bIncludePlatformName = true);
                                                    
SIPXTAPI_API SIPX_RESULT sipxConfigSetOutboundProxy(const SIPX_INST hInst,
                                                    const char* szProxy) ;

SIPXTAPI_API SIPX_RESULT sipxConfigSetDnsSrvTimeouts(const int initialTimeoutInSecs, 
                                                     const int retries) ;


SIPXTAPI_API SIPX_RESULT sipxConfigSetRegisterResponseWaitSeconds(const SIPX_INST hInst,
                                                                  const int seconds);   
SIPXTAPI_API SIPX_RESULT sipxConfigSetDnsSrvFailoverTimeout(const SIPX_INST hInst,
                                                            const int failoverTimeoutInSecs); 


SIPXTAPI_API SIPX_RESULT sipxConfigEnableRport(const SIPX_INST hInst,
                                               const bool bEnable) ;

SIPXTAPI_API SIPX_RESULT sipxConfigEnableRportMapping(const SIPX_INST hInst,
                                                      const bool bEnable);
                                               
SIPXTAPI_API SIPX_RESULT sipxConfigSetRegisterExpiration(const SIPX_INST hInst,
                                                         const int nRegisterExpirationSecs);

SIPXTAPI_API SIPX_RESULT sipxConfigSetSubscribeExpiration(const SIPX_INST hInst,
                                                          const int nSubscribeExpirationSecs);
   
SIPXTAPI_API SIPX_RESULT sipxConfigEnableStun(const SIPX_INST hInst,
                                              const char* szServer, 
                                              int iServerPort,
                                              int iKeepAliveInSecs) ;

SIPXTAPI_API SIPX_RESULT sipxConfigDisableStun(const SIPX_INST hInst) ;


SIPXTAPI_API SIPX_RESULT sipxConfigEnableTurn(const SIPX_INST hInst,
                                              const char*     szServer,
                                              const int       iServerPort,
                                              const char*     szUsername,
                                              const char*     szPassword,
                                              const int       iKeepAliveInSecs) ;

SIPXTAPI_API SIPX_RESULT sipxConfigDisableTurn(const SIPX_INST hInst) ;


SIPXTAPI_API SIPX_RESULT sipxConfigEnableIce(const SIPX_INST hInst) ;


SIPXTAPI_API SIPX_RESULT sipxConfigDisableIce(const SIPX_INST hInst) ;


SIPXTAPI_API SIPX_RESULT sipxConfigKeepAliveAdd(const SIPX_INST     hInst,
                                                SIPX_CONTACT_ID     contactId,
                                                SIPX_KEEPALIVE_TYPE type,
                                                const char*         remoteIp,
                                                int                 remotePort,
                                                int                 keepAliveSecs) ;


SIPXTAPI_API SIPX_RESULT sipxConfigKeepAliveRemove(const SIPX_INST     hInst,
                                                   SIPX_CONTACT_ID     contactId,
                                                   SIPX_KEEPALIVE_TYPE type,
                                                   const char*         remoteIp,
                                                   int                 remotePort) ;


SIPXTAPI_API SIPX_RESULT sipxConfigEnableOutOfBandDTMF(const SIPX_INST hInst,
                                                       const bool bEnable) ;

SIPXTAPI_API SIPX_RESULT sipxConfigEnableInBandDTMF(const SIPX_INST hInst,
                                                    const bool bEnable) ;
         
         
SIPXTAPI_API SIPX_RESULT sipxConfigEnableRTCP(const SIPX_INST hInst,
                                              const bool bEnable) ;
         

SIPXTAPI_API SIPX_RESULT sipxConfigEnableDnsSrv(const bool bEnable);

SIPXTAPI_API SIPX_RESULT sipxConfigIsOutOfBandDTMFEnabled(const SIPX_INST hInst,
                                                          bool& bEnable) ;

SIPXTAPI_API SIPX_RESULT sipxConfigIsInBandDTMFEnabled(const SIPX_INST hInst,
                                                       bool& bEnable) ;


SIPXTAPI_API SIPX_RESULT sipxConfigGetVersion(char* szVersion,
                                                                                          const size_t nBuffer) ;

SIPXTAPI_API SIPX_RESULT sipxConfigGetLocalSipUdpPort(SIPX_INST hInst, int* pPort) ;

SIPXTAPI_API SIPX_RESULT sipxConfigAddContact(const SIPX_INST hInst,
                                              const char* szSipContactAddress,
                                              const int iSipContactPort,
                                              SIPX_CONTACT_ID& iNewContactId);

SIPXTAPI_API SIPX_RESULT sipxConfigGetLocalSipTcpPort(SIPX_INST hInst, int* pPort) ;


SIPXTAPI_API SIPX_RESULT sipxConfigGetLocalSipTlsPort(SIPX_INST hInst, int* pPort) ;


SIPXTAPI_API SIPX_RESULT sipxConfigSetAudioCodecPreferences(const SIPX_INST hInst, 
                                                            SIPX_AUDIO_BANDWIDTH_ID bandWidth) ;

SIPXTAPI_API SIPX_RESULT sipxConfigSetAudioCodecByName(const SIPX_INST hInst, 
                                                       const char* szCodecName) ;

SIPXTAPI_API SIPX_RESULT sipxConfigGetAudioCodecPreferences(const SIPX_INST hInst, 
                                                            SIPX_AUDIO_BANDWIDTH_ID *pBandWidth);

SIPXTAPI_API SIPX_RESULT sipxConfigGetNumAudioCodecs(const SIPX_INST hInst, 
                                                     int* pNumCodecs) ;


SIPXTAPI_API SIPX_RESULT sipxConfigGetAudioCodec(const SIPX_INST hInst, 
                                                 const int index, 
                                                 SIPX_AUDIO_CODEC* pCodec) ;

SIPXTAPI_API SIPX_RESULT sipxConfigSetVideoBandwidth(const SIPX_INST hInst, 
                                                     SIPX_VIDEO_BANDWIDTH_ID bandWidth);

SIPXTAPI_API SIPX_RESULT sipxConfigGetVideoCaptureDevices(const SIPX_INST hInst,
                                                          char **arrSzCaptureDevices,
                                                          int nDeviceStringLength,
                                                          int nArrayLength);
                                                          

SIPXTAPI_API SIPX_RESULT sipxConfigGetVideoCaptureDevice(const SIPX_INST hInst,
                                                         char* szCaptureDevice,
                                                         int nLength);
                                                          
SIPXTAPI_API SIPX_RESULT sipxConfigSetVideoCaptureDevice(const SIPX_INST hInst,
                                                         const char* szCaptureDevice);
                                                          
                            
SIPXTAPI_API SIPX_RESULT sipxConfigSetVideoCodecByName(const SIPX_INST hInst, 
                                                       const char* szCodecName) ;

SIPXTAPI_API SIPX_RESULT sipxConfigResetVideoCodecs(const SIPX_INST hInst);

SIPXTAPI_API SIPX_RESULT sipxConfigGetVideoCodecPreferences(const SIPX_INST hInst, 
                                                            SIPX_VIDEO_BANDWIDTH_ID *pBandWidth);

SIPXTAPI_API SIPX_RESULT sipxConfigGetNumVideoCodecs(const SIPX_INST hInst, 
                                                     int* pNumCodecs) ;


SIPXTAPI_API SIPX_RESULT sipxConfigSetVideoFormat(const SIPX_INST hInst,
                                                  SIPX_VIDEO_FORMAT videoFormat);


SIPXTAPI_API SIPX_RESULT sipxConfigGetVideoCodec(const SIPX_INST hInst, 
                                                 const int index, 
                                                 SIPX_VIDEO_CODEC* pCodec) ;

SIPXTAPI_API SIPX_RESULT sipxConfigGetLocalContacts(const SIPX_INST hInst,
                                                    SIPX_CONTACT_ADDRESS addresses[],
                                                    size_t nMaxAddresses,
                                                    size_t& nActualAddresses) ;

SIPXTAPI_API SIPX_RESULT sipxConfigGetLocalFeedbackAddress(const SIPX_INST hInst,
                                                           const char*     szRemoteIp,
                                                           const int       iRemotePort,
                                                           char*           szContactIp,
                                                           size_t          nContactIpLength,
                                                           int&            iContactPort,
                                                           int             iTimeoutMs) ;

SIPXTAPI_API SIPX_RESULT sipxConfigGetAllLocalNetworkIps(const char* arrAddresses[], 
                                                         const char* arrAddressAdapter[],
                                                         int &numAddresses);
                                                         
SIPXTAPI_API SIPX_RESULT sipxConfigSetSecurityParameters(const SIPX_INST hInst,
                                                         const char* szDbLocation,
                                                         const char* szMyCertNickname,
                                                         const char* szDbPassword);                                        

SIPXTAPI_API SIPX_RESULT sipxConfigEnableSipShortNames(const SIPX_INST hInst, 
                                                       const bool bEnabled);

SIPXTAPI_API SIPX_RESULT sipxConfigEnableSipDateHeader(const SIPX_INST hInst, 
                                                       const bool bEnabled);
SIPXTAPI_API SIPX_RESULT sipxConfigEnableSipAllowHeader(const SIPX_INST hInst, 
                                                       const bool bEnabled);
SIPXTAPI_API SIPX_RESULT sipxConfigSetSipAcceptLanguage(const SIPX_INST hInst, 
                                                        const char* szLanguage);
SIPXTAPI_API SIPX_RESULT sipxConfigSetLocationHeader(const SIPX_INST hInst, 
                                                     const char* szHeader);

SIPXTAPI_API SIPX_RESULT sipxConfigSetConnectionIdleTimeout(const SIPX_INST hInst, 
                                                            const int idleTimeout);

SIPXTAPI_API SIPX_RESULT sipxConfigPrepareToHibernate(const SIPX_INST hInst);


SIPXTAPI_API SIPX_RESULT sipxConfigUnHibernate(const SIPX_INST hInst);


SIPXTAPI_API SIPX_RESULT sipxConfigEnableRtpOverTcp(const SIPX_INST hInst,
                                                    bool bEnable);

SIPXTAPI_API SIPX_RESULT sipxConfigSetVideoPreviewDisplay(const SIPX_INST hInst, 
                                                          SIPX_VIDEO_DISPLAY* const pDisplay);


SIPXTAPI_API SIPX_RESULT sipxConfigUpdatePreviewWindow(const SIPX_INST hInst, const SIPX_WINDOW_HANDLE hWnd);


SIPXTAPI_API SIPX_RESULT sipxConfigSetVideoQuality(const SIPX_INST hInst, const SIPX_VIDEO_QUALITY_ID quality);

SIPXTAPI_API SIPX_RESULT sipxConfigSetVideoParameters(const SIPX_INST hInst, 
                                                      const int bitRate,
                                                      const int frameRate);

SIPXTAPI_API SIPX_RESULT sipxConfigSetVideoBitrate(const SIPX_INST hInst, 
                                                   const int bitRate);

SIPXTAPI_API SIPX_RESULT sipxConfigSetVideoFramerate(const SIPX_INST hInst, 
                                                     const int frameRate);

SIPXTAPI_API SIPX_RESULT sipxConfigSetVideoCpuUsage(const SIPX_INST hInst, 
                                                    const int cpuUsage);


SIPXTAPI_API SIPX_RESULT sipxConfigSubscribe(const SIPX_INST hInst, 
                                             const SIPX_LINE hLine, 
                                             const char* szTargetUrl, 
                                             const char* szEventType, 
                                             const char* szAcceptType, 
                                             const SIPX_CONTACT_ID contactId, 
                                             SIPX_SUB* phSub); 
SIPXTAPI_API SIPX_RESULT sipxConfigUnsubscribe(const SIPX_SUB hSub); 


SIPXTAPI_API SIPX_RESULT sipxConfigExternalTransportAdd(SIPX_INST const           hInst,
                                                        SIPX_TRANSPORT&           hTransport,
                                                        const bool                bIsReliable,
                                                        const char*               szTransport,
                                                        const char*               szLocalIP,
                                                        const int                 iLocalPort,
                                                        SIPX_TRANSPORT_WRITE_PROC writeProc,
                                                        const char*               szLocalRoutingId,
                                                        const void*               pUserData = NULL) ;

SIPXTAPI_API SIPX_RESULT sipxConfigExternalTransportRemove(const SIPX_TRANSPORT hTransport);

SIPXTAPI_API SIPX_RESULT sipxConfigExternalTransportRouteByUser(const SIPX_TRANSPORT hTransport,
                                                                bool                 bRouteByUser) ;

SIPXTAPI_API SIPX_RESULT sipxConfigExternalTransportHandleMessage(const SIPX_TRANSPORT hTransport,
                                                                  const char*  szSourceIP,
                                                                  const int    iSourcePort,
                                                                  const char*  szLocalIP,
                                                                  const int    iLocalPort,
                                                                  const void*  pData,
                                                                  const size_t nData);

SIPXTAPI_API SIPX_RESULT sipxConfigSetVoiceQualityServer(const SIPX_INST hInst,
                                                         const char*     szServer) ;



SIPXTAPI_API SIPX_RESULT sipxUtilUrlParse(const char* szUrl,
                                          char* szUsername,
                                          char* szHostname,
                                          int*  iPort) ;

SIPXTAPI_API SIPX_RESULT sipxUtilUrlGetDisplayName(const char* szUrl,
                                                   char*       szDisplayName,
                                                   size_t      nDisplayName) ;

SIPXTAPI_API SIPX_RESULT sipxUtilUrlUpdate(char*       szUrl,
                                           size_t &    nUrl,
                                           const char* szNewUsername,
                                           const char* szNewHostname,
                                           const int   iNewPort) ;


SIPXTAPI_API SIPX_RESULT sipxUtilUrlGetUrlParam(const char* szUrl,
                                                const char* szParamName,
                                                size_t      nParamIndex,
                                                char*       szParamValue,
                                                size_t      nParamValue) ;


#endif // _sipXtapi_h_