TeamTalk.cs

/*
 * Copyright (c) 2005-2018, BearWare.dk
 * 
 * Contact Information:
 *
 * Bjoern D. Rasmussen
 * Kirketoften 5
 * DK-8260 Viby J
 * Denmark
 * Email: contact@bearware.dk
 * Phone: +45 20 20 54 59
 * Web: http://www.bearware.dk
 *
 * This source code is part of the TeamTalk SDK owned by
 * BearWare.dk. Use of this file, or its compiled unit, requires a
 * TeamTalk SDK License Key issued by BearWare.dk.
 *
 * The TeamTalk SDK License Agreement along with its Terms and
 * Conditions are outlined in the file License.txt included with the
 * TeamTalk SDK distribution.
 *
 */
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Imaging;
using System.Threading;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.InteropServices;
using c_tt;
 
namespace BearWare
{
    [Flags]
    public enum StreamType : uint
    {
        STREAMTYPE_NONE                             = 0x00000000,
        STREAMTYPE_VOICE                            = 0x00000001,
        STREAMTYPE_VIDEOCAPTURE                     = 0x00000002,
        STREAMTYPE_MEDIAFILE_AUDIO                  = 0x00000004,
        STREAMTYPE_MEDIAFILE_VIDEO                  = 0x00000008,
        STREAMTYPE_DESKTOP                          = 0x00000010,
        STREAMTYPE_DESKTOPINPUT                     = 0x00000020,
        STREAMTYPE_MEDIAFILE                        = STREAMTYPE_MEDIAFILE_AUDIO |
                                                      STREAMTYPE_MEDIAFILE_VIDEO,
        STREAMTYPE_CHANNELMSG                       = 0x00000040,
        STREAMTYPE_LOCALMEDIAPLAYBACK_AUDIO = 0x00000080,
 
        STREAMTYPE_CLASSROOM_ALL = STREAMTYPE_VOICE |
                                                      STREAMTYPE_VIDEOCAPTURE |
                                                      STREAMTYPE_DESKTOP |
                                                      STREAMTYPE_MEDIAFILE |
                                                      STREAMTYPE_CHANNELMSG,
    }
    public enum SoundSystem : uint
    {
        SOUNDSYSTEM_NONE = 0,
        SOUNDSYSTEM_WINMM = 1,
        SOUNDSYSTEM_DSOUND = 2,
        SOUNDSYSTEM_ALSA = 3,
        SOUNDSYSTEM_COREAUDIO = 4,
        SOUNDSYSTEM_WASAPI = 5,
        SOUNDSYSTEM_OPENSLES_ANDROID = 7,
        SOUNDSYSTEM_AUDIOUNIT = 8,
        SOUNDSYSTEM_AUDIOUNIT_IOS = SOUNDSYSTEM_AUDIOUNIT,
    }
 
    [Flags]
    public enum SoundDeviceFeature : uint
    {
        SOUNDDEVICEFEATURE_NONE = 0x0000,
        SOUNDDEVICEFEATURE_AEC = 0x0001,
        SOUNDDEVICEFEATURE_AGC = 0x0002,
        SOUNDDEVICEFEATURE_DENOISE = 0x0004,
        SOUNDDEVICEFEATURE_3DPOSITION = 0x0008,
        SOUNDDEVICEFEATURE_DUPLEXMODE = 0x0010,
        SOUNDDEVICEFEATURE_DEFAULTCOMDEVICE = 0x0020,
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct SoundDevice
    {
        public int nDeviceID;
        public SoundSystem nSoundSystem;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szDeviceName;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szDeviceID;
        public int nWaveDeviceID;
        public bool bSupports3D;
        public int nMaxInputChannels;
        public int nMaxOutputChannels;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_SAMPLERATES_MAX)]
        public int[] inputSampleRates;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_SAMPLERATES_MAX)]
        public int[] outputSampleRates;
        public int nDefaultSampleRate;
        public SoundDeviceFeature uSoundDeviceFeatures;
    }
 
 
    public struct SoundDeviceEffects
    {
        public bool bEnableAGC;
        public bool bEnableDenoise;
        public bool bEnableEchoCancellation;
    }
 
    public struct SoundDeviceConstants
    {
        public const int TT_SOUNDDEVICE_ID_REMOTEIO = 0;
        public const int TT_SOUNDDEVICE_ID_VOICEPREPROCESSINGIO = (1 | (int)TT_SOUNDDEVICE_ID_SHARED_FLAG);
        public const int TT_SOUNDDEVICE_ID_OPENSLES_DEFAULT = 0;
        public const int TT_SOUNDDEVICE_ID_OPENSLES_VOICECOM = 1;
        public const int TT_SOUNDDEVICE_ID_TEAMTALK_VIRTUAL = 1978;
 
 
        public const uint TT_SOUNDDEVICE_ID_SHARED_FLAG = 0x00000800;
 
        public const uint TT_SOUNDDEVICE_ID_MASK = 0x000007FF;
    }
 
    public struct SoundLevel
    {
        public const int SOUND_VU_MAX = 100;
        public const int SOUND_VU_MIN = 0;
        public const int SOUND_VOLUME_MAX = 32000;
        public const int SOUND_VOLUME_DEFAULT = 1000;
        public const int SOUND_VOLUME_MIN = 0;
        public const int SOUND_GAIN_MAX = 32000;
        public const int SOUND_GAIN_DEFAULT = 1000;
        public const int SOUND_GAIN_MIN = 0;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct AudioBlock
    {
        public int nStreamID;
        public int nSampleRate;
        public int nChannels;
        public System.IntPtr lpRawAudio;
        public int nSamples;
        public uint uSampleIndex;
        StreamType uStreamTypes;
    }
 
    public enum MediaFileStatus : uint
    {
        MFS_CLOSED          = 0,
        MFS_ERROR           = 1,
        MFS_STARTED         = 2,
        MFS_FINISHED        = 3,
        MFS_ABORTED         = 4,
        MFS_PAUSED          = 5,
        MFS_PLAYING         = 6
    }
 
    public enum AudioFileFormat : uint
    {
        AFF_NONE = 0,
        AFF_CHANNELCODEC_FORMAT  = 1,
        AFF_WAVE_FORMAT = 2,
        AFF_MP3_16KBIT_FORMAT = 3,
        AFF_MP3_32KBIT_FORMAT = 4,
        AFF_MP3_64KBIT_FORMAT = 5,
        AFF_MP3_128KBIT_FORMAT = 6,
        AFF_MP3_256KBIT_FORMAT = 7,
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct AudioFormat
    {
        public AudioFileFormat nAudioFmt;
        public int nSampleRate;
        public int nChannels;
    }
 
    public enum FourCC : uint
    {
        FOURCC_NONE     = 0,
        FOURCC_I420     = 100,
        FOURCC_YUY2     = 101,
        FOURCC_RGB32    = 102
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct VideoFormat
    {
        public int nWidth;
        public int nHeight;
        public int nFPS_Numerator;
        public int nFPS_Denominator;
        public FourCC picFourCC;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct VideoFrame
    {
        public int nWidth;
        public int nHeight;
        public int nStreamID;
        public bool bKeyFrame;
        public System.IntPtr frameBuffer;
        public int nFrameBufferSize;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct VideoCaptureDevice
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szDeviceID;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szDeviceName;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szCaptureAPI;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_VIDEOFORMATS_MAX)]
        public VideoFormat[] videoFormats;
        public int nVideoFormatsCount;
    }
 
    public enum BitmapFormat : uint
    {
        BMP_NONE            = 0,
        BMP_RGB8_PALETTE    = 1,
        BMP_RGB16_555       = 2,
        BMP_RGB24           = 3,
        BMP_RGB32           = 4
    }
 
    public enum DesktopProtocol : uint
    {
        DESKTOPPROTOCOL_ZLIB_1  = 1
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct DesktopWindow
    {
        public int nWidth;
        public int nHeight;
        public BitmapFormat bmpFormat;
        public int nBytesPerLine;
        public int nSessionID;
        public DesktopProtocol nProtocol;
        public IntPtr frameBuffer;
        public int nFrameBufferSize;
    }
 
    public enum DesktopKeyState : uint
    {
        DESKTOPKEYSTATE_NONE       = 0x00000000,
        DESKTOPKEYSTATE_DOWN       = 0x00000001,
        DESKTOPKEYSTATE_UP         = 0x00000002,
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct DesktopInput
    {
        public ushort uMousePosX;
        public ushort uMousePosY;
        public uint uKeyCode;
        public DesktopKeyState uKeyState;
        public DesktopInput(bool set_defaults)
        {
            if (set_defaults)
            {
                uMousePosX = uMousePosY = (ushort)DesktopInputConstants.DESKTOPINPUT_MOUSEPOS_IGNORE;
                uKeyCode = DesktopInputConstants.DESKTOPINPUT_KEYCODE_IGNORE;
                uKeyState = DesktopKeyState.DESKTOPKEYSTATE_NONE;
            }
            else
            {
                uMousePosX = uMousePosY = 0;
                uKeyCode = 0;
                uKeyState = DesktopKeyState.DESKTOPKEYSTATE_NONE;
            }
        }
    }
 
    public struct DesktopInputConstants
    {
        public const uint DESKTOPINPUT_KEYCODE_IGNORE = 0xFFFFFFFF;
 
        public const ushort DESKTOPINPUT_MOUSEPOS_IGNORE = 0xFFFF;
 
        public const uint DESKTOPINPUT_KEYCODE_LMOUSEBTN = 0x1000;
 
        public const uint DESKTOPINPUT_KEYCODE_RMOUSEBTN = 0x1001;
 
        public const uint DESKTOPINPUT_KEYCODE_MMOUSEBTN = 0x1002;
    }
 
    [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
    public struct SpeexCodec
    {
        [FieldOffset(0)]
        public int nBandmode;
        [FieldOffset(4)]
        public int nQuality;
        [FieldOffset(8)]
        public int nTxIntervalMSec;
        [FieldOffset(12)]
        public bool bStereoPlayback;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct SpeexVBRCodec
    {
        public int nBandmode;
        public int nQuality;
        public int nBitRate;
        public int nMaxBitRate;
        public bool bDTX;
        public int nTxIntervalMSec;
        public bool bStereoPlayback; 
    }
 
    public struct SpeexConstants
    {
        public const int SPEEX_BANDMODE_NARROW = 0;
        public const int SPEEX_BANDMODE_WIDE = 1;
        public const int SPEEX_BANDMODE_UWIDE = 2;
        public const int SPEEX_QUALITY_MIN = 0;
        public const int SPEEX_QUALITY_MAX = 10;
        public const int SPEEX_NB_MIN_BITRATE = 2150;
        public const int SPEEX_NB_MAX_BITRATE = 24600;
        public const int SPEEX_WB_MIN_BITRATE = 3950;
        public const int SPEEX_WB_MAX_BITRATE = 42200;
        public const int SPEEX_UWB_MIN_BITRATE = 4150;
        public const int SPEEX_UWB_MAX_BITRATE = 44000;
        public const int DEFAULT_SPEEX_BANDMODE = 1;
        public const int DEFAULT_SPEEX_QUALITY = 4;
        public const int DEFAULT_SPEEX_DELAY = 40;
        public const bool DEFAULT_SPEEX_SIMSTEREO = false;
        public const int DEFAULT_SPEEX_BITRATE = 0;
        public const int DEFAULT_SPEEX_MAXBITRATE = 0;
        public const bool DEFAULT_SPEEX_DTX = true;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct OpusCodec
    {
        public int nSampleRate;
        public int nChannels;
        public int nApplication;
        public int nComplexity;
        public bool bFEC;
        public bool bDTX;
        public int nBitRate;
        public bool bVBR;
        public bool bVBRConstraint;
        public int nTxIntervalMSec;
        public int nFrameSizeMSec;
    }
 
    public struct OpusConstants
    {
        public const int OPUS_APPLICATION_VOIP = 2048;
        public const int OPUS_APPLICATION_AUDIO = 2049;
        public const int OPUS_MIN_BITRATE = 6000;
        public const int OPUS_MAX_BITRATE = 510000;
 
        public const int OPUS_MIN_FRAMESIZE = 2; /* Actually it's 2.5 */
        public const int OPUS_MAX_FRAMESIZE = 60;
        public const int OPUS_REALMAX_FRAMESIZE = 120;
 
        public const int DEFAULT_OPUS_APPLICATION = OPUS_APPLICATION_VOIP;
        public const int DEFAULT_OPUS_SAMPLERATE = 48000;
        public const int DEFAULT_OPUS_CHANNELS = 1;
        public const int DEFAULT_OPUS_COMPLEXITY = 10;
        public const bool DEFAULT_OPUS_FEC = true;
        public const bool DEFAULT_OPUS_DTX = false;
        public const bool DEFAULT_OPUS_VBR = true;
        public const bool DEFAULT_OPUS_VBRCONSTRAINT = false;
        public const int DEFAULT_OPUS_BITRATE = 32000;
        public const int DEFAULT_OPUS_DELAY = 20;
    }
 
    [StructLayout(LayoutKind.Explicit)]
    public struct SpeexDSP
    {
        [FieldOffset(0)]
        public bool bEnableAGC;
        [FieldOffset(4)]
        public int nGainLevel;
        [FieldOffset(8)]
        public int nMaxIncDBSec;
        [FieldOffset(12)]
        public int nMaxDecDBSec;
        [FieldOffset(16)]
        public int nMaxGainDB;
        [FieldOffset(20)]
        public bool bEnableDenoise;
        [FieldOffset(24)]
        public int nMaxNoiseSuppressDB;
        [FieldOffset(28)]
        public bool bEnableEchoCancellation;
        [FieldOffset(32)]
        public int nEchoSuppress;
        [FieldOffset(36)]
        public int nEchoSuppressActive;
 
        public SpeexDSP(bool set_defaults)
        {
            if (set_defaults)
            {
                bEnableAGC = SpeexDSPConstants.DEFAULT_AGC_ENABLE;
                nGainLevel = SpeexDSPConstants.DEFAULT_AGC_GAINLEVEL;
                nMaxIncDBSec = SpeexDSPConstants.DEFAULT_AGC_INC_MAXDB;
                nMaxDecDBSec = SpeexDSPConstants.DEFAULT_AGC_DEC_MAXDB;
                nMaxGainDB = SpeexDSPConstants.DEFAULT_AGC_GAINMAXDB;
 
                bEnableDenoise = SpeexDSPConstants.DEFAULT_DENOISE_ENABLE;
                nMaxNoiseSuppressDB = SpeexDSPConstants.DEFAULT_DENOISE_SUPPRESS;
 
                bEnableEchoCancellation = SpeexDSPConstants.DEFAULT_ECHO_ENABLE;
                nEchoSuppress = SpeexDSPConstants.DEFAULT_ECHO_SUPPRESS;
                nEchoSuppressActive = SpeexDSPConstants.DEFAULT_ECHO_SUPPRESS_ACTIVE;
            }
            else
            {
                bEnableAGC = false;
                nGainLevel = 0;
                nMaxIncDBSec = 0;
                nMaxDecDBSec = 0;
                nMaxGainDB = 0;
 
                bEnableDenoise = false;
                nMaxNoiseSuppressDB = 0;
 
                bEnableEchoCancellation = false;
                nEchoSuppress = 0;
                nEchoSuppressActive = 0;
            }
        }
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct TTAudioPreprocessor
    {
        public int nGainLevel;
        public bool bMuteLeftSpeaker;
        public bool bMuteRightSpeaker;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct WebRTCAudioPreprocessor
    {
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public struct Preamplifier
        {
            public bool bEnable;
            public float fFixedGainFactor;
        }
        public Preamplifier preamplifier;
 
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public struct EchoCanceller
        {
            public bool bEnable;
        }
        public EchoCanceller echocanceller;
 
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public struct NoiseSuppression
        {
            public bool bEnable;
            public int nLevel;
        }
        public NoiseSuppression noisesuppression;
 
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public struct VoiceDetection
        {
            public bool bEnable;
        }
        public VoiceDetection voicedetection;
 
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public struct GainController2
        {
            public bool bEnable;
            [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
            public struct FixedDigital
            {
                public float fGainDB;
            }
            public FixedDigital fixeddigital;
 
            [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
            public struct AdaptiveDigital
            {
                /* @brief Enable saturation protector where saturation
                 * margin is 2 dB. */
                public bool bEnable;
                /* Range: 0 <= x <= 100. Default: 20 dB */
                public float fInitialSaturationMarginDB;
                /* Range: 0 <= x <= 100. Default: 2 dB */
                public float fExtraSaturationMarginDB;
                /* Range: 0 < x < infinite. Default: 3 dB/sec */
                public float fMaxGainChangeDBPerSecond;
                /* Range: -infinite < x < 0. Default: -50 */
                public float fMaxOutputNoiseLevelDBFS;
            }
            public AdaptiveDigital adaptivedigital;
        }
        public GainController2 gaincontroller2;
 
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public struct LevelEstimation
        {
            public bool bEnable;
        }
        public LevelEstimation levelestimation;
 
        public WebRTCAudioPreprocessor(bool set_defaults)
        {
            if (set_defaults)
            {
                preamplifier.bEnable = WebRTCConstants.DEFAULT_WEBRTC_PREAMPLIFIER_ENABLE;
                preamplifier.fFixedGainFactor = WebRTCConstants.DEFAULT_WEBRTC_PREAMPLIFIER_GAINFACTOR;
 
                echocanceller.bEnable = WebRTCConstants.DEFAULT_WEBRTC_ECHO_CANCEL_ENABLE;
 
                noisesuppression.bEnable = WebRTCConstants.DEFAULT_WEBRTC_NOISESUPPRESS_ENABLE;
                noisesuppression.nLevel = WebRTCConstants.DEFAULT_WEBRTC_NOISESUPPRESS_LEVEL;
 
                voicedetection.bEnable = WebRTCConstants.DEFAULT_WEBRTC_VAD_ENABLE;
 
                gaincontroller2.bEnable = WebRTCConstants.DEFAULT_WEBRTC_GAINCTL_ENABLE;
                gaincontroller2.fixeddigital.fGainDB = WebRTCConstants.DEFAULT_WEBRTC_GAINDB;
 
                gaincontroller2.adaptivedigital.bEnable = WebRTCConstants.DEFAULT_WEBRTC_SAT_PROT_ENABLE;
                gaincontroller2.adaptivedigital.fInitialSaturationMarginDB = WebRTCConstants.DEFAULT_WEBRTC_INIT_SAT_MARGIN_DB;
                gaincontroller2.adaptivedigital.fExtraSaturationMarginDB = WebRTCConstants.DEFAULT_WEBRTC_EXTRA_SAT_MARGIN_DB;
                gaincontroller2.adaptivedigital.fMaxGainChangeDBPerSecond = WebRTCConstants.DEFAULT_WEBRTC_MAXGAIN_DBSEC;
                gaincontroller2.adaptivedigital.fMaxOutputNoiseLevelDBFS = WebRTCConstants.DEFAULT_WEBRTC_MAX_OUT_NOISE;
 
                levelestimation.bEnable = WebRTCConstants.DEFAULT_WEBRTC_LEVELESTIMATION_ENABLE;
            }
            else
            {
                preamplifier.bEnable = false;
                preamplifier.fFixedGainFactor = 0.0f;
 
                echocanceller.bEnable = false;
 
                noisesuppression.bEnable = false;
                noisesuppression.nLevel = 0;
 
                voicedetection.bEnable = false;
 
                gaincontroller2.bEnable = false;
                gaincontroller2.fixeddigital.fGainDB = 0.0f;
 
                gaincontroller2.adaptivedigital.bEnable = false;
                gaincontroller2.adaptivedigital.fInitialSaturationMarginDB = 0.0f;
                gaincontroller2.adaptivedigital.fExtraSaturationMarginDB = 0.0f;
                gaincontroller2.adaptivedigital.fMaxGainChangeDBPerSecond = 0.0f;
                gaincontroller2.adaptivedigital.fMaxOutputNoiseLevelDBFS = 0.0f;
 
                levelestimation.bEnable = false;
            }
        }
    }
 
    public struct WebRTCConstants
    {
        public const bool DEFAULT_WEBRTC_PREAMPLIFIER_ENABLE = false;
        public const float DEFAULT_WEBRTC_PREAMPLIFIER_GAINFACTOR = 1.0f;
        public const bool DEFAULT_WEBRTC_VAD_ENABLE = false;
        public const bool DEFAULT_WEBRTC_LEVELESTIMATION_ENABLE = false;
        public const bool DEFAULT_WEBRTC_GAINCTL_ENABLE = false;
        public const float DEFAULT_WEBRTC_GAINDB = 15;
        public const bool DEFAULT_WEBRTC_SAT_PROT_ENABLE = false;
        public const float DEFAULT_WEBRTC_INIT_SAT_MARGIN_DB = 20;
        public const float DEFAULT_WEBRTC_EXTRA_SAT_MARGIN_DB = 2;
        public const float DEFAULT_WEBRTC_MAXGAIN_DBSEC = 3;
        public const float DEFAULT_WEBRTC_MAX_OUT_NOISE = -50;
        public const bool DEFAULT_WEBRTC_NOISESUPPRESS_ENABLE = false;
        public const int DEFAULT_WEBRTC_NOISESUPPRESS_LEVEL = 2;
        public const bool DEFAULT_WEBRTC_ECHO_CANCEL_ENABLE = false;
        public const float WEBRTC_GAINCONTROLLER2_FIXEDGAIN_MAX = 49.9f;
    }
 
    public enum AudioPreprocessorType : uint
    {
        NO_AUDIOPREPROCESSOR = 0,
        SPEEXDSP_AUDIOPREPROCESSOR = 1,
        TEAMTALK_AUDIOPREPROCESSOR = 2,
        WEBRTC_AUDIOPREPROCESSOR = 3,
    };
 
    [StructLayout(LayoutKind.Explicit)]
    public struct AudioPreprocessor
    {
        [FieldOffset(0)]
        public AudioPreprocessorType nPreprocessor;
        [FieldOffset(4)]
        public SpeexDSP speexdsp;
        [FieldOffset(4)]
        public TTAudioPreprocessor ttpreprocessor;
        [FieldOffset(4)]
        public WebRTCAudioPreprocessor webrtc;
    }
 
    public struct SpeexDSPConstants
    {
        public const bool DEFAULT_AGC_ENABLE = true;
        public const int DEFAULT_AGC_GAINLEVEL = 8000;
        public const int DEFAULT_AGC_INC_MAXDB = 12;
        public const int DEFAULT_AGC_DEC_MAXDB = -40;
        public const int DEFAULT_AGC_GAINMAXDB = 30;
        public const bool DEFAULT_DENOISE_ENABLE = true;
        public const int DEFAULT_DENOISE_SUPPRESS = -30;
        public const bool DEFAULT_ECHO_ENABLE = true;
        public const int DEFAULT_ECHO_SUPPRESS = -40;
        public const int DEFAULT_ECHO_SUPPRESS_ACTIVE = -15;
    }
 
    [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
    public struct WebMVP8Codec
    {
        [FieldOffset(0)]
        public int nRcTargetBitrate;
        [FieldOffset(0)]
        public int rc_target_bitrate;
        [FieldOffset(4)]
        public uint nEncodeDeadline;
    }
 
    public struct WebMVP8CodecConstants
    {
        public const int WEBM_VPX_DL_REALTIME = 1;
        public const int WEBM_VPX_DL_GOOD_QUALITY = 1000000;
        public const int WEBM_VPX_DL_BEST_QUALITY = 0;
    }
 
    public enum Codec : uint
    {
        NO_CODEC = 0,
        SPEEX_CODEC = 1,
        SPEEX_VBR_CODEC = 2,
        OPUS_CODEC = 3,
        WEBM_VP8_CODEC = 128
    }
 
    [StructLayout(LayoutKind.Explicit)]
    public struct AudioCodec
    {
        [FieldOffset(0)]
        public Codec nCodec;
        [FieldOffset(4)]
        public SpeexCodec speex;
        [FieldOffset(4)]
        public SpeexVBRCodec speex_vbr;
        [FieldOffset(4)]
        public OpusCodec opus;
    }
 
    [StructLayout(LayoutKind.Explicit)]
    public struct AudioConfig
    {
        [FieldOffset(0)]
        public bool bEnableAGC;
        [FieldOffset(4)]
        public int nGainLevel;
 
        public AudioConfig(bool set_defaults)
        {
            if (set_defaults)
            {
                bEnableAGC = true;
                nGainLevel = AudioConfigConstants.DEFAULT_AGC_GAINLEVEL;
            }
            else
            {
                bEnableAGC = false;
                nGainLevel = 0;
            }
        }
    }
 
    public struct AudioConfigConstants
    {
        public const int DEFAULT_AGC_GAINLEVEL = 8000;
        public const int DEFAULT_AGC_INC_MAXDB = 12;
    }
 
    [StructLayout(LayoutKind.Explicit)]
    public struct VideoCodec
    {
        [FieldOffset(0)]
        public Codec nCodec;
        [FieldOffset(4)]
        public WebMVP8Codec webm_vp8;
    }
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct MediaFileInfo
    {
        public MediaFileStatus nStatus;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szFileName;
        public AudioFormat audioFmt;
        public VideoFormat videoFmt;
        public uint uDurationMSec;
        public uint uElapsedMSec;
    }
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct MediaFilePlayback
    {
        public uint uOffsetMSec;
        public bool bPaused;
        public AudioPreprocessor audioPreprocessor;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct AudioInputProgress
    {
        public int nStreamID;
        public uint uQueueMSec;
        public uint uElapsedMSec;
    }
 
    [Flags]
    public enum UserRight : uint
    {
        USERRIGHT_NONE                              = 0x00000000,
        USERRIGHT_MULTI_LOGIN                       = 0x00000001,
        USERRIGHT_VIEW_ALL_USERS                    = 0x00000002,
        USERRIGHT_CREATE_TEMPORARY_CHANNEL          = 0x00000004,
        USERRIGHT_MODIFY_CHANNELS                   = 0x00000008,
        USERRIGHT_TEXTMESSAGE_BROADCAST             = 0x00000010,
        USERRIGHT_KICK_USERS                        = 0x00000020,
        USERRIGHT_BAN_USERS                         = 0x00000040,
        USERRIGHT_MOVE_USERS                        = 0x00000080,
        USERRIGHT_OPERATOR_ENABLE                   = 0x00000100,
        USERRIGHT_UPLOAD_FILES                      = 0x00000200,
        USERRIGHT_DOWNLOAD_FILES                    = 0x00000400,
        USERRIGHT_UPDATE_SERVERPROPERTIES           = 0x00000800,
        USERRIGHT_TRANSMIT_VOICE                    = 0x00001000,
        USERRIGHT_TRANSMIT_VIDEOCAPTURE             = 0x00002000,
        USERRIGHT_TRANSMIT_DESKTOP                  = 0x00004000,
        USERRIGHT_TRANSMIT_DESKTOPINPUT             = 0x00008000,
        USERRIGHT_TRANSMIT_MEDIAFILE_AUDIO          = 0x00010000,
        USERRIGHT_TRANSMIT_MEDIAFILE_VIDEO          = 0x00020000,
        USERRIGHT_TRANSMIT_MEDIAFILE = USERRIGHT_TRANSMIT_MEDIAFILE_VIDEO | USERRIGHT_TRANSMIT_MEDIAFILE_AUDIO,
        USERRIGHT_LOCKED_NICKNAME                   = 0x00040000,
        USERRIGHT_LOCKED_STATUS                     = 0x00080000,
        USERRIGHT_RECORD_VOICE                      = 0x00100000,
        USERRIGHT_VIEW_HIDDEN_CHANNELS              = 0x00200000,
        USERRIGHT_ALL                               = 0xFFFFFFFF & ~USERRIGHT_LOCKED_NICKNAME & ~USERRIGHT_LOCKED_STATUS
    }
 
    [Flags]
    public enum ServerLogEvent : uint
    {
        SERVERLOGEVENT_NONE = 0x00000000,
        SERVERLOGEVENT_USER_CONNECTED = 0x00000001,
        SERVERLOGEVENT_USER_DISCONNECTED = 0x00000002,
        SERVERLOGEVENT_USER_LOGGEDIN = 0x00000004,
        SERVERLOGEVENT_USER_LOGGEDOUT = 0x00000008,
        SERVERLOGEVENT_USER_LOGINFAILED = 0x00000010,
        SERVERLOGEVENT_USER_TIMEDOUT = 0x00000020,
        SERVERLOGEVENT_USER_KICKED = 0x00000040,
        SERVERLOGEVENT_USER_BANNED = 0x00000080,
        SERVERLOGEVENT_USER_UNBANNED = 0x00000100,
        SERVERLOGEVENT_USER_UPDATED = 0x00000200,
        SERVERLOGEVENT_USER_JOINEDCHANNEL = 0x00000400,
        SERVERLOGEVENT_USER_LEFTCHANNEL = 0x00000800,
        SERVERLOGEVENT_USER_MOVED = 0x00001000,
        SERVERLOGEVENT_USER_TEXTMESSAGE_PRIVATE = 0x00002000,
        SERVERLOGEVENT_USER_TEXTMESSAGE_CUSTOM = 0x00004000,
        SERVERLOGEVENT_USER_TEXTMESSAGE_CHANNEL = 0x00008000,
        SERVERLOGEVENT_USER_TEXTMESSAGE_BROADCAST = 0x00010000,
        SERVERLOGEVENT_CHANNEL_CREATED = 0x00020000,
        SERVERLOGEVENT_CHANNEL_UPDATED = 0x00040000,
        SERVERLOGEVENT_CHANNEL_REMOVED = 0x00080000,
        SERVERLOGEVENT_FILE_UPLOADED = 0x00100000,
        SERVERLOGEVENT_FILE_DOWNLOADED = 0x00200000,
        SERVERLOGEVENT_FILE_DELETED = 0x00400000,
        SERVERLOGEVENT_SERVER_UPDATED = 0x00800000,
        SERVERLOGEVENT_SERVER_SAVECONFIG = 0x01000000,
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct ServerProperties
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szServerName;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szMOTD;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szMOTDRaw;
        public int nMaxUsers;
        public int nMaxLoginAttempts;
        public int nMaxLoginsPerIPAddress;
        public int nMaxVoiceTxPerSecond;
        public int nMaxVideoCaptureTxPerSecond;
        public int nMaxMediaFileTxPerSecond;
        public int nMaxDesktopTxPerSecond;
        public int nMaxTotalTxPerSecond;
        public bool bAutoSave;
        public int nTcpPort;
        public int nUdpPort;
        public int nUserTimeout;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szServerVersion;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szServerProtocolVersion;
        public int nLoginDelayMSec;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szAccessToken;
        public ServerLogEvent uServerLogEvents;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct ServerStatistics
    {
        public long nTotalBytesTX;
        public long nTotalBytesRX;
        public long nVoiceBytesTX;
        public long nVoiceBytesRX;
        public long nVideoCaptureBytesTX;
        public long nVideoCaptureBytesRX;
        public long nMediaFileBytesTX;
        public long nMediaFileBytesRX;
        public long nDesktopBytesTX;
        public long nDesktopBytesRX;
        public int nUsersServed;
        public int nUsersPeak;
        public long nFilesTx;
        public long nFilesRx;
        public long nUptimeMSec;
    }
 
    [Flags]
    public enum BanType : uint
    {
        BANTYPE_NONE = 0x00,
        BANTYPE_CHANNEL = 0x01,
        BANTYPE_IPADDR = 0x02,
        BANTYPE_USERNAME = 0x04
    };
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct BannedUser
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szIPAddress;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szChannelPath;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szBanTime;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szNickname;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szUsername;
        public BanType uBanTypes;
    }
 
    [Flags]
    public enum UserType : uint
    {
        USERTYPE_NONE       = 0x0,
        USERTYPE_DEFAULT    = 0x01,
        USERTYPE_ADMIN      = 0x02
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct AbusePrevention
    {
        public int nCommandsLimit;
        public int nCommandsIntervalMSec;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct UserAccount
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szUsername;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szPassword;
        public UserType uUserType;
        public UserRight uUserRights;
        public int nUserData;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szNote;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szInitChannel;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_CHANNELS_OPERATOR_MAX)]
        public int[] autoOperatorChannels;
        public int nAudioCodecBpsLimit;
        public AbusePrevention abusePrevent;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szLastModified;
    }
    [Flags]
    public enum Subscription : uint
    {
        SUBSCRIBE_NONE = 0x00000000,
        SUBSCRIBE_USER_MSG = 0x00000001,
        SUBSCRIBE_CHANNEL_MSG = 0x00000002,
        SUBSCRIBE_BROADCAST_MSG = 0x00000004,
        SUBSCRIBE_CUSTOM_MSG = 0x00000008,
        SUBSCRIBE_VOICE = 0x00000010,
        SUBSCRIBE_VIDEOCAPTURE = 0x00000020,
        SUBSCRIBE_DESKTOP = 0x00000040,
        SUBSCRIBE_DESKTOPINPUT = 0x00000080,
        SUBSCRIBE_MEDIAFILE = 0x00000100,
        SUBSCRIBE_INTERCEPT_USER_MSG = 0x00010000,
        SUBSCRIBE_INTERCEPT_CHANNEL_MSG = 0x00020000,
        /* unused SUBSCRIBE_INTERCEPT_BROADCAST_MSG = 0x00040000 */
        SUBSCRIBE_INTERCEPT_CUSTOM_MSG = 0x00080000,
        SUBSCRIBE_INTERCEPT_VOICE = 0x00100000,
        SUBSCRIBE_INTERCEPT_VIDEOCAPTURE = 0x00200000,
        SUBSCRIBE_INTERCEPT_DESKTOP = 0x00400000,
        /* unused SUBSCRIBE_INTERCEPT_DESKTOPINPUT = 0x00800000, */
        SUBSCRIBE_INTERCEPT_MEDIAFILE = 0x01000000,
    }
 
    [Flags]
    public enum UserState : uint
    {
        USERSTATE_NONE                                  = 0x0000000,
        USERSTATE_VOICE                                 = 0x00000001,
        USERSTATE_MUTE_VOICE                            = 0x00000002,
        USERSTATE_MUTE_MEDIAFILE                        = 0x00000004,
        USERSTATE_DESKTOP                               = 0x00000008,
        USERSTATE_VIDEOCAPTURE                          = 0x00000010,
        USERSTATE_MEDIAFILE_AUDIO                       = 0x00000020,
        USERSTATE_MEDIAFILE_VIDEO                       = 0x00000040,
        USERSTATE_MEDIAFILE                             = USERSTATE_MEDIAFILE_AUDIO |
                                                          USERSTATE_MEDIAFILE_VIDEO
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct User
    {
        public int nUserID;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szUsername;
        public int nUserData;
        public UserType uUserType;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szIPAddress;
        public uint uVersion;
        public int nChannelID; 
        public Subscription uLocalSubscriptions;
        public Subscription uPeerSubscriptions;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szNickname;
        public int nStatusMode;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szStatusMsg;
        public UserState uUserState;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szMediaStorageDir;
        public int nVolumeVoice;
        public int nVolumeMediaFile;
        public int nStoppedDelayVoice;
        public int nStoppedDelayMediaFile;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
        public float[] soundPositionVoice;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
        public float[] soundPositionMediaFile;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
        public bool[] stereoPlaybackVoice;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
        public bool[] stereoPlaybackMediaFile;
        public int nBufferMSecVoice;
        public int nBufferMSecMediaFile;
        public int nActiveAdaptiveDelayMSec;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szClientName;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct UserStatistics
    {
        public long nVoicePacketsRecv;
        public long nVoicePacketsLost;
        public long nVideoCapturePacketsRecv;
        public long nVideoCaptureFramesRecv;
        public long nVideoCaptureFramesLost;
        public long nVideoCaptureFramesDropped;
        public long nMediaFileAudioPacketsRecv;
        public long nMediaFileAudioPacketsLost;
        public long nMediaFileVideoPacketsRecv;
        public long nMediaFileVideoFramesRecv;
        public long nMediaFileVideoFramesLost;
        public long nMediaFileVideoFramesDropped;
    }
 
    public enum TextMsgType : uint
    {
        MSGTYPE_USER        = 1,
        MSGTYPE_CHANNEL     = 2,
        MSGTYPE_BROADCAST   = 3,
        MSGTYPE_CUSTOM = 4
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct TextMessage
    {
        public TextMsgType nMsgType;
        public int nFromUserID;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szFromUsername;
        public int nToUserID;
        public int nChannelID;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szMessage;
        public bool bMore;
    }
    [Flags]
    public enum ChannelType : uint
    {
        CHANNEL_DEFAULT                                         = 0x0000,
        CHANNEL_PERMANENT                                       = 0x0001,
        CHANNEL_SOLO_TRANSMIT                                   = 0x0002,
        CHANNEL_CLASSROOM = 0x0004,
        CHANNEL_OPERATOR_RECVONLY                               = 0x0008,
        CHANNEL_NO_VOICEACTIVATION                              = 0x0010,
        CHANNEL_NO_RECORDING                                    = 0x0020,
        CHANNEL_HIDDEN                                          = 0x0040,
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct Channel
    {
        public int nParentID;
        public int nChannelID;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szName;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szTopic;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szPassword;
        public bool bPassword;
        public ChannelType uChannelType;
        public int nUserData;
        public long nDiskQuota;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szOpPassword;
        public int nMaxUsers;
        public AudioCodec audiocodec;
        public AudioConfig audiocfg;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_TRANSMITUSERS_MAX * 2)]
        public int[] transmitUsers;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_TRANSMITQUEUE_MAX)]
        public int[] transmitUsersQueue;
 
        public int nTransmitUsersQueueDelayMSec;        
 
        public int nTimeOutTimerVoiceMSec;
 
        public int nTimeOutTimerMediaFileMSec;
        
        public void AddTransmitUser(int nUserID, StreamType uStreamType)
        {
            int i;
            for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
            {
                if (transmitUsers[i * 2] == 0 || transmitUsers[i * 2] == nUserID)
                    break;
            }
            if (i < TeamTalkBase.TT_TRANSMITUSERS_MAX)
            {
                transmitUsers[i * 2] = nUserID;
                transmitUsers[i * 2 + 1] |= (int)uStreamType;
            }
        }
        public StreamType GetTransmitStreamTypes(int nUserID)
        {
            int i;
            for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
            {
                if (transmitUsers[i * 2] == nUserID)
                    return (StreamType)transmitUsers[i * 2 + 1];
            }
            return StreamType.STREAMTYPE_NONE;
        }
        public int GetTransmitUserCount()
        {
            int i;
            for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
            {
                if (transmitUsers[i * 2] == 0)
                    break;
            }
            return i;
        }
        public void RemoveTransmitUser(int nUserID, StreamType uStreamType)
        {
            int i;
            for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
            {
                if (transmitUsers[i * 2] == nUserID)
                    break;
            }
            if (i < TeamTalkBase.TT_TRANSMITUSERS_MAX)
            {
                transmitUsers[i * 2] = nUserID;
                transmitUsers[i * 2 + 1] &= (int)~uStreamType;
 
                if (transmitUsers[i * 2 + 1] == (int)StreamType.STREAMTYPE_NONE)
                {
                    for (; i < TeamTalkBase.TT_TRANSMITUSERS_MAX - 1; i++)
                    {
                        transmitUsers[i * 2] = transmitUsers[(i + 1) * 2 + 1];
                        transmitUsers[i * 2 + 1] = transmitUsers[(i + 1) * 2 + 1];
                    }
                }
            }
        }
    }
 
    public enum FileTransferStatus : uint
    {
        FILETRANSFER_CLOSED = 0,
        FILETRANSFER_ERROR = 1,
        FILETRANSFER_ACTIVE = 2,
        FILETRANSFER_FINISHED = 3
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct FileTransfer
    {
        public FileTransferStatus nStatus;
        public int nTransferID;
        public int nChannelID;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szLocalFilePath;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szRemoteFileName;
        public long nFileSize;
        public long nTransferred;
        public bool bInbound;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct RemoteFile
    {
        public int nChannelID;
        public int nFileID;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szFileName;
        public long nFileSize;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szUsername;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szUploadTime;
    }
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct EncryptionContext
    {
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szCertificateFile;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szPrivateKeyFile;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szCAFile;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szCADir;
        public bool bVerifyPeer;
        public bool bVerifyClientOnce;
        public int nVerifyDepth;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct ClientKeepAlive
    {
        public int nConnectionLostMSec;
        public int nTcpKeepAliveIntervalMSec;
        public int nUdpKeepAliveIntervalMSec;
        public int nUdpKeepAliveRTXMSec;
        public int nUdpConnectRTXMSec;
        public int nUdpConnectTimeoutMSec;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct ClientStatistics
    {
        public long nUdpBytesSent;
        public long nUdpBytesRecv;
        public long nVoiceBytesSent;
        public long nVoiceBytesRecv;
        public long nVideoCaptureBytesSent;
        public long nVideoCaptureBytesRecv;
        public long nMediaFileAudioBytesSent;
        public long nMediaFileAudioBytesRecv;
        public long nMediaFileVideoBytesSent;
        public long nMediaFileVideoBytesRecv;
        public long nDesktopBytesSent;
        public long nDesktopBytesRecv;
        public int nUdpPingTimeMs;
        public int nTcpPingTimeMs;
        public int nTcpServerSilenceSec;
        public int nUdpServerSilenceSec;
        public int nSoundInputDeviceDelayMSec;
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct JitterConfig
    {
        public int nFixedDelayMSec;
        public bool bUseAdativeDejitter;
        public int nMaxAdaptiveDelayMSec;
        public int nActiveAdaptiveDelayMSec;
    }
 
 
    public enum ClientError : uint
    {
        CMDERR_SUCCESS = 0,
        SUCCESS = 0,
 
        /* COMMAND ERRORS 1000-1999 ARE DUE TO INVALID OR UNSUPPORTED
         * COMMANDS */
 
        CMDERR_SYNTAX_ERROR                     = 1000,
        CMDERR_UNKNOWN_COMMAND                  = 1001,
        CMDERR_MISSING_PARAMETER                = 1002,
        CMDERR_INCOMPATIBLE_PROTOCOLS           = 1003,
        CMDERR_UNKNOWN_AUDIOCODEC               = 1004,
        CMDERR_INVALID_USERNAME = 1005,
 
        /* COMMAND ERRORS 2000-2999 ARE DUE TO INSUFFICIENT RIGHTS */
 
        CMDERR_INCORRECT_SERVER_PASSWORD        = 2000,
        CMDERR_INCORRECT_CHANNEL_PASSWORD       = 2001,
        CMDERR_INVALID_ACCOUNT                  = 2002,
        CMDERR_MAX_SERVER_USERS_EXCEEDED        = 2003,
        CMDERR_MAX_CHANNEL_USERS_EXCEEDED       = 2004,
        CMDERR_SERVER_BANNED                    = 2005,
        CMDERR_NOT_AUTHORIZED                   = 2006,
        CMDERR_MAX_DISKUSAGE_EXCEEDED           = 2008,
 
        CMDERR_INCORRECT_OP_PASSWORD            = 2010,
 
        CMDERR_AUDIOCODEC_BITRATE_LIMIT_EXCEEDED = 2011,
 
        CMDERR_MAX_LOGINS_PER_IPADDRESS_EXCEEDED = 2012,
 
        CMDERR_MAX_CHANNELS_EXCEEDED            = 2013,
 
        CMDERR_COMMAND_FLOOD = 2014,
 
        CMDERR_CHANNEL_BANNED = 2015,
 
        /* COMMAND ERRORS 3000-3999 ARE DUE TO INVALID STATE OF CLIENT INSTANCE */
 
        CMDERR_NOT_LOGGEDIN = 3000,
 
        CMDERR_ALREADY_LOGGEDIN                 = 3001,
        CMDERR_NOT_IN_CHANNEL                   = 3002,
        CMDERR_ALREADY_IN_CHANNEL               = 3003,
        CMDERR_CHANNEL_ALREADY_EXISTS           = 3004,
        CMDERR_CHANNEL_NOT_FOUND                = 3005,
        CMDERR_USER_NOT_FOUND                   = 3006,
        CMDERR_BAN_NOT_FOUND                    = 3007,
        CMDERR_FILETRANSFER_NOT_FOUND           = 3008,
        CMDERR_OPENFILE_FAILED                  = 3009,
        CMDERR_ACCOUNT_NOT_FOUND                = 3010,
        CMDERR_FILE_NOT_FOUND                   = 3011,
        CMDERR_FILE_ALREADY_EXISTS              = 3012,
        CMDERR_FILESHARING_DISABLED             = 3013,
 
        CMDERR_CHANNEL_HAS_USERS                = 3015,
 
        CMDERR_LOGINSERVICE_UNAVAILABLE         = 3016,
 
        CMDERR_CHANNEL_CANNOT_BE_HIDDEN         = 3017,
            
        /* ERRORS 10000-10999 ARE NOT COMMAND ERRORS BUT INSTEAD
         * ERRORS IN THE CLIENT INSTANCE. */
 
        INTERR_SNDINPUT_FAILURE = 10000,
        INTERR_SNDOUTPUT_FAILURE                = 10001,
        INTERR_AUDIOCODEC_INIT_FAILED           = 10002,
        INTERR_SPEEXDSP_INIT_FAILED = 10003,
        INTERR_AUDIOPREPROCESSOR_INIT_FAILED = 10003,
        INTERR_TTMESSAGE_QUEUE_OVERFLOW         = 10004,
        INTERR_SNDEFFECT_FAILURE = 10005,
    }
 
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct ClientErrorMsg
    {
        public int nErrorNo;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szErrorMsg;
    }
 
    public enum ClientEvent : uint
    {
        CLIENTEVENT_NONE = 0,
        CLIENTEVENT_CON_SUCCESS = CLIENTEVENT_NONE + 10,
        CLIENTEVENT_CON_FAILED = CLIENTEVENT_NONE + 20,
        CLIENTEVENT_CON_LOST = CLIENTEVENT_NONE + 30,
        CLIENTEVENT_CON_MAX_PAYLOAD_UPDATED = CLIENTEVENT_NONE + 40,
        CLIENTEVENT_CMD_PROCESSING = CLIENTEVENT_NONE + 200,
        CLIENTEVENT_CMD_ERROR = CLIENTEVENT_NONE + 210,
        CLIENTEVENT_CMD_SUCCESS = CLIENTEVENT_NONE + 220,
        CLIENTEVENT_CMD_MYSELF_LOGGEDIN = CLIENTEVENT_NONE + 230,
        CLIENTEVENT_CMD_MYSELF_LOGGEDOUT = CLIENTEVENT_NONE + 240,
        CLIENTEVENT_CMD_MYSELF_KICKED = CLIENTEVENT_NONE + 250,
        CLIENTEVENT_CMD_USER_LOGGEDIN = CLIENTEVENT_NONE + 260,
        CLIENTEVENT_CMD_USER_LOGGEDOUT = CLIENTEVENT_NONE + 270,
        CLIENTEVENT_CMD_USER_UPDATE = CLIENTEVENT_NONE + 280,
        CLIENTEVENT_CMD_USER_JOINED = CLIENTEVENT_NONE + 290,
        CLIENTEVENT_CMD_USER_LEFT = CLIENTEVENT_NONE + 300,
        CLIENTEVENT_CMD_USER_TEXTMSG = CLIENTEVENT_NONE + 310,
        CLIENTEVENT_CMD_CHANNEL_NEW = CLIENTEVENT_NONE + 320,
        CLIENTEVENT_CMD_CHANNEL_UPDATE = CLIENTEVENT_NONE + 330,
        CLIENTEVENT_CMD_CHANNEL_REMOVE = CLIENTEVENT_NONE + 340,
        CLIENTEVENT_CMD_SERVER_UPDATE = CLIENTEVENT_NONE + 350,
        CLIENTEVENT_CMD_SERVERSTATISTICS = CLIENTEVENT_NONE + 360,
        CLIENTEVENT_CMD_FILE_NEW = CLIENTEVENT_NONE + 370,
        CLIENTEVENT_CMD_FILE_REMOVE = CLIENTEVENT_NONE + 380,
        CLIENTEVENT_CMD_USERACCOUNT = CLIENTEVENT_NONE + 390,
        CLIENTEVENT_CMD_BANNEDUSER = CLIENTEVENT_NONE + 400,
        CLIENTEVENT_USER_STATECHANGE = CLIENTEVENT_NONE + 500,
        CLIENTEVENT_USER_VIDEOCAPTURE = CLIENTEVENT_NONE + 510,
        CLIENTEVENT_USER_MEDIAFILE_VIDEO = CLIENTEVENT_NONE + 520,
        CLIENTEVENT_USER_DESKTOPWINDOW = CLIENTEVENT_NONE + 530,
        CLIENTEVENT_USER_DESKTOPCURSOR = CLIENTEVENT_NONE + 540,
        CLIENTEVENT_USER_DESKTOPINPUT = CLIENTEVENT_NONE + 550,
        CLIENTEVENT_USER_RECORD_MEDIAFILE = CLIENTEVENT_NONE + 560,
        CLIENTEVENT_USER_AUDIOBLOCK = CLIENTEVENT_NONE + 570,
        CLIENTEVENT_INTERNAL_ERROR = CLIENTEVENT_NONE + 1000,
        CLIENTEVENT_VOICE_ACTIVATION = CLIENTEVENT_NONE + 1010,
        CLIENTEVENT_HOTKEY = CLIENTEVENT_NONE + 1020,
        CLIENTEVENT_HOTKEY_TEST = CLIENTEVENT_NONE + 1030,
        CLIENTEVENT_FILETRANSFER = CLIENTEVENT_NONE + 1040,
        CLIENTEVENT_DESKTOPWINDOW_TRANSFER = CLIENTEVENT_NONE + 1050,
        CLIENTEVENT_STREAM_MEDIAFILE = CLIENTEVENT_NONE + 1060,
        CLIENTEVENT_LOCAL_MEDIAFILE = CLIENTEVENT_NONE + 1070,
        CLIENTEVENT_AUDIOINPUT = CLIENTEVENT_NONE + 1080,
        CLIENTEVENT_USER_FIRSTVOICESTREAMPACKET = CLIENTEVENT_NONE + 1090,
    }
 
 
    /* List of structures used internally by TeamTalkBase. */
    public enum TTType : uint
    {
        __NONE                    =  0,
        __AUDIOCODEC              =  1,
        __BANNEDUSER              =  2,
        __VIDEOFORMAT             =  3,
        __OPUSCODEC               =  4,
        __CHANNEL                 =  5,
        __CLIENTSTATISTICS        =  6,
        __REMOTEFILE              =  7,
        __FILETRANSFER            =  8,
        __MEDIAFILESTATUS         =  9,
        __SERVERPROPERTIES        = 10,
        __SERVERSTATISTICS        = 11,
        __SOUNDDEVICE             = 12,
        __SPEEXCODEC              = 13,
        __TEXTMESSAGE             = 14,
        __WEBMVP8CODEC            = 15,
        __TTMESSAGE               = 16,
        __USER                    = 17,
        __USERACCOUNT             = 18,
        __USERSTATISTICS          = 19,
        __VIDEOCAPTUREDEVICE      = 20,
        __VIDEOCODEC              = 21,
        __AUDIOCONFIG             = 22,
        __SPEEXVBRCODEC           = 23,
        __VIDEOFRAME              = 24,
        __AUDIOBLOCK              = 25,
        __AUDIOFORMAT             = 26,
        __MEDIAFILEINFO           = 27,
        __CLIENTERRORMSG          = 28,
        __TTBOOL                  = 29,
        __INT32                   = 30,
        __DESKTOPINPUT            = 31,
        __SPEEXDSP                = 32,
        __STREAMTYPE              = 33,
        __AUDIOPREPROCESSORTYPE   = 34,
        __AUDIOPREPROCESSOR       = 35,
        __TTAUDIOPREPROCESSOR     = 36,
        __MEDIAFILEPLAYBACK       = 37,
        __CLIENTKEEPALIVE         = 38,
        __UINT32                  = 39,
        __AUDIOINPUTPROGRESS      = 40,
        __JITTERCONFIG            = 41,
        __WEBRTCAUDIOPREPROCESSOR = 42,
        __ENCRYPTIONCONTEXT       = 43,
    }
 
    [StructLayout(LayoutKind.Sequential)]
    public struct TTMessage
    {
        public ClientEvent nClientEvent;
        public int nSource;
        public TTType ttType;
        public uint uReserved;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst = TTDLL.SIZEOF_TTMESSAGE_DATA)]
        public byte[] data;
        //UnionData data;
        
        public object DataToObject()
        {
            switch (ttType)
            {
                case TTType.__CHANNEL:
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(Channel));
                case TTType.__CLIENTERRORMSG:
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ClientErrorMsg));
                case TTType.__DESKTOPINPUT:
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(DesktopInput));
                case TTType.__FILETRANSFER:
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(FileTransfer));
                case TTType.__MEDIAFILEINFO:
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(MediaFileInfo));
                case TTType.__REMOTEFILE:
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(RemoteFile));
                case TTType.__SERVERPROPERTIES:
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ServerProperties));
                case TTType.__SERVERSTATISTICS:
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ServerStatistics));
                case TTType.__TEXTMESSAGE:
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(TextMessage));
                case TTType.__USER:
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(User));
                case TTType.__USERACCOUNT:
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(UserAccount));
                case TTType.__BANNEDUSER :
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(BannedUser));
                case TTType.__TTBOOL:
                    return Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this)) != 0;
                case TTType.__INT32:
                    return Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this));
                case TTType.__STREAMTYPE :
                    return (StreamType)Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this));
                case TTType.__AUDIOINPUTPROGRESS :
                    return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(AudioInputProgress));
                default:
                    return null;
            }
        }
    }
 
    [StructLayout(LayoutKind.Explicit, Size = 5224)]
    struct UnionData
    {
        [FieldOffset(0)]
        public ClientErrorMsg clienterrormsg;
        [FieldOffset(0)]
        public Channel channel;
        [FieldOffset(0)]
        public DesktopInput desktopinput;
        [FieldOffset(0)]
        public FileTransfer filetransfer;
        [FieldOffset(0)]
        public MediaFileInfo mediafileinfo;
        [FieldOffset(0)]
        public RemoteFile remotefile;
        [FieldOffset(0)]
        public ServerProperties serverproperties;
        [FieldOffset(0)]
        public TextMessage textmessage;
        [FieldOffset(0)]
        public User user;
        [FieldOffset(0)]
        public UserAccount useraccount;
        [FieldOffset(0)]
        public bool bActive;
        [FieldOffset(0)]
        public int nBytesRemain;
        [FieldOffset(0)]
        public int nStreamID;
        [FieldOffset(0)]
        public int nPayloadSize;
    }
 
    [Flags]
    public enum ClientFlag : uint
    {
        CLIENT_CLOSED = 0x00000000,
        CLIENT_SNDINPUT_READY = 0x00000001,
        CLIENT_SNDOUTPUT_READY = 0x00000002,
        CLIENT_SNDINOUTPUT_DUPLEX = 0x00000004,
        CLIENT_SNDINPUT_VOICEACTIVATED = 0x00000008,
        CLIENT_SNDINPUT_VOICEACTIVE = 0x00000010,
        CLIENT_SNDOUTPUT_MUTE = 0x00000020,
        CLIENT_SNDOUTPUT_AUTO3DPOSITION = 0x00000040,
        CLIENT_VIDEOCAPTURE_READY = 0x00000080,
        CLIENT_TX_VOICE = 0x00000100,
        CLIENT_TX_VIDEOCAPTURE = 0x00000200,
        CLIENT_TX_DESKTOP = 0x00000400,
        CLIENT_DESKTOP_ACTIVE = 0x00000800,
        CLIENT_MUX_AUDIOFILE = 0x00001000,
        CLIENT_CONNECTING = 0x00002000,
        CLIENT_CONNECTED = 0x00004000,
        CLIENT_CONNECTION = CLIENT_CONNECTING | CLIENT_CONNECTED,
        CLIENT_AUTHORIZED = 0x00008000,
        CLIENT_STREAM_AUDIO = 0x00010000,
        CLIENT_STREAM_VIDEO = 0x00020000
    }
 
    public abstract class TeamTalkBase : IDisposable
    {
        public const int TT_STRLEN = 512;
 
        public const int TT_USERID_MAX = 0xFFF;
 
        public const int TT_CHANNELID_MAX = 0xFFF;
 
        public const int TT_VIDEOFORMATS_MAX = 1024;
 
        public const int TT_TRANSMITUSERS_MAX = 128;
 
        public const int TT_CLASSROOM_FREEFORALL = 0xFFF;
 
        public const int TT_CLASSROOM_USERID_INDEX = 0;
 
        public const int TT_CLASSROOM_STREAMTYPE_INDEX = 1;
 
        public const int TT_TRANSMITUSERS_FREEFORALL = 0xFFF;
 
        public const int TT_TRANSMITUSERS_USERID_INDEX = 0;
 
        public const int TT_TRANSMITUSERS_STREAMTYPE_INDEX = 1;
 
        public const int TT_LOCAL_USERID = 0;
 
        public const int TT_LOCAL_TX_USERID = 0x1002;
 
        public const int TT_MUXED_USERID = 0x1001; /* TT_USERID_MAX + 2 */
    
        public const int TT_CHANNELS_OPERATOR_MAX = 16;
 
        public const int TT_TRANSMITQUEUE_MAX = 16;
 
        public const int TT_SAMPLERATES_MAX = 16;
 
        public const int TT_DESKTOPINPUT_MAX = 16;
 
        public const uint TT_MEDIAPLAYBACK_OFFSET_IGNORE = 0xFFFFFFFF;
 
 
        public static string GetVersion() { return Marshal.PtrToStringAuto(TTDLL.TT_GetVersion()); }
 
        protected TeamTalkBase(bool poll_based)
        {
            Assembly assembly = Assembly.GetExecutingAssembly();
            AssemblyName name = assembly.GetName();
            Version dllversion = new Version(Marshal.PtrToStringUni((c_tt.TTDLL.TT_GetVersion())));
            if (!name.Version.Equals(dllversion))
            {
                string errmsg = String.Format("Invalid {2} version loaded. {2} is version {0} and {3} is version {1}",
                    dllversion.ToString(), name.Version.ToString(), c_tt.TTDLL.dllname, c_tt.TTDLL.mgtdllname);
 
                // throw new Exception(errmsg);
 
                System.Diagnostics.Debug.WriteLine(errmsg);
            }
 
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOCODEC) == Marshal.SizeOf(new AudioCodec()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__BANNEDUSER) == Marshal.SizeOf(new BannedUser()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOFORMAT) == Marshal.SizeOf(new VideoFormat()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__OPUSCODEC) == Marshal.SizeOf(new OpusCodec()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CHANNEL) == Marshal.SizeOf(new Channel()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTSTATISTICS) == Marshal.SizeOf(new ClientStatistics()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__REMOTEFILE) == Marshal.SizeOf(new RemoteFile()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__FILETRANSFER) == Marshal.SizeOf(new FileTransfer()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILESTATUS) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(MediaFileStatus))));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SERVERPROPERTIES) == Marshal.SizeOf(new ServerProperties()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SERVERSTATISTICS) == Marshal.SizeOf(new ServerStatistics()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SOUNDDEVICE) == Marshal.SizeOf(new SoundDevice()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXCODEC) == Marshal.SizeOf(new SpeexCodec()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TEXTMESSAGE) == Marshal.SizeOf(new TextMessage()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__WEBMVP8CODEC) == Marshal.SizeOf(new WebMVP8Codec()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TTMESSAGE) == Marshal.SizeOf(new TTMessage()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USER) == Marshal.SizeOf(new User()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USERACCOUNT) == Marshal.SizeOf(new UserAccount()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USERSTATISTICS) == Marshal.SizeOf(new UserStatistics()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOCAPTUREDEVICE) == Marshal.SizeOf(new VideoCaptureDevice()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOCODEC) == Marshal.SizeOf(new VideoCodec()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOCONFIG) == Marshal.SizeOf(new AudioConfig()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXVBRCODEC) == Marshal.SizeOf(new SpeexVBRCodec()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOFRAME) == Marshal.SizeOf(new VideoFrame()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOBLOCK) == Marshal.SizeOf(new AudioBlock()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOFORMAT) == Marshal.SizeOf(new AudioFormat()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILEINFO) == Marshal.SizeOf(new MediaFileInfo()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTERRORMSG) == Marshal.SizeOf(new ClientErrorMsg()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__DESKTOPINPUT) == Marshal.SizeOf(new DesktopInput()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXDSP) == Marshal.SizeOf(new SpeexDSP()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__STREAMTYPE) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(StreamType))));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOPREPROCESSORTYPE) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(AudioPreprocessorType))));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__WEBRTCAUDIOPREPROCESSOR) == Marshal.SizeOf(new WebRTCAudioPreprocessor()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TTAUDIOPREPROCESSOR) == Marshal.SizeOf(new TTAudioPreprocessor()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOPREPROCESSOR) == Marshal.SizeOf(new AudioPreprocessor()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILEPLAYBACK) == Marshal.SizeOf(new MediaFilePlayback()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTKEEPALIVE) == Marshal.SizeOf(new ClientKeepAlive()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOINPUTPROGRESS) == Marshal.SizeOf(new AudioInputProgress()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__JITTERCONFIG) == Marshal.SizeOf(new JitterConfig()));
            Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__ENCRYPTIONCONTEXT) == Marshal.SizeOf(new EncryptionContext()));
 
            if (poll_based)
                m_ttInst = TTDLL.TT_InitTeamTalkPoll();
            else
            {
                m_eventhandler = new MyEventHandler(this);
#if PocketPC
                IntPtr hWnd = m_eventhandler.Hwnd;
#else
                m_eventhandler.CreateControl();
                IntPtr hWnd = m_eventhandler.Handle;
#endif
                m_ttInst = TTDLL.TT_InitTeamTalk(hWnd, MyEventHandler.WM_TEAMTALK_CLIENTEVENT);
            }
        }
 
        ~TeamTalkBase()
        {
            DeleteMe();
        }
 
 
        #region IDisposable Members
 
        public void Dispose()
        {
            DeleteMe();
        }
 
        private void DeleteMe()
        {
            if (m_ttInst != IntPtr.Zero)
            {
                TTDLL.TT_CloseTeamTalk(m_ttInst);
                m_ttInst = IntPtr.Zero;
            }
        }
 
        #endregion
 
        public bool GetMessage(ref TTMessage pMsg, int nWaitMs)
        {
            return TTDLL.TT_GetMessage(m_ttInst, ref pMsg, ref nWaitMs);
        }
 
        public bool PumpMessage(ClientEvent nClientEvent,
                                int nIdentifier)
        {
            return TTDLL.TT_PumpMessage(m_ttInst, nClientEvent, nIdentifier);
        }
 
        public BearWare.ClientFlag GetFlags()
        {
            return TTDLL.TT_GetFlags(m_ttInst);
        }
 
        public ClientFlag Flags
        {
            get { return GetFlags(); }
        }
 
        public static bool SetLicenseInformation(string szRegName, string szRegKey)
        {
            return TTDLL.TT_SetLicenseInformation(szRegName, szRegKey);
        }
 
        public void ProcessMsg(TTMessage msg)
        {
            switch (msg.nClientEvent)
            {
                case ClientEvent.CLIENTEVENT_CON_SUCCESS:
                    if(OnConnectionSuccess != null)
                        OnConnectionSuccess();
                    break;
                case ClientEvent.CLIENTEVENT_CON_FAILED:
                    if (OnConnectionFailed != null)
                    OnConnectionFailed();
                    break;
                case ClientEvent.CLIENTEVENT_CON_LOST:
                    if (OnConnectionLost != null)
                        OnConnectionLost();
                    break;
                case ClientEvent.CLIENTEVENT_CON_MAX_PAYLOAD_UPDATED :
                    if (OnConnectionMaxPayloadUpdated != null)
                        OnConnectionMaxPayloadUpdated((int)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_PROCESSING:
                    if (OnCmdProcessing != null)
                        OnCmdProcessing(msg.nSource, (bool)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_ERROR:
                    if (OnCmdError != null)
                        OnCmdError((int)msg.nSource, (ClientErrorMsg)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_SUCCESS :
                    if (OnCmdSuccess != null)
                        OnCmdSuccess((int)msg.nSource);
                    break;
                case ClientEvent.CLIENTEVENT_CMD_MYSELF_LOGGEDIN:
                    if (OnCmdMyselfLoggedIn != null)
                        OnCmdMyselfLoggedIn((int)msg.nSource, (UserAccount)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_MYSELF_LOGGEDOUT:
                    if (OnCmdMyselfLoggedOut != null)
                        OnCmdMyselfLoggedOut();
                    break;
                case ClientEvent.CLIENTEVENT_CMD_MYSELF_KICKED:
                    if (msg.ttType == TTType.__USER)
                    {
                        if (OnCmdMyselfKicked != null)
                            OnCmdMyselfKicked((User)msg.DataToObject());
                    }
                    else if (OnCmdMyselfKicked != null)
                        OnCmdMyselfKicked(new User());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_USER_LOGGEDIN:
                    if (OnCmdUserLoggedIn != null)
                        OnCmdUserLoggedIn((User)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_USER_LOGGEDOUT:
                    if (OnCmdUserLoggedOut != null)
                        OnCmdUserLoggedOut((User)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_USER_UPDATE:
                    if (OnCmdUserUpdate != null)
                        OnCmdUserUpdate((User)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_USER_JOINED:
                    if (OnCmdUserJoinedChannel != null)
                        OnCmdUserJoinedChannel((User)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_USER_LEFT:
                    if (OnCmdUserLeftChannel != null)
                        OnCmdUserLeftChannel((User)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_USER_TEXTMSG:
                    if (OnCmdUserTextMessage != null)
                        OnCmdUserTextMessage((TextMessage)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_CHANNEL_NEW:
                    if (OnCmdChannelNew != null)
                        OnCmdChannelNew((Channel)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_CHANNEL_UPDATE:
                    if (OnCmdChannelUpdate != null)
                        OnCmdChannelUpdate((Channel)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_CHANNEL_REMOVE:
                    if (OnCmdChannelRemove != null)
                        OnCmdChannelRemove((Channel)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_SERVER_UPDATE:
                    if (OnCmdServerUpdate != null)
                        OnCmdServerUpdate((ServerProperties)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_SERVERSTATISTICS :
                    if (OnCmdServerStatistics != null)
                        OnCmdServerStatistics((ServerStatistics)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_FILE_NEW:
                    if (OnCmdFileNew != null)
                        OnCmdFileNew((RemoteFile)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_FILE_REMOVE:
                    if (OnCmdFileRemove != null)
                        OnCmdFileRemove((RemoteFile)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_USERACCOUNT :
                    if (OnCmdUserAccount != null)
                        OnCmdUserAccount((UserAccount)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_CMD_BANNEDUSER :
                    if (OnCmdBannedUser != null)
                        OnCmdBannedUser((BannedUser)msg.DataToObject());
                    break;
                
                case ClientEvent.CLIENTEVENT_USER_STATECHANGE :
                    if (OnUserStateChange != null)
                        OnUserStateChange((User)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_USER_VIDEOCAPTURE:
                    if (OnUserVideoCapture != null)
                        OnUserVideoCapture(msg.nSource, (int)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_USER_MEDIAFILE_VIDEO:
                    if (OnUserMediaFileVideo != null)
                        OnUserMediaFileVideo((int)msg.nSource, (int)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_USER_DESKTOPWINDOW:
                    if (OnUserDesktopWindow != null)
                        OnUserDesktopWindow((int)msg.nSource, (int)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_USER_DESKTOPCURSOR:
                    if (OnUserDesktopCursor != null)
                        OnUserDesktopCursor((int)msg.nSource, (DesktopInput)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_USER_DESKTOPINPUT :
                    if (OnUserDesktopInput != null)
                        OnUserDesktopInput((int)msg.nSource, (DesktopInput)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_USER_RECORD_MEDIAFILE :
                    if(OnUserRecordMediaFile != null)
                        OnUserRecordMediaFile((int)msg.nSource, (MediaFileInfo)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_USER_AUDIOBLOCK :
                    if(OnUserAudioBlock != null)
                        OnUserAudioBlock((int)msg.nSource, (StreamType)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_INTERNAL_ERROR :
                    if(OnInternalError!= null)
                        OnInternalError((ClientErrorMsg)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_VOICE_ACTIVATION :
                    if(OnVoiceActivation != null)
                        OnVoiceActivation((bool)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_HOTKEY :
                    if(OnHotKeyToggle != null)
                        OnHotKeyToggle(msg.nSource, (bool)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_HOTKEY_TEST :
                    if(OnHotKeyTest != null)
                        OnHotKeyTest(msg.nSource, (bool)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_FILETRANSFER :
                    if(OnFileTransfer != null)
                        OnFileTransfer((FileTransfer)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_DESKTOPWINDOW_TRANSFER :
                    if(OnDesktopWindowTransfer != null)
                        OnDesktopWindowTransfer(msg.nSource, (int)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_STREAM_MEDIAFILE :
                    if(OnStreamMediaFile != null)
                        OnStreamMediaFile((MediaFileInfo)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_LOCAL_MEDIAFILE:
                    if (OnLocalMediaFile != null)
                        OnLocalMediaFile((MediaFileInfo)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_AUDIOINPUT:
                    if (OnAudioInput != null)
                        OnAudioInput((AudioInputProgress)msg.DataToObject());
                    break;
                case ClientEvent.CLIENTEVENT_USER_FIRSTVOICESTREAMPACKET:
                    if (OnUserFirstVoiceStreamPacket != null)
                        OnUserFirstVoiceStreamPacket((User)msg.DataToObject(), msg.nSource);
                    break;
            }
        }
 
        public static bool GetDefaultSoundDevices(ref int lpnInputDeviceID,
                                                  ref int lpnOutputDeviceID)
        {
            return TTDLL.TT_GetDefaultSoundDevices(ref lpnInputDeviceID, ref lpnOutputDeviceID);
        }
        public static bool GetDefaultSoundDevicesEx(SoundSystem nSndSystem,
                                                    ref int lpnInputDeviceID,
                                                    ref int lpnOutputDeviceID)
        {
            return TTDLL.TT_GetDefaultSoundDevicesEx(nSndSystem, ref lpnInputDeviceID, ref lpnOutputDeviceID);
        }
        public static bool GetSoundDevices(out SoundDevice[] lpSoundDevices)
        {
            int count = 0;
            bool b = TTDLL.TT_GetSoundDevices_NULL(IntPtr.Zero, ref count);
            SoundDevice[] devs = new SoundDevice[count];
            b = TTDLL.TT_GetSoundDevices(devs, ref count);
            lpSoundDevices = b ? devs : null;
            return b;
        }
        public static bool RestartSoundSystem()
        {
            return TTDLL.TT_RestartSoundSystem();
        }
        public static IntPtr StartSoundLoopbackTest(int nInputDeviceID, int nOutputDeviceID,
                                                    int nSampleRate, int nChannels,
                                                    bool bDuplexMode, SpeexDSP lpSpeexDSP)
        {
            return TTDLL.TT_StartSoundLoopbackTest(nInputDeviceID, nOutputDeviceID,
                                                 nSampleRate, nChannels, bDuplexMode,
                                                 ref lpSpeexDSP);
        }
        public static IntPtr StartSoundLoopbackTest(int nInputDeviceID, int nOutputDeviceID,
                                                    int nSampleRate, int nChannels,
                                                    bool bDuplexMode, AudioPreprocessor lpAudioPreprocessor,
                                                    BearWare.SoundDeviceEffects lpSoundDeviceEffects)
        {
            return TTDLL.TT_StartSoundLoopbackTestEx(nInputDeviceID, nOutputDeviceID,
                                                    nSampleRate, nChannels, bDuplexMode,
                                                    ref lpAudioPreprocessor, ref lpSoundDeviceEffects);
        }
        public static bool CloseSoundLoopbackTest(IntPtr lpTTSoundLoop)
        {
            return TTDLL.TT_CloseSoundLoopbackTest(lpTTSoundLoop);
        }
        public bool InitSoundInputDevice(int nInputDeviceID)
        {
            return TTDLL.TT_InitSoundInputDevice(m_ttInst, nInputDeviceID);
        }
 
        public bool InitSoundInputSharedDevice(int nSampleRate,int nChannels, int nFrameSize)
        {
            return TTDLL.TT_InitSoundInputSharedDevice(nSampleRate, nChannels, nFrameSize);
        }
 
        public bool InitSoundOutputDevice(int nOutputDeviceID)
        {
            return TTDLL.TT_InitSoundOutputDevice(m_ttInst, nOutputDeviceID);
        }
        public bool InitSoundOutputSharedDevice(int nSampleRate, int nChannels,int nFrameSize)
        {
            return TTDLL.TT_InitSoundOutputSharedDevice(nSampleRate, nChannels, nFrameSize);
        }
        public bool InitSoundDuplexDevices(int nInputDeviceID, int nOutputDeviceID)
        {
            return TTDLL.TT_InitSoundDuplexDevices(m_ttInst, nInputDeviceID, nOutputDeviceID);
        }
        public bool CloseSoundInputDevice()
        {
            return TTDLL.TT_CloseSoundInputDevice(m_ttInst);
        }
        public bool CloseSoundOutputDevice()
        {
            return TTDLL.TT_CloseSoundOutputDevice(m_ttInst);
        }
        public bool CloseSoundDuplexDevices()
        {
            return TTDLL.TT_CloseSoundDuplexDevices(m_ttInst);
        }
        public bool SetSoundDeviceEffects(SoundDeviceEffects lpSoundDeviceEffect)
        {
            return TTDLL.TT_SetSoundDeviceEffects(m_ttInst, ref lpSoundDeviceEffect);
        }
        public bool GetSoundDeviceEffects(ref SoundDeviceEffects lpSoundDeviceEffect)
        {
            return TTDLL.TT_GetSoundDeviceEffects(m_ttInst, ref lpSoundDeviceEffect);
        }
        public int GetSoundInputLevel()
        {
            return TTDLL.TT_GetSoundInputLevel(m_ttInst);
        }
        public bool SetSoundInputGainLevel(int nLevel)
        {
            return TTDLL.TT_SetSoundInputGainLevel(m_ttInst, nLevel);
        }
        public int GetSoundInputGainLevel()
        {
            return TTDLL.TT_GetSoundInputGainLevel(m_ttInst);
        }
 
        public bool SetSoundInputPreprocess(SpeexDSP lpSpeexDSP)
        {
            return TTDLL.TT_SetSoundInputPreprocess(m_ttInst, ref lpSpeexDSP);
        }
 
        public bool GetSoundInputPreprocess(ref SpeexDSP lpSpeexDSP)
        {
            return TTDLL.TT_GetSoundInputPreprocess(m_ttInst, ref lpSpeexDSP);
        }
        public bool SetSoundInputPreprocess(AudioPreprocessor lpAudioPreprocessor)
        {
            return TTDLL.TT_SetSoundInputPreprocessEx(m_ttInst, ref lpAudioPreprocessor);
        }
 
        public bool GetSoundInputPreprocess(ref AudioPreprocessor lpAudioPreprocessor)
        {
            return TTDLL.TT_GetSoundInputPreprocessEx(m_ttInst, ref lpAudioPreprocessor);
        }
        public bool SetSoundOutputVolume(int nVolume)
        {
            return TTDLL.TT_SetSoundOutputVolume(m_ttInst, nVolume);
        }
        public int GetSoundOutputVolume()
        {
            return TTDLL.TT_GetSoundOutputVolume(m_ttInst);
        }
        public bool SetSoundOutputMute(bool bMuteAll)
        {
            return TTDLL.TT_SetSoundOutputMute(m_ttInst, bMuteAll);
        }
        public bool Enable3DSoundPositioning(bool bEnable)
        {
            return TTDLL.TT_Enable3DSoundPositioning(m_ttInst, bEnable);
        }
        public bool AutoPositionUsers()
        {
            return TTDLL.TT_AutoPositionUsers(m_ttInst);
        }
 
        public bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes,
                                          bool bEnable)
        {
            return TTDLL.TT_EnableAudioBlockEvent(m_ttInst, nUserID, uStreamTypes, bEnable);
        }
        public bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes,
                                          AudioFormat lpAudioFormat, bool bEnable)
        {
            return TTDLL.TT_EnableAudioBlockEventEx(m_ttInst, nUserID, uStreamTypes, ref lpAudioFormat, bEnable);
        }
        public bool InsertAudioBlock(AudioBlock lpAudioBlock)
        {
            return TTDLL.TT_InsertAudioBlock(m_ttInst, ref lpAudioBlock);
        }
 
        public bool EnableVoiceTransmission(bool bEnable)
        {
            return TTDLL.TT_EnableVoiceTransmission(m_ttInst, bEnable);
        }
 
        public bool EnableVoiceActivation(bool bEnable)
        {
            return TTDLL.TT_EnableVoiceActivation(m_ttInst, bEnable);
        }
        public bool SetVoiceActivationLevel(int nLevel)
        {
            return TTDLL.TT_SetVoiceActivationLevel(m_ttInst, nLevel);
        }
        public int GetVoiceActivationLevel()
        {
            return TTDLL.TT_GetVoiceActivationLevel(m_ttInst);
        }
        public bool SetVoiceActivationStopDelay(int nDelayMSec)
        {
            return TTDLL.TT_SetVoiceActivationStopDelay(m_ttInst, nDelayMSec);
        }
 
        public int GetVoiceActivationStopDelay()
        {
            return TTDLL.TT_GetVoiceActivationStopDelay(m_ttInst);
        }
 
        public bool StartRecordingMuxedAudioFile(AudioCodec lpAudioCodec,
                                                 string szAudioFileName,
                                                 AudioFileFormat uAFF)
        {
            return TTDLL.TT_StartRecordingMuxedAudioFile(m_ttInst,
                                                       ref lpAudioCodec,
                                                       szAudioFileName,
                                                       uAFF);
        }
 
        public bool StartRecordingMuxedAudioFile(int nChannelID,
                                                 string szAudioFileName,
                                                 AudioFileFormat uAFF)
        {
            return TTDLL.TT_StartRecordingMuxedAudioFileEx(m_ttInst,
                                                           nChannelID,
                                                           szAudioFileName,
                                                           uAFF);
        }
 
 
        public bool StartRecordingMuxedStreams(StreamType uStreamTypes,
                                               AudioCodec lpAudioCodec,
                                               string szAudioFileName,
                                               AudioFileFormat uAFF)
        {
            return TTDLL.TT_StartRecordingMuxedStreams(m_ttInst, uStreamTypes, ref lpAudioCodec, szAudioFileName, uAFF);
        }
 
        public bool StopRecordingMuxedAudioFile()
        {
            return TTDLL.TT_StopRecordingMuxedAudioFile(m_ttInst);
        }
 
        public bool StopRecordingMuxedAudioFile(int nChannelID)
        {
            return TTDLL.TT_StopRecordingMuxedAudioFileEx(m_ttInst, nChannelID);
        }
 
        public bool StartVideoCaptureTransmission(VideoCodec lpVideoCodec)
        {
            return TTDLL.TT_StartVideoCaptureTransmission(m_ttInst, ref lpVideoCodec);
        }
 
        public bool StopVideoCaptureTransmission()
        {
            return TTDLL.TT_StopVideoCaptureTransmission(m_ttInst);
        }
 
        public static bool GetVideoCaptureDevices(out VideoCaptureDevice[] lpVideoDevices)
        {
            //To speed up query we only query for a max of 25.
            //Hopefully no one has more than 25 capture devices. 
            VideoCaptureDevice[] devs = new VideoCaptureDevice[25];
            int count = devs.Length;
            bool b = TTDLL.TT_GetVideoCaptureDevices(devs, ref count);
            if (b)
            {
                lpVideoDevices = new VideoCaptureDevice[count];
                for (int i = 0; i < count; i++)
                    lpVideoDevices[i] = devs[i];
            }
            else lpVideoDevices = null;
 
            return b;
        }
        public bool InitVideoCaptureDevice(string szDeviceID,
                                           VideoFormat lpVideoFormat)
        {
            return TTDLL.TT_InitVideoCaptureDevice(m_ttInst, szDeviceID, ref lpVideoFormat);
        }
        public bool CloseVideoCaptureDevice()
        {
            return TTDLL.TT_CloseVideoCaptureDevice(m_ttInst);
        }
        public bool PaintVideoFrame(int nUserID,
                                    System.IntPtr hDC,
                                    int XDest,
                                    int YDest,
                                    int nDestWidth,
                                    int nDestHeight,
                                    ref VideoFrame lpVideoFrame)
        {
            return TTDLL.TT_PaintVideoFrame(nUserID, hDC, XDest, YDest, nDestWidth, 
                                          nDestHeight, ref lpVideoFrame);
        }
 
        public bool PaintVideoFrameEx(int nUserID,
                                      System.IntPtr hDC,
                                      int XDest,
                                      int YDest,
                                      int nDestWidth,
                                      int nDestHeight,
                                      int XSrc,
                                      int YSrc,
                                      int nSrcWidth,
                                      int nSrcHeight,
                                      ref VideoFrame lpVideoFrame)
        {
            return TTDLL.TT_PaintVideoFrameEx(nUserID, hDC, XDest, YDest, nDestWidth, nDestHeight, 
                                            XSrc, YSrc, nSrcWidth, nSrcHeight, 
                                            ref lpVideoFrame);
        }
 
        public VideoFrame AcquireUserVideoCaptureFrame(int nUserID, out Bitmap bmp)
        {
            bmp = null;
            IntPtr ptr = TTDLL.TT_AcquireUserVideoCaptureFrame(m_ttInst, nUserID);
            if(ptr == IntPtr.Zero)
                return new VideoFrame();
 
            VideoFrame frm = (VideoFrame)Marshal.PtrToStructure(ptr, typeof(VideoFrame));
            vidcapframes.Add(frm.frameBuffer, ptr);
 
            PixelFormat pixelformat = PixelFormat.Format32bppRgb;
            bmp = new Bitmap(frm.nWidth, frm.nHeight, frm.nWidth*4, pixelformat, frm.frameBuffer);
            return frm;
        }
 
        Dictionary<IntPtr, IntPtr> vidcapframes = new Dictionary<IntPtr, IntPtr>();
 
        public bool ReleaseUserVideoCaptureFrame(VideoFrame lpVideoFrame)
        {
            IntPtr ptr;
            if (vidcapframes.TryGetValue(lpVideoFrame.frameBuffer, out ptr))
            {
                vidcapframes.Remove(lpVideoFrame.frameBuffer);
                return TTDLL.TT_ReleaseUserVideoCaptureFrame(m_ttInst, ptr);
            }
            return false;
        }
 
        /*
        public bool GetUserVideoFrame(int nUserID,
                               ref System.Drawing.Bitmap lpPicture)
        {
            CaptureFormat cap;
            if (!TTDLL.TT_GetUserVideoFrame(m_ttInst, nUserID, IntPtr.Zero, 0, out cap))
                return false;
 
            PixelFormat pixelformat = PixelFormat.Format32bppRgb;
 
            if (lpPicture == null ||
               lpPicture.Width != cap.nWidth ||
               lpPicture.Height != cap.nHeight
#if PocketPC
                )
#else
               || lpPicture.PixelFormat != pixelformat)
#endif
            {
                lpPicture = new Bitmap(cap.nWidth, cap.nHeight,
                                       pixelformat);
            }
 
            // Lock the bitmap's bits.  
            System.Drawing.Rectangle rect = new System.Drawing.Rectangle(0, 0, lpPicture.Width, lpPicture.Height);
            BitmapData bmpData = lpPicture.LockBits(rect, ImageLockMode.ReadWrite, pixelformat);
 
            // Get the address of the first line.
            IntPtr ptr = bmpData.Scan0;
 
            bool b = TTDLL.TT_GetUserVideoFrame(m_ttInst, nUserID, ptr,
                                              cap.nWidth * cap.nHeight * 4, out cap);
            // Unlock the bits.
            lpPicture.UnlockBits(bmpData);
            return b;
        }
         * */
 
        public bool StartStreamingMediaFileToChannel(string szMediaFilePath,
                                                     VideoCodec lpVideoCodec)
        {
            return TTDLL.TT_StartStreamingMediaFileToChannel(m_ttInst, szMediaFilePath,
                                                           ref lpVideoCodec);
        }
 
        public bool StartStreamingMediaFileToChannel(string szMediaFilePath,
                                                     MediaFilePlayback lpMediaFilePlayback,
                                                     VideoCodec lpVideoCodec)
        {
            return TTDLL.TT_StartStreamingMediaFileToChannelEx(m_ttInst, szMediaFilePath,
                                                               ref lpMediaFilePlayback,
                                                               ref lpVideoCodec);
        }
 
        public bool UpdateStreamingMediaFileToChannel(MediaFilePlayback lpMediaFilePlayback,
                                                      VideoCodec lpVideoCodec)
        {
            return TTDLL.TT_UpdateStreamingMediaFileToChannel(m_ttInst, ref lpMediaFilePlayback, ref lpVideoCodec);
        }
 
        public bool StopStreamingMediaFileToChannel()
        {
            return TTDLL.TT_StopStreamingMediaFileToChannel(m_ttInst);
        }
 
        public int InitLocalPlayback(string szMediaFilePath, MediaFilePlayback lpMediaFilePlayback)
        {
            return TTDLL.TT_InitLocalPlayback(m_ttInst, szMediaFilePath, ref lpMediaFilePlayback);
        }
 
        public bool UpdateLocalPlayback(int nPlaybackSessionID,
                                        MediaFilePlayback lpMediaFilePlayback)
        {
            return TTDLL.TT_UpdateLocalPlayback(m_ttInst, nPlaybackSessionID, ref lpMediaFilePlayback);
        }
 
        public bool StopLocalPlayback(int nPlaybackSessionID)
        {
            return TTDLL.TT_StopLocalPlayback(m_ttInst, nPlaybackSessionID);
        }
 
        public static bool GetMediaFileInfo(string szMediaFilePath,
                                            ref MediaFileInfo lpMediaFileInfo)
        {
            return TTDLL.TT_GetMediaFileInfo(szMediaFilePath, ref lpMediaFileInfo);
        }
 
        public VideoFrame AcquireUserMediaVideoFrame(int nUserID, out Bitmap bmp)
        {
            bmp = null;
            IntPtr ptr = TTDLL.TT_AcquireUserMediaVideoFrame(m_ttInst, nUserID);
            if (ptr == IntPtr.Zero)
                return new VideoFrame();
 
            VideoFrame frm = (VideoFrame)Marshal.PtrToStructure(ptr, typeof(VideoFrame));
            mediaframes.Add(frm.frameBuffer, ptr);
 
            PixelFormat pixelformat = PixelFormat.Format32bppRgb;
            bmp = new Bitmap(frm.nWidth, frm.nHeight, frm.nWidth * 4, pixelformat, frm.frameBuffer);
            return frm;
        }
 
        public bool ReleaseUserMediaVideoFrame(VideoFrame lpVideoFrame)
        {
            IntPtr ptr;
            if (mediaframes.TryGetValue(lpVideoFrame.frameBuffer, out ptr))
            {
                mediaframes.Remove(lpVideoFrame.frameBuffer);
                return TTDLL.TT_ReleaseUserMediaVideoFrame(m_ttInst, ptr);
            }
            return false;
        }
 
        Dictionary<IntPtr, IntPtr> mediaframes = new Dictionary<IntPtr, IntPtr>();
 
        public int SendDesktopWindow(DesktopWindow lpDesktopWindow,
                                     BitmapFormat nConvertBmpFormat)
        {
            return TTDLL.TT_SendDesktopWindow(m_ttInst, ref lpDesktopWindow, nConvertBmpFormat);
        }
 
        public bool CloseDesktopWindow()
        {
            return TTDLL.TT_CloseDesktopWindow(m_ttInst);
        }
 
        public static System.Drawing.Color Palette_GetColorTable(BitmapFormat nBmpPalette,
                                                          int nIndex)
        {
            IntPtr ptr = TTDLL.TT_Palette_GetColorTable(nBmpPalette, nIndex);
            switch(nBmpPalette)
            {
                case BitmapFormat.BMP_RGB8_PALETTE:
                    return Color.FromArgb(Marshal.ReadInt32(ptr));
            }
            return new Color();
        }
 
        public int SendDesktopWindowFromHWND(System.IntPtr hWnd,
                                               BitmapFormat nBitmapFormat,
                                               DesktopProtocol nDesktopProtocol)
        {
            return TTDLL.TT_SendDesktopWindowFromHWND(m_ttInst, hWnd, nBitmapFormat, nDesktopProtocol);
        }
 
        public bool PaintDesktopWindow(int nUserID,
                                       System.IntPtr hDC,
                                       int XDest,
                                       int YDest,
                                       int nDestWidth,
                                       int nDestHeight)
        {
            return TTDLL.TT_PaintDesktopWindow(m_ttInst, nUserID, hDC, XDest, YDest, nDestWidth, nDestHeight);
        }
 
        public bool PaintDesktopWindowEx(int nUserID,
                                         System.IntPtr hDC,
                                         int XDest,
                                         int YDest,
                                         int nDestWidth,
                                         int nDestHeight,
                                         int XSrc,
                                         int YSrc,
                                         int nSrcWidth,
                                         int nSrcHeight)
        {
            return TTDLL.TT_PaintDesktopWindowEx(m_ttInst, nUserID, hDC, XDest, 
                                               YDest, nDestWidth, nDestHeight, 
                                               XSrc, YSrc, nSrcWidth, nSrcHeight);
        }
 
        public bool SendDesktopCursorPosition(ushort nPosX,
                                              ushort nPosY)
        {
            return TTDLL.TT_SendDesktopCursorPosition(m_ttInst, nPosX, nPosY);
        }
 
        public bool SendDesktopInput(int nUserID,
                                     DesktopInput[] lpDesktopInputs)
        {
            return TTDLL.TT_SendDesktopInput(m_ttInst, nUserID, lpDesktopInputs, lpDesktopInputs.Length);
        }
 
        public DesktopWindow AcquireUserDesktopWindow(int nUserID)
        {
            IntPtr ptr = TTDLL.TT_AcquireUserDesktopWindow(m_ttInst, nUserID);
            if (ptr == IntPtr.Zero)
                return new DesktopWindow();
            DesktopWindow lpDesktopWindow = (DesktopWindow)Marshal.PtrToStructure(ptr, typeof(DesktopWindow));
            desktopwindows.Add(lpDesktopWindow.frameBuffer, ptr);
            return lpDesktopWindow;
        }
 
        public DesktopWindow AcquireUserDesktopWindowEx(int nUserID, BitmapFormat nBitmapFormat)
        {
            IntPtr ptr = TTDLL.TT_AcquireUserDesktopWindowEx(m_ttInst, nUserID, nBitmapFormat);
            if (ptr == IntPtr.Zero)
                return new DesktopWindow();
            DesktopWindow lpDesktopWindow = (DesktopWindow)Marshal.PtrToStructure(ptr, typeof(DesktopWindow));
            desktopwindows.Add(lpDesktopWindow.frameBuffer, ptr);
            return lpDesktopWindow;
        }
 
        Dictionary<IntPtr, IntPtr> desktopwindows = new Dictionary<IntPtr, IntPtr>();
        public bool ReleaseUserDesktopWindow(DesktopWindow lpDesktopWindow)
        {
            IntPtr ptr;
            if (desktopwindows.TryGetValue(lpDesktopWindow.frameBuffer, out ptr))
            {
                desktopwindows.Remove(lpDesktopWindow.frameBuffer);
                return TTDLL.TT_ReleaseUserDesktopWindow(m_ttInst, ptr);
            }
            return false;
        }
 
        public bool SetEncryptionContext(EncryptionContext lpEncryptionContext)
        {
            return TTDLL.TT_SetEncryptionContext(m_ttInst, ref lpEncryptionContext);
        }
 
        public bool Connect(string szHostAddress,
                            int nTcpPort,
                            int nUdpPort,
                            int nLocalTcpPort,
                            int nLocalUdpPort,
                            bool bEncrypted)
        {
            return TTDLL.TT_Connect(m_ttInst, szHostAddress, nTcpPort, nUdpPort, 
                                    nLocalTcpPort, nLocalUdpPort, bEncrypted);
        }
 
        public bool ConnectSysID(string szHostAddress,
                                 int nTcpPort,
                                 int nUdpPort,
                                 int nLocalTcpPort,
                                 int nLocalUdpPort,
                                 bool bEncrypted,
                                 string szSystemID)
        {
            return TTDLL.TT_ConnectSysID(m_ttInst, szHostAddress, 
                                         nTcpPort, nUdpPort, nLocalTcpPort, 
                                         nLocalUdpPort, bEncrypted, szSystemID);
        }
 
        public bool ConnectEx(string szHostAddress,
                              int nTcpPort,
                              int nUdpPort,
                              string szBindIPAddr,
                              int nLocalTcpPort,
                              int nLocalUdpPort,
                              bool bEncrypted)
        {
            return TTDLL.TT_ConnectEx(m_ttInst, szHostAddress, nTcpPort, nUdpPort,
                                      szBindIPAddr, nLocalTcpPort, nLocalUdpPort,
                                      bEncrypted);
        }
 
        public bool Disconnect()
        {
            return TTDLL.TT_Disconnect(m_ttInst);
        }
        public bool QueryMaxPayload(int nUserID)
        {
            return TTDLL.TT_QueryMaxPayload(m_ttInst, nUserID);
        }
        public bool GetClientStatistics(ref ClientStatistics lpClientStatistics)
        {
            return TTDLL.TT_GetClientStatistics(m_ttInst, ref lpClientStatistics);
        }
 
        public bool SetClientKeepAlive(ClientKeepAlive lpClientKeepAlive)
        {
            return TTDLL.TT_SetClientKeepAlive(m_ttInst, ref lpClientKeepAlive);
        }
 
        public bool GetClientKeepAlive(ref ClientKeepAlive lpClientKeepAlive)
        {
            return TTDLL.TT_GetClientKeepAlive(m_ttInst, ref lpClientKeepAlive);
        }
        public int DoPing()
        {
            return TTDLL.TT_DoPing(m_ttInst);
        }
 
        public int DoLogin(string szNickname, string szUsername, string szPassword)
        {
            return TTDLL.TT_DoLogin(m_ttInst, szNickname, szUsername, szPassword);
        }
 
        public int DoLoginEx(string szNickname, string szUsername, string szPassword,
                             string szClientName)
        {
            return TTDLL.TT_DoLoginEx(m_ttInst, szNickname, szUsername, szPassword, szClientName);
        }
        public int DoLogout()
        {
            return TTDLL.TT_DoLogout(m_ttInst);
        }
        public int DoJoinChannel(Channel lpChannel)
        {
            return TTDLL.TT_DoJoinChannel(m_ttInst, ref lpChannel);
        }
        public int DoJoinChannelByID(int nChannelID, string szPassword)
        {
            return TTDLL.TT_DoJoinChannelByID(m_ttInst, nChannelID, szPassword);
        }
        public int DoLeaveChannel()
        {
            return TTDLL.TT_DoLeaveChannel(m_ttInst);
        }
        public int DoChangeNickname(string szNewNick)
        {
            return TTDLL.TT_DoChangeNickname(m_ttInst, szNewNick);
        }
        public int DoChangeStatus(int nStatusMode, string szStatusMessage)
        {
            return TTDLL.TT_DoChangeStatus(m_ttInst, nStatusMode, szStatusMessage);
        }
        public int DoTextMessage(TextMessage lpTextMessage)
        {
            return TTDLL.TT_DoTextMessage(m_ttInst, ref lpTextMessage);
        }
        public int DoChannelOp(int nUserID, int nChannelID, bool bMakeOperator)
        {
            return TTDLL.TT_DoChannelOp(m_ttInst, nUserID, nChannelID, bMakeOperator);
        }
        public int DoChannelOpEx(int nUserID,
                          int nChannelID,
                          string szOpPassword,
                          bool bMakeOperator)
        {
            return TTDLL.TT_DoChannelOpEx(m_ttInst, nUserID, nChannelID, szOpPassword, bMakeOperator);
        }
        public int DoKickUser(int nUserID, int nChannelID)
        {
            return TTDLL.TT_DoKickUser(m_ttInst, nUserID, nChannelID);
        }
        public int DoSendFile(int nChannelID, string szLocalFilePath)
        {
            return TTDLL.TT_DoSendFile(m_ttInst, nChannelID, szLocalFilePath);
        }
        public int DoRecvFile(int nChannelID, int nFileID, string szLocalFilePath)
        {
            return TTDLL.TT_DoRecvFile(m_ttInst, nChannelID, nFileID, szLocalFilePath);
        }
        public int DoDeleteFile(int nChannelID, int nFileID)
        {
            return TTDLL.TT_DoDeleteFile(m_ttInst, nChannelID, nFileID);
        }
        public int DoSubscribe(int nUserID, Subscription uSubscriptions)
        {
            return TTDLL.TT_DoSubscribe(m_ttInst, nUserID, uSubscriptions);
        }
        public int DoUnsubscribe(int nUserID, Subscription uSubscriptions)
        {
            return TTDLL.TT_DoUnsubscribe(m_ttInst, nUserID, uSubscriptions);
        }
        public int DoMakeChannel(Channel lpChannel)
        {
            return TTDLL.TT_DoMakeChannel(m_ttInst, ref lpChannel);
        }
        public int DoUpdateChannel(Channel lpChannel)
        {
            return TTDLL.TT_DoUpdateChannel(m_ttInst, ref lpChannel);
        }
        public int DoRemoveChannel(int nChannelID)
        {
            return TTDLL.TT_DoRemoveChannel(m_ttInst, nChannelID);
        }
        public int DoMoveUser(int nUserID, int nChannelID)
        {
            return TTDLL.TT_DoMoveUser(m_ttInst, nUserID, nChannelID);
        }
        public int DoUpdateServer(ServerProperties lpServerProperties)
        {
            return TTDLL.TT_DoUpdateServer(m_ttInst, ref lpServerProperties);
        }
        public int DoListUserAccounts(int nIndex, int nCount)
        {
            return TTDLL.TT_DoListUserAccounts(m_ttInst, nIndex, nCount);
        }
        public int DoNewUserAccount(UserAccount lpUserAccount)
        {
            return TTDLL.TT_DoNewUserAccount(m_ttInst, ref lpUserAccount);
        }
        public int DoDeleteUserAccount(string szUsername)
        {
            return TTDLL.TT_DoDeleteUserAccount(m_ttInst, szUsername);
        }
        public int DoBanUser(int nUserID, int nChannelID)
        {
            return TTDLL.TT_DoBanUser(m_ttInst, nUserID, nChannelID);
        }
 
        public int DoBanUserEx(int nUserID, BanType uBanTypes)
        {
            return TTDLL.TT_DoBanUserEx(m_ttInst, nUserID, uBanTypes);
        }
 
        public int DoBan(BannedUser lpBannedUser)
        {
            return TTDLL.TT_DoBan(m_ttInst, ref lpBannedUser);
        }
 
        public int DoBanIPAddress(string szIPAddress, int nChannelID)
        {
            return TTDLL.TT_DoBanIPAddress(m_ttInst, szIPAddress, nChannelID);
        }
 
        public int DoUnBanUser(string szIPAddress, int nChannelID)
        {
            return TTDLL.TT_DoUnBanUser(m_ttInst, szIPAddress, nChannelID);
        }
 
        public int DoUnBanUserEx(BannedUser lpBannedUser)
        {
            return TTDLL.TT_DoUnBanUserEx(m_ttInst, ref lpBannedUser);
        }
 
        public int DoListBans(int nChannelID, int nIndex, int nCount)
        {
            return TTDLL.TT_DoListBans(m_ttInst, nChannelID, nIndex, nCount);
        }
        public int DoSaveConfig()
        {
            return TTDLL.TT_DoSaveConfig(m_ttInst);
        }
        public int DoQueryServerStats()
        {
            return TTDLL.TT_DoQueryServerStats(m_ttInst);
        }
        public int DoQuit()
        {
            return TTDLL.TT_DoQuit(m_ttInst);
        }
        public bool GetServerProperties(ref ServerProperties lpServerProperties)
        {
            return TTDLL.TT_GetServerProperties(m_ttInst, ref lpServerProperties);
        }
        public bool GetServerUsers(out User[] lpUsers)
        {
            int count = 0;
            bool b = TTDLL.TT_GetServerUsers_NULL(m_ttInst, IntPtr.Zero, ref count);
            User[] users = new User[count];
            b = TTDLL.TT_GetServerUsers(m_ttInst, users, ref count);
            lpUsers = b ? users : null;
            return b;
        }
        public int GetRootChannelID()
        {
            return TTDLL.TT_GetRootChannelID(m_ttInst);
        }
        public int GetMyChannelID()
        {
            return TTDLL.TT_GetMyChannelID(m_ttInst);
        }
        public int ChannelID { get { return GetMyChannelID(); } }
        public bool GetChannel(int nChannelID, ref Channel lpChannel)
        {
            return TTDLL.TT_GetChannel(m_ttInst, nChannelID, ref lpChannel);
        }
        public bool GetChannelPath(int nChannelID, ref string szChannelPath)
        {
            IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
            bool b = TTDLL.TT_GetChannelPath(m_ttInst, nChannelID, ptr);
            if(b)
                szChannelPath = Marshal.PtrToStringUni(ptr);
            Marshal.FreeHGlobal(ptr);
            return b;
        }
        public int GetChannelIDFromPath(string szChannelPath)
        {
            return TTDLL.TT_GetChannelIDFromPath(m_ttInst, szChannelPath);
        }
        public bool GetChannelUsers(int nChannelID, out User[] lpUsers)
        {
            int count = 0;
            bool b = TTDLL.TT_GetChannelUsers_NULL(m_ttInst, nChannelID, IntPtr.Zero, ref count);
            User[] users = new User[count];
            b = TTDLL.TT_GetChannelUsers(m_ttInst, nChannelID, users, ref count);
            lpUsers = b ? users : null;
            return b;
        }
        public bool GetChannelFiles(int nChannelID, out RemoteFile[] lpRemoteFiles)
        {
            int count = 0;
            bool b = TTDLL.TT_GetChannelFiles_NULL(m_ttInst, nChannelID, IntPtr.Zero, ref count);
            RemoteFile[] files = new RemoteFile[count];
            b = TTDLL.TT_GetChannelFiles(m_ttInst, nChannelID, files, ref count);
            lpRemoteFiles = b ? files : null;
            return b;
        }
        public bool GetChannelFile(int nChannelID, int nFileID, ref RemoteFile lpRemoteFile)
        {
            return TTDLL.TT_GetChannelFile(m_ttInst, nChannelID, nFileID, ref lpRemoteFile);
        }
        public bool IsChannelOperator(int nUserID, int nChannelID)
        {
            return TTDLL.TT_IsChannelOperator(m_ttInst, nUserID, nChannelID);
        }
        public bool GetServerChannels(out Channel[] lpChannels)
        {
            int count = 0;
            bool b = TTDLL.TT_GetServerChannels_NULL(m_ttInst, IntPtr.Zero, ref count);
            Channel[] channels = new Channel[count];
            b = TTDLL.TT_GetServerChannels(m_ttInst, channels, ref count);
            lpChannels = b ? channels : null;
            return b;
        }
        public int GetMyUserID()
        {
            return TTDLL.TT_GetMyUserID(m_ttInst);
        }
 
        public bool GetMyUserAccount(ref UserAccount lpUserAccount)
        {
            return TTDLL.TT_GetMyUserAccount(m_ttInst, ref lpUserAccount);
        }
 
        public int UserID { get { return GetMyUserID(); } }
 
        public UserType GetMyUserType()
        {
            return TTDLL.TT_GetMyUserType(m_ttInst);
        }
 
        public BearWare.UserType UserType { get { return GetMyUserType(); } }
 
        public BearWare.UserRight UserRights { get { return GetMyUserRights(); } }
 
        public BearWare.UserRight GetMyUserRights()
        {
            return TTDLL.TT_GetMyUserRights(m_ttInst);
        }
 
        public int GetMyUserData()
        {
            return TTDLL.TT_GetMyUserData(m_ttInst);
        }
 
        public int UserData { get { return GetMyUserData(); } }
 
        public bool GetUser(int nUserID, ref User lpUser)
        {
            return TTDLL.TT_GetUser(m_ttInst, nUserID, ref lpUser);
        }
        public bool GetUserStatistics(int nUserID, ref UserStatistics lpUserStatistics)
        {
            return TTDLL.TT_GetUserStatistics(m_ttInst, nUserID, ref lpUserStatistics);
        }
        public bool GetUserByUsername(string szUsername, ref User lpUser)
        {
            return TTDLL.TT_GetUserByUsername(m_ttInst, szUsername, ref lpUser);
        }
        public bool SetUserVolume(int nUserID, StreamType nStreamType, int nVolume)
        {
            return TTDLL.TT_SetUserVolume(m_ttInst, nUserID, nStreamType, nVolume);
        }
        public bool SetUserMute(int nUserID, StreamType nStreamType, bool bMute)
        {
            return TTDLL.TT_SetUserMute(m_ttInst, nUserID, nStreamType, bMute);
        }
        public bool SetUserStoppedPlaybackDelay(int nUserID, 
                                                StreamType nStreamType,
                                                int nDelayMSec)
        {
            return TTDLL.TT_SetUserStoppedPlaybackDelay(m_ttInst, nUserID, nStreamType, nDelayMSec);
        }
 
        public bool SetUserJitterControl(int nUserID,
                                         StreamType nStreamType,
                                         JitterConfig lpJitterConfig)
        {
            return TTDLL.TT_SetUserJitterControl(m_ttInst, nUserID, nStreamType, ref lpJitterConfig);
        }
 
        public bool GetUserJitterControl(int nUserID,
                                         StreamType nStreamType,
                                         ref JitterConfig lpJitterConfig)
        {
            return TTDLL.TT_GetUserJitterControl(m_ttInst, nUserID, nStreamType, ref lpJitterConfig);
        }
 
        public bool SetUserPosition(int nUserID, StreamType nStreamType, 
                                    float x, float y, float z)
        {
            return TTDLL.TT_SetUserPosition(m_ttInst, nUserID, nStreamType, x, y, z);
        }
        public bool SetUserStereo(int nUserID, StreamType nStreamType, bool bLeftSpeaker, bool bRightSpeaker)
        {
            return TTDLL.TT_SetUserStereo(m_ttInst, nUserID, nStreamType, bLeftSpeaker, bRightSpeaker);
        }
        public bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars,
                                           AudioFileFormat uAFF)
        {
            return TTDLL.TT_SetUserMediaStorageDir(m_ttInst, nUserID, szFolderPath, szFileNameVars, uAFF);
        }
 
        public bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars,
                                           AudioFileFormat uAFF, int nStopRecordingExtraDelayMSec)
        {
            return TTDLL.TT_SetUserMediaStorageDirEx(m_ttInst, nUserID, szFolderPath, szFileNameVars, uAFF, nStopRecordingExtraDelayMSec);
        }
 
        public bool SetUserAudioStreamBufferSize(int nUserID, StreamType uStreamType,
                                                 int nMSec)
        {
            return TTDLL.TT_SetUserAudioStreamBufferSize(m_ttInst, nUserID, uStreamType, nMSec);
        }
        public AudioBlock AcquireUserAudioBlock(StreamType uStreamTypes, int nUserID)
        {
            IntPtr ptr = TTDLL.TT_AcquireUserAudioBlock(m_ttInst, uStreamTypes, nUserID);
            if (ptr == IntPtr.Zero)
                return new AudioBlock();
            AudioBlock lpAudioBlock = (AudioBlock)Marshal.PtrToStructure(ptr, typeof(AudioBlock));
            audioblocks.Add(lpAudioBlock.lpRawAudio, ptr);
            return lpAudioBlock; 
        }
 
        Dictionary<IntPtr, IntPtr> audioblocks = new Dictionary<IntPtr, IntPtr>();
 
        public bool ReleaseUserAudioBlock(AudioBlock lpAudioBlock)
        {
            IntPtr ptr;
            if (audioblocks.TryGetValue(lpAudioBlock.lpRawAudio, out ptr))
            {
                audioblocks.Remove(lpAudioBlock.lpRawAudio);
                return TTDLL.TT_ReleaseUserAudioBlock(m_ttInst, ptr);
            }
            return false;
        }
        public bool GetFileTransferInfo(int nTransferID, ref FileTransfer lpFileTransfer)
        {
            return TTDLL.TT_GetFileTransferInfo(m_ttInst, nTransferID, ref lpFileTransfer);
        }
 
        public bool CancelFileTranfer(int nTransferID)
        {
            return TTDLL.TT_CancelFileTransfer(m_ttInst, nTransferID);
        }
 
        public static string GetErrorMessage(ClientError nError)
        {
            IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
            TTDLL.TT_GetErrorMessage((int)nError, ptr);
            string s = Marshal.PtrToStringUni(ptr);
            Marshal.FreeHGlobal(ptr);
            return s;
        }
 
        public bool HotKey_Register(int nHotKeyID, int[] lpnVKCodes)
        {
            return TTDLL.TT_HotKey_Register(m_ttInst, nHotKeyID, lpnVKCodes, lpnVKCodes.Length);
        }
        public bool HotKey_Unregister(int nHotKeyID)
        {
            return TTDLL.TT_HotKey_Unregister(m_ttInst, nHotKeyID);
        }
        public int HotKey_IsActive(int nHotKeyID)
        {
            return TTDLL.TT_HotKey_IsActive(m_ttInst, nHotKeyID);
        }
        public bool HotKey_InstallTestHook()
        {
            if (m_eventhandler != null)
            {
#if PocketPC
                IntPtr hWnd = m_eventhandler.Hwnd;
#else
                IntPtr hWnd = m_eventhandler.Handle;
#endif
                return TTDLL.TT_HotKey_InstallTestHook(m_ttInst, hWnd,
                                                     MyEventHandler.WM_TEAMTALK_CLIENTEVENT);
            }
            return false;
        }
        public bool HotKey_RemoveTestHook()
        {
            return TTDLL.TT_HotKey_RemoveTestHook(m_ttInst);
        }
        public bool HotKey_GetKeyString(int nVKCode, ref string szKeyName)
        {
            IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
            bool b = TTDLL.TT_HotKey_GetKeyString(m_ttInst, nVKCode, ptr);
            if(b)
                szKeyName = Marshal.PtrToStringUni(ptr);
            Marshal.FreeHGlobal(ptr);
            return b;
        }
        public bool DBG_SetSoundInputTone(StreamType uStreamTypes, int nFrequency)
        {
            return TTDLL.TT_DBG_SetSoundInputTone(m_ttInst, uStreamTypes, nFrequency);
        }
 
 
        public bool DBG_WriteAudioFileTone(MediaFileInfo lpMediaFileInfo,
                                           int nFrequency)
        {
            return TTDLL.TT_DBG_WriteAudioFileTone(ref lpMediaFileInfo, nFrequency);
        }
        
        public delegate void Connection();
        public event Connection OnConnectionSuccess;
        public event Connection OnConnectionFailed;
        public event Connection OnConnectionLost;
 
        public delegate void MaxPayloadUpdate(int nPayloadSize);
 
        public event MaxPayloadUpdate OnConnectionMaxPayloadUpdated;
 
        public delegate void CommandProcessing(int nCmdID, bool bActive);
 
        public event CommandProcessing OnCmdProcessing;
 
        public delegate void CommandError(int nCmdID, ClientErrorMsg clienterrormsg);
 
        public event CommandError OnCmdError;
 
        public delegate void CommandSuccess(int nCmdID);
 
        public event CommandSuccess OnCmdSuccess;
 
        public delegate void MyselfLoggedIn(int nMyUserID, UserAccount useraccount);
 
        public event MyselfLoggedIn OnCmdMyselfLoggedIn;
 
        public delegate void MyselfLoggedOut();
        public event MyselfLoggedOut OnCmdMyselfLoggedOut;
 
        public delegate void MyselfKicked(User user);
        public event MyselfKicked OnCmdMyselfKicked;
 
        public delegate void UserUpdate(User user);
 
        public delegate void UserStreamUpdate(User user, int nStreamID);
 
        public event UserUpdate OnCmdUserLoggedIn;
 
        public event UserUpdate OnCmdUserLoggedOut;
 
        public event UserUpdate OnCmdUserUpdate;
 
        public event UserUpdate OnCmdUserJoinedChannel;
 
        public event UserUpdate OnCmdUserLeftChannel;
 
        public delegate void UserTextMessage(TextMessage textmessage);
 
        public event UserTextMessage OnCmdUserTextMessage;
 
 
        public delegate void ChannelUpdate(Channel channel);
 
        public event ChannelUpdate OnCmdChannelNew;
 
        public event ChannelUpdate OnCmdChannelUpdate;
 
        public event ChannelUpdate OnCmdChannelRemove;
 
        public delegate void ServerUpdate(ServerProperties serverproperties);
 
        public event ServerUpdate OnCmdServerUpdate;
 
        public delegate void ServerStats(ServerStatistics serverstatistics);
            
        public event ServerStats OnCmdServerStatistics;
 
        public delegate void FileUpdate(RemoteFile remotefile);
 
        public event FileUpdate OnCmdFileNew;
 
        public event FileUpdate OnCmdFileRemove;
 
        public delegate void ListUserAccount(UserAccount useraccount);
 
        public event ListUserAccount OnCmdUserAccount;
 
        public delegate void ListBannedUser(BannedUser banneduser);
 
        public event ListBannedUser OnCmdBannedUser;
 
        public event UserStreamUpdate OnUserFirstVoiceStreamPacket;
 
        public event UserUpdate OnUserStateChange;
 
        public delegate void UserVideoFrame(int nUserID, int nStreamID);
 
        public event UserVideoFrame OnUserVideoCapture;
 
        public event UserVideoFrame OnUserMediaFileVideo;
 
        public delegate void NewDesktopWindow(int nUserID, int nStreamID);
 
        public event NewDesktopWindow OnUserDesktopWindow;
 
        public delegate void UserDesktopInput(int nSrcUserID, DesktopInput desktopinput);
 
        public event UserDesktopInput OnUserDesktopCursor;
 
        public event UserDesktopInput OnUserDesktopInput;
 
        public delegate void UserRecordMediaFile(int nUserID, MediaFileInfo mediafileinfo);
 
        public event UserRecordMediaFile OnUserRecordMediaFile;
 
        public delegate void NewAudioBlock(int nUserID, StreamType nStreamType);
 
        public event NewAudioBlock OnUserAudioBlock;
 
        public delegate void ErrorOccured(ClientErrorMsg clienterrormsg);
 
        public event ErrorOccured OnInternalError;
 
        public delegate void VoiceActivation(bool bVoiceActive);
 
        public event VoiceActivation OnVoiceActivation;
 
        public delegate void HotKeyToggle(int nHotKeyID, bool bActive);
 
        public event HotKeyToggle OnHotKeyToggle;
 
        public delegate void HotKeyTest(int nVkCode, bool bActive);
 
        public event HotKeyTest OnHotKeyTest;
 
        public delegate void FileTransferUpdate(FileTransfer filetransfer);
 
        public event FileTransferUpdate OnFileTransfer;
 
        public delegate void DesktopTransferUpdate(int nSessionID, int nBytesRemain);
 
        public event DesktopTransferUpdate OnDesktopWindowTransfer;
 
        public delegate void StreamMediaFile(MediaFileInfo mediafileinfo);
 
        public event StreamMediaFile OnStreamMediaFile;
 
        public delegate void LocalMediaFile(MediaFileInfo mediafileinfo);
 
        public event LocalMediaFile OnLocalMediaFile;
 
        public delegate void AudioInput(AudioInputProgress aip);
 
        public event AudioInput OnAudioInput;
 
        //TTDLL instance
        private IntPtr m_ttInst;
        //TTDLL event handler
        c_tt.MyEventHandler m_eventhandler;
    }
 
    public class TeamTalk5 : TeamTalkBase
    {
        public const int DEFAULT_TCPPORT = 10333;
        public const int DEFAULT_UDPPORT = 10333;
 
        public TeamTalk5(bool poll_based)
            : base(poll_based)
        {
        }
    }
 
    public class TeamTalk5Pro : TeamTalkBase
    {
        public const int DEFAULT_TCPPORT = 10443;
        public const int DEFAULT_UDPPORT = 10443;
 
        public TeamTalk5Pro(bool poll_based)
            : base(poll_based)
        {
        }
    }
    public enum TTKeyTranslate : uint
    {
        TTKEY_NO_TRANSLATE                  = 0,
        TTKEY_WINKEYCODE_TO_TTKEYCODE       = 1,
        TTKEY_TTKEYCODE_TO_WINKEYCODE       = 2,
        TTKEY_MACKEYCODE_TO_TTKEYCODE       = 3,
        TTKEY_TTKEYCODE_TO_MACKEYCODE       = 4
    }
 
    public enum MixerControl : uint
    {
        WAVEOUT_MASTER,
        WAVEOUT_WAVE,
        WAVEOUT_MICROPHONE,
 
        WAVEIN_MICROPHONE,
        WAVEIN_LINEIN,
        WAVEIN_WAVEOUT,
    }
 
    public class WindowsMixer
    {
        public static int GetMixerCount()
        {
            return TTDLL.TT_Mixer_GetMixerCount();
        }
        public static bool GetMixerName(int nMixerIndex,
                                        ref string szMixerName)
        {
            IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
            bool b = TTDLL.TT_Mixer_GetMixerName(nMixerIndex, ptr);
            if(b)
                szMixerName = Marshal.PtrToStringUni(ptr);
 
            Marshal.FreeHGlobal(ptr);
            return b;
        }
        public static bool GetWaveInName(int nWaveDeviceID,
                                         ref string szMixerName)
        {
            IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
            bool b = TTDLL.TT_Mixer_GetWaveInName(nWaveDeviceID, ptr);
            if(b)
                szMixerName = Marshal.PtrToStringUni(ptr);
            Marshal.FreeHGlobal(ptr);
            return b;
        }
        public static bool GetWaveOutName(int nWaveDeviceID,
                                          ref string szMixerName)
        {
            IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
            bool b = TTDLL.TT_Mixer_GetWaveOutName(nWaveDeviceID, ptr);
            if(b)
                szMixerName = Marshal.PtrToStringUni(ptr);
 
            Marshal.FreeHGlobal(ptr);
            return b;
        }
 
        public static bool SetWaveOutMute(int nWaveDeviceID, MixerControl nControl, bool bMute)
        {
            return TTDLL.TT_Mixer_SetWaveOutMute(nWaveDeviceID, nControl, bMute);
        }
        public static int GetWaveOutMute(int nWaveDeviceID, MixerControl nControl)
        {
            return TTDLL.TT_Mixer_GetWaveOutMute(nWaveDeviceID, nControl);
        }
        public static bool SetWaveOutVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
        {
            return TTDLL.TT_Mixer_SetWaveOutVolume(nWaveDeviceID, nControl, nVolume);
        }
        public static int GetWaveOutVolume(int nWaveDeviceID, MixerControl nControl)
        {
            return TTDLL.TT_Mixer_GetWaveOutVolume(nWaveDeviceID, nControl);
        }
        public static bool SetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
        {
            return TTDLL.TT_Mixer_SetWaveInSelected(nWaveDeviceID, nControl);
        }
        public static int GetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
        {
            return TTDLL.TT_Mixer_GetWaveInSelected(nWaveDeviceID, nControl);
        }
        public static bool SetWaveInVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
        {
            return TTDLL.TT_Mixer_SetWaveInVolume(nWaveDeviceID, nControl, nVolume);
        }
        public static int GetWaveInVolume(int nWaveDeviceID, MixerControl nControl)
        {
            return TTDLL.TT_Mixer_GetWaveInVolume(nWaveDeviceID, nControl);
        }
        public static bool SetWaveInBoost(int nWaveDeviceID, bool bEnable)
        {
            return TTDLL.TT_Mixer_SetWaveInBoost(nWaveDeviceID, bEnable);
        }
        public static int GetWaveInBoost(int nWaveDeviceID)
        {
            return TTDLL.TT_Mixer_GetWaveInBoost(nWaveDeviceID);
        }
        public static bool SetWaveInMute(int nWaveDeviceID, bool bEnable)
        {
            return TTDLL.TT_Mixer_SetWaveInMute(nWaveDeviceID, bEnable);
        }
        public static int GetWaveInMute(int nWaveDeviceID)
        {
            return TTDLL.TT_Mixer_GetWaveInMute(nWaveDeviceID);
        }
        public static int GetWaveInControlCount(int nWaveDeviceID)
        {
            return TTDLL.TT_Mixer_GetWaveInControlCount(nWaveDeviceID);
        }
        public static bool GetWaveInControlName(int nWaveDeviceID, int nControlIndex,
                                                ref string szDeviceName)
        {
            IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
            bool b = TTDLL.TT_Mixer_GetWaveInControlName(nWaveDeviceID, nControlIndex, ptr);
            if(b)
                szDeviceName = Marshal.PtrToStringUni(ptr);
            Marshal.FreeHGlobal(ptr);
            return b;
        }
        public static bool SetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
        {
            return TTDLL.TT_Mixer_SetWaveInControlSelected(nWaveDeviceID, nControlIndex);
        }
        public static bool GetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
        {
            return TTDLL.TT_Mixer_GetWaveInControlSelected(nWaveDeviceID, nControlIndex);
        }
    }
    public class WindowsFirewall
    {
        public static bool IsEnabled()
        {
            return TTDLL.TT_Firewall_IsEnabled();
        }
        public static bool Enable(bool bEnable)
        {
            return TTDLL.TT_Firewall_Enable(bEnable);
        }
        public static bool AppExceptionExists(string szExecutable)
        {
            return TTDLL.TT_Firewall_AppExceptionExists(szExecutable);
        }
        public static bool AddAppException(string szName, string szExecutable)
        {
            return TTDLL.TT_Firewall_AddAppException(szName, szExecutable);
        }
        public static bool RemoveAppException(string szExecutable)
        {
            return TTDLL.TT_Firewall_RemoveAppException(szExecutable);
        }
    }
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    public struct ShareWindow
    {
        public IntPtr hWnd;
        public int nWndX;
        public int nWndY;
        public int nWidth;
        public int nHeight;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
        public string szWindowTitle;
    }
 
    public class WindowsHelper
    {
        public static System.IntPtr GetDesktopActiveHWND()
        {
            return TTDLL.TT_Windows_GetDesktopActiveHWND();
        }
 
        public static System.IntPtr GetDesktopHWND()
        {
            return TTDLL.TT_Windows_GetDesktopHWND();
        }
 
        public static bool GetDesktopWindowHWND(int nIndex,
                                                ref System.IntPtr lpHWnd)
        {
            return TTDLL.TT_Windows_GetDesktopWindowHWND(nIndex, ref lpHWnd);
        }
 
        public static bool GetWindow(System.IntPtr hWnd,
                                     ref ShareWindow lpShareWindow)
        {
            return TTDLL.TT_Windows_GetWindow(hWnd, ref lpShareWindow);
        }
 
        public static int DesktopInputKeyTranslate(TTKeyTranslate nTranslate,
                                                   DesktopInput[] lpDesktopInputs,
                                                   out DesktopInput[] lpTranslatedDesktopInputs)
        {
            lpTranslatedDesktopInputs = new DesktopInput[lpDesktopInputs.Length];
            return TTDLL.TT_DesktopInput_KeyTranslate(nTranslate, lpDesktopInputs,
                                                    lpTranslatedDesktopInputs,
                                                    lpDesktopInputs.Length);
        }
 
        public static int DesktopInputExecute(DesktopInput[] lpDesktopInputs)
        {
            return TTDLL.TT_DesktopInput_Execute(lpDesktopInputs, lpDesktopInputs.Length);
        }
 
    }
}