TeamTalk 5 Java DLL Version 5.18A

TeamTalk.cs
1 /*
2 * Copyright (c) 2005-2018, BearWare.dk
3 *
4 * Contact Information:
5 *
6 * Bjoern D. Rasmussen
7 * Kirketoften 5
8 * DK-8260 Viby J
9 * Denmark
10 * Email: contact@bearware.dk
11 * Phone: +45 20 20 54 59
12 * Web: http://www.bearware.dk
13 *
14 * This source code is part of the TeamTalk SDK owned by
15 * BearWare.dk. Use of this file, or its compiled unit, requires a
16 * TeamTalk SDK License Key issued by BearWare.dk.
17 *
18 * The TeamTalk SDK License Agreement along with its Terms and
19 * Conditions are outlined in the file License.txt included with the
20 * TeamTalk SDK distribution.
21 *
22 */
23
24 using System;
25 using System.Collections.Generic;
26 using System.Text;
27 using System.Windows.Forms;
28 using System.Drawing;
29 using System.Drawing.Imaging;
30 using System.Threading;
31 using System.Diagnostics;
32 using System.Reflection;
33 using System.Runtime.InteropServices;
34 using c_tt;
35
36 namespace BearWare
37 {
43 [Flags]
44 public enum StreamType : uint
45 {
47 STREAMTYPE_NONE = 0x00000000,
50 STREAMTYPE_VOICE = 0x00000001,
53 STREAMTYPE_VIDEOCAPTURE = 0x00000002,
56 STREAMTYPE_MEDIAFILE_AUDIO = 0x00000004,
59 STREAMTYPE_MEDIAFILE_VIDEO = 0x00000008,
62 STREAMTYPE_DESKTOP = 0x00000010,
66 STREAMTYPE_DESKTOPINPUT = 0x00000020,
68 STREAMTYPE_MEDIAFILE = STREAMTYPE_MEDIAFILE_AUDIO |
69 STREAMTYPE_MEDIAFILE_VIDEO,
78 STREAMTYPE_CHANNELMSG = 0x00000040,
84 STREAMTYPE_LOCALMEDIAPLAYBACK_AUDIO = 0x00000080,
85
88 STREAMTYPE_CLASSROOM_ALL = STREAMTYPE_VOICE |
89 STREAMTYPE_VIDEOCAPTURE |
90 STREAMTYPE_DESKTOP |
91 STREAMTYPE_MEDIAFILE |
92 STREAMTYPE_CHANNELMSG,
93 }
106 public enum SoundSystem : uint
107 {
109 SOUNDSYSTEM_NONE = 0,
111 SOUNDSYSTEM_WINMM = 1,
113 SOUNDSYSTEM_DSOUND = 2,
121 SOUNDSYSTEM_ALSA = 3,
123 SOUNDSYSTEM_COREAUDIO = 4,
134 SOUNDSYSTEM_WASAPI = 5,
136 SOUNDSYSTEM_OPENSLES_ANDROID = 7,
152 SOUNDSYSTEM_AUDIOUNIT = 8,
154 SOUNDSYSTEM_AUDIOUNIT_IOS = SOUNDSYSTEM_AUDIOUNIT,
157 SOUNDSYSTEM_PULSEAUDIO = 10,
158 }
159
164 [Flags]
165 public enum SoundDeviceFeature : uint
166 {
167 SOUNDDEVICEFEATURE_NONE = 0x0000,
173 SOUNDDEVICEFEATURE_AEC = 0x0001,
179 SOUNDDEVICEFEATURE_AGC = 0x0002,
184 SOUNDDEVICEFEATURE_DENOISE = 0x0004,
187 SOUNDDEVICEFEATURE_3DPOSITION = 0x0008,
190 SOUNDDEVICEFEATURE_DUPLEXMODE = 0x0010,
193 SOUNDDEVICEFEATURE_DEFAULTCOMDEVICE = 0x0020,
194 }
195
208 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
209 public struct SoundDevice
210 {
216 public int nDeviceID;
218 public SoundSystem nSoundSystem;
220 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
221 public string szDeviceName;
226 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
227 public string szDeviceID;
244 public int nWaveDeviceID;
247 public bool bSupports3D;
249 public int nMaxInputChannels;
251 public int nMaxOutputChannels;
255 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_SAMPLERATES_MAX)]
256 public int[] inputSampleRates;
260 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_SAMPLERATES_MAX)]
261 public int[] outputSampleRates;
263 public int nDefaultSampleRate;
269 public SoundDeviceFeature uSoundDeviceFeatures;
270 }
271
272
281 public struct SoundDeviceEffects
282 {
298 public bool bEnableAGC;
315 public bool bEnableDenoise;
331 public bool bEnableEchoCancellation;
332 }
333
336 public struct SoundDeviceConstants
337 {
340 public const int TT_SOUNDDEVICE_ID_REMOTEIO = 0;
346 public const int TT_SOUNDDEVICE_ID_VOICEPREPROCESSINGIO = (1 | (int)TT_SOUNDDEVICE_ID_SHARED_FLAG);
351 public const int TT_SOUNDDEVICE_ID_OPENSLES_DEFAULT = 0;
356 public const int TT_SOUNDDEVICE_ID_OPENSLES_VOICECOM = 1;
365 public const int TT_SOUNDDEVICE_ID_TEAMTALK_VIRTUAL = 1978;
366
367
381 public const uint TT_SOUNDDEVICE_ID_SHARED_FLAG = 0x00000800;
382
387 public const uint TT_SOUNDDEVICE_ID_MASK = 0x000007FF;
388 }
389
393 public struct SoundLevel
394 {
400 public const int SOUND_VU_MAX = 100;
406 public const int SOUND_VU_MIN = 0;
414 public const int SOUND_VOLUME_MAX = 32000;
422 public const int SOUND_VOLUME_DEFAULT = 1000;
428 public const int SOUND_VOLUME_MIN = 0;
437 public const int SOUND_GAIN_MAX = 32000;
447 public const int SOUND_GAIN_DEFAULT = 1000;
456 public const int SOUND_GAIN_MIN = 0;
457 }
458
473 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
474 public struct AudioBlock
475 {
479 public int nStreamID;
481 public int nSampleRate;
483 public int nChannels;
487 public System.IntPtr lpRawAudio;
489 public int nSamples;
497 public uint uSampleIndex;
510 StreamType uStreamTypes;
511 }
512
521 public enum MediaFileStatus : uint
522 {
523 MFS_CLOSED = 0,
525 MFS_ERROR = 1,
527 MFS_STARTED = 2,
529 MFS_FINISHED = 3,
531 MFS_ABORTED = 4,
533 MFS_PAUSED = 5,
536 MFS_PLAYING = 6
537 }
538
542 public enum AudioFileFormat : uint
543 {
545 AFF_NONE = 0,
556 AFF_CHANNELCODEC_FORMAT = 1,
558 AFF_WAVE_FORMAT = 2,
560 AFF_MP3_16KBIT_FORMAT = 3,
562 AFF_MP3_32KBIT_FORMAT = 4,
564 AFF_MP3_64KBIT_FORMAT = 5,
566 AFF_MP3_128KBIT_FORMAT = 6,
568 AFF_MP3_256KBIT_FORMAT = 7,
570 AFF_MP3_320KBIT_FORMAT = 8,
571 }
572
580 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
581 public struct AudioFormat
582 {
584 public AudioFileFormat nAudioFmt;
586 public int nSampleRate;
588 public int nChannels;
589 }
590
601 public enum FourCC : uint
602 {
604 FOURCC_NONE = 0,
607 FOURCC_I420 = 100,
610 FOURCC_YUY2 = 101,
613 FOURCC_RGB32 = 102
614 }
615
622 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
623 public struct VideoFormat
624 {
627 public int nWidth;
630 public int nHeight;
634 public int nFPS_Numerator;
638 public int nFPS_Denominator;
640 public FourCC picFourCC;
641 }
642
650 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
651 public struct VideoFrame
652 {
655 public int nWidth;
658 public int nHeight;
664 public int nStreamID;
669 public bool bKeyFrame;
671 public System.IntPtr frameBuffer;
674 public int nFrameBufferSize;
675 }
676
686 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
687 public struct VideoCaptureDevice
688 {
690 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
691 public string szDeviceID;
693 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
694 public string szDeviceName;
707 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
708 public string szCaptureAPI;
710 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_VIDEOFORMATS_MAX)]
711 public VideoFormat[] videoFormats;
714 public int nVideoFormatsCount;
715 }
716
724 public enum BitmapFormat : uint
725 {
727 BMP_NONE = 0,
733 BMP_RGB8_PALETTE = 1,
736 BMP_RGB16_555 = 2,
740 BMP_RGB24 = 3,
744 BMP_RGB32 = 4
745 }
746
751 public enum DesktopProtocol : uint
752 {
755 DESKTOPPROTOCOL_ZLIB_1 = 1
756 }
757
764 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
765 public struct DesktopWindow
766 {
768 public int nWidth;
770 public int nHeight;
772 public BitmapFormat bmpFormat;
775 public int nBytesPerLine;
782 public int nSessionID;
784 public DesktopProtocol nProtocol;
786 public IntPtr frameBuffer;
789 public int nFrameBufferSize;
790 }
791
795 public enum DesktopKeyState : uint
796 {
798 DESKTOPKEYSTATE_NONE = 0x00000000,
800 DESKTOPKEYSTATE_DOWN = 0x00000001,
802 DESKTOPKEYSTATE_UP = 0x00000002,
803 }
804
812 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
813 public struct DesktopInput
814 {
818 public ushort uMousePosX;
822 public ushort uMousePosY;
828 public uint uKeyCode;
831 public DesktopKeyState uKeyState;
833 public DesktopInput(bool set_defaults)
834 {
835 if (set_defaults)
836 {
837 uMousePosX = uMousePosY = (ushort)DesktopInputConstants.DESKTOPINPUT_MOUSEPOS_IGNORE;
838 uKeyCode = DesktopInputConstants.DESKTOPINPUT_KEYCODE_IGNORE;
839 uKeyState = DesktopKeyState.DESKTOPKEYSTATE_NONE;
840 }
841 else
842 {
843 uMousePosX = uMousePosY = 0;
844 uKeyCode = 0;
845 uKeyState = DesktopKeyState.DESKTOPKEYSTATE_NONE;
846 }
847 }
848 }
849
851 public struct DesktopInputConstants
852 {
860 public const uint DESKTOPINPUT_KEYCODE_IGNORE = 0xFFFFFFFF;
861
869 public const ushort DESKTOPINPUT_MOUSEPOS_IGNORE = 0xFFFF;
870
877 public const uint DESKTOPINPUT_KEYCODE_LMOUSEBTN = 0x1000;
878
885 public const uint DESKTOPINPUT_KEYCODE_RMOUSEBTN = 0x1001;
886
893 public const uint DESKTOPINPUT_KEYCODE_MMOUSEBTN = 0x1002;
894 }
895
908 [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
909 public struct SpeexCodec
910 {
913 [FieldOffset(0)]
914 public int nBandmode;
917 [FieldOffset(4)]
918 public int nQuality;
928 [FieldOffset(8)]
929 public int nTxIntervalMSec;
935 [FieldOffset(12)]
936 public bool bStereoPlayback;
937 }
938
944 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
945 public struct SpeexVBRCodec
946 {
949 public int nBandmode;
952 public int nQuality;
959 public int nBitRate;
963 public int nMaxBitRate;
967 public bool bDTX;
976 public int nTxIntervalMSec;
982 public bool bStereoPlayback;
983 }
984
986 public struct SpeexConstants
987 {
989 public const int SPEEX_BANDMODE_NARROW = 0;
991 public const int SPEEX_BANDMODE_WIDE = 1;
993 public const int SPEEX_BANDMODE_UWIDE = 2;
995 public const int SPEEX_QUALITY_MIN = 0;
997 public const int SPEEX_QUALITY_MAX = 10;
1000 public const int SPEEX_NB_MIN_BITRATE = 2150;
1003 public const int SPEEX_NB_MAX_BITRATE = 24600;
1006 public const int SPEEX_WB_MIN_BITRATE = 3950;
1009 public const int SPEEX_WB_MAX_BITRATE = 42200;
1012 public const int SPEEX_UWB_MIN_BITRATE = 4150;
1015 public const int SPEEX_UWB_MAX_BITRATE = 44000;
1018 public const int DEFAULT_SPEEX_BANDMODE = 1;
1021 public const int DEFAULT_SPEEX_QUALITY = 4;
1024 public const int DEFAULT_SPEEX_DELAY = 40;
1027 public const bool DEFAULT_SPEEX_SIMSTEREO = false;
1030 public const int DEFAULT_SPEEX_BITRATE = 0;
1033 public const int DEFAULT_SPEEX_MAXBITRATE = 0;
1036 public const bool DEFAULT_SPEEX_DTX = true;
1037 }
1038
1041 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1042 public struct OpusCodec
1043 {
1046 public int nSampleRate;
1048 public int nChannels;
1052 public int nApplication;
1055 public int nComplexity;
1058 public bool bFEC;
1061 public bool bDTX;
1065 public int nBitRate;
1067 public bool bVBR;
1070 public bool bVBRConstraint;
1077 public int nTxIntervalMSec;
1081 public int nFrameSizeMSec;
1082 }
1083
1085 public struct OpusConstants
1086 {
1089 public const int OPUS_APPLICATION_VOIP = 2048;
1092 public const int OPUS_APPLICATION_AUDIO = 2049;
1095 public const int OPUS_MIN_BITRATE = 6000;
1098 public const int OPUS_MAX_BITRATE = 510000;
1099
1102 public const int OPUS_MIN_FRAMESIZE = 2; /* Actually it's 2.5 */
1105 public const int OPUS_MAX_FRAMESIZE = 60;
1109 public const int OPUS_REALMAX_FRAMESIZE = 120;
1110
1111 public const int DEFAULT_OPUS_APPLICATION = OPUS_APPLICATION_VOIP;
1112 public const int DEFAULT_OPUS_SAMPLERATE = 48000;
1113 public const int DEFAULT_OPUS_CHANNELS = 1;
1114 public const int DEFAULT_OPUS_COMPLEXITY = 10;
1115 public const bool DEFAULT_OPUS_FEC = true;
1116 public const bool DEFAULT_OPUS_DTX = false;
1117 public const bool DEFAULT_OPUS_VBR = true;
1118 public const bool DEFAULT_OPUS_VBRCONSTRAINT = false;
1119 public const int DEFAULT_OPUS_BITRATE = 32000;
1120 public const int DEFAULT_OPUS_DELAY = 20;
1121 }
1122
1140 [StructLayout(LayoutKind.Explicit)]
1141 public struct SpeexDSP
1142 {
1150 [FieldOffset(0)]
1151 public bool bEnableAGC;
1154 [FieldOffset(4)]
1155 public int nGainLevel;
1159 [FieldOffset(8)]
1160 public int nMaxIncDBSec;
1165 [FieldOffset(12)]
1166 public int nMaxDecDBSec;
1170 [FieldOffset(16)]
1171 public int nMaxGainDB;
1174 [FieldOffset(20)]
1175 public bool bEnableDenoise;
1179 [FieldOffset(24)]
1180 public int nMaxNoiseSuppressDB;
1199 [FieldOffset(28)]
1200 public bool bEnableEchoCancellation;
1204 [FieldOffset(32)]
1205 public int nEchoSuppress;
1209 [FieldOffset(36)]
1210 public int nEchoSuppressActive;
1211
1212 public SpeexDSP(bool set_defaults)
1213 {
1214 if (set_defaults)
1215 {
1216 bEnableAGC = SpeexDSPConstants.DEFAULT_AGC_ENABLE;
1217 nGainLevel = SpeexDSPConstants.DEFAULT_AGC_GAINLEVEL;
1218 nMaxIncDBSec = SpeexDSPConstants.DEFAULT_AGC_INC_MAXDB;
1219 nMaxDecDBSec = SpeexDSPConstants.DEFAULT_AGC_DEC_MAXDB;
1220 nMaxGainDB = SpeexDSPConstants.DEFAULT_AGC_GAINMAXDB;
1221
1222 bEnableDenoise = SpeexDSPConstants.DEFAULT_DENOISE_ENABLE;
1223 nMaxNoiseSuppressDB = SpeexDSPConstants.DEFAULT_DENOISE_SUPPRESS;
1224
1225 bEnableEchoCancellation = SpeexDSPConstants.DEFAULT_ECHO_ENABLE;
1226 nEchoSuppress = SpeexDSPConstants.DEFAULT_ECHO_SUPPRESS;
1227 nEchoSuppressActive = SpeexDSPConstants.DEFAULT_ECHO_SUPPRESS_ACTIVE;
1228 }
1229 else
1230 {
1231 bEnableAGC = false;
1232 nGainLevel = 0;
1233 nMaxIncDBSec = 0;
1234 nMaxDecDBSec = 0;
1235 nMaxGainDB = 0;
1236
1237 bEnableDenoise = false;
1238 nMaxNoiseSuppressDB = 0;
1239
1240 bEnableEchoCancellation = false;
1241 nEchoSuppress = 0;
1242 nEchoSuppressActive = 0;
1243 }
1244 }
1245 }
1246
1249 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1250 public struct TTAudioPreprocessor
1251 {
1255 public int nGainLevel;
1257 public bool bMuteLeftSpeaker;
1259 public bool bMuteRightSpeaker;
1260 }
1261
1271 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1272 public struct WebRTCAudioPreprocessor
1273 {
1275 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1276 public struct Preamplifier
1277 {
1280 public bool bEnable;
1282 public float fFixedGainFactor;
1283 }
1284 public Preamplifier preamplifier;
1285
1288 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1289 public struct EchoCanceller
1290 {
1296 public bool bEnable;
1297 }
1298 public EchoCanceller echocanceller;
1299
1302 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1303 public struct NoiseSuppression
1304 {
1306 public bool bEnable;
1309 public int nLevel;
1310 }
1311 public NoiseSuppression noisesuppression;
1312
1315 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1316 public struct GainController2
1317 {
1320 public bool bEnable;
1323 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1324 public struct FixedDigital
1325 {
1328 public float fGainDB;
1329 }
1330 public FixedDigital fixeddigital;
1331
1333 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1334 public struct AdaptiveDigital
1335 {
1336 /* @brief Configuration for fine tuning gain level after echo
1337 * cancellation and noise suppression. */
1338 public bool bEnable;
1340 public float fHeadRoomDB;
1342 public float fMaxGainDB;
1344 public float fInitialGainDB;
1345 /* Range: 0 < x < infinite. Default: 6 dB/sec */
1346 public float fMaxGainChangeDBPerSecond;
1347 /* Range: -infinite < x < 0. Default: -50 */
1348 public float fMaxOutputNoiseLevelDBFS;
1349 }
1350 public AdaptiveDigital adaptivedigital;
1351 }
1352 public GainController2 gaincontroller2;
1353
1354 public WebRTCAudioPreprocessor(bool set_defaults)
1355 {
1356 if (set_defaults)
1357 {
1358 preamplifier.bEnable = WebRTCConstants.DEFAULT_WEBRTC_PREAMPLIFIER_ENABLE;
1359 preamplifier.fFixedGainFactor = WebRTCConstants.DEFAULT_WEBRTC_PREAMPLIFIER_GAINFACTOR;
1360
1361 echocanceller.bEnable = WebRTCConstants.DEFAULT_WEBRTC_ECHO_CANCEL_ENABLE;
1362
1363 noisesuppression.bEnable = WebRTCConstants.DEFAULT_WEBRTC_NOISESUPPRESS_ENABLE;
1364 noisesuppression.nLevel = WebRTCConstants.DEFAULT_WEBRTC_NOISESUPPRESS_LEVEL;
1365
1366 gaincontroller2.bEnable = WebRTCConstants.DEFAULT_WEBRTC_GAINCTL_ENABLE;
1367 gaincontroller2.fixeddigital.fGainDB = WebRTCConstants.DEFAULT_WEBRTC_GAINDB;
1368
1369 gaincontroller2.adaptivedigital.bEnable = WebRTCConstants.DEFAULT_WEBRTC_SAT_PROT_ENABLE;
1370 gaincontroller2.adaptivedigital.fHeadRoomDB = WebRTCConstants.DEFAULT_WEBRTC_HEADROOM_DB;
1371 gaincontroller2.adaptivedigital.fMaxGainDB = WebRTCConstants.DEFAULT_WEBRTC_MAXGAIN_DB;
1372 gaincontroller2.adaptivedigital.fInitialGainDB = WebRTCConstants.DEFAULT_WEBRTC_INITIAL_GAIN_DB;
1373 gaincontroller2.adaptivedigital.fMaxGainChangeDBPerSecond = WebRTCConstants.DEFAULT_WEBRTC_MAXGAIN_DBSEC;
1374 gaincontroller2.adaptivedigital.fMaxOutputNoiseLevelDBFS = WebRTCConstants.DEFAULT_WEBRTC_MAX_OUT_NOISE;
1375 }
1376 else
1377 {
1378 preamplifier.bEnable = false;
1379 preamplifier.fFixedGainFactor = 0.0f;
1380
1381 echocanceller.bEnable = false;
1382
1383 noisesuppression.bEnable = false;
1384 noisesuppression.nLevel = 0;
1385
1386 gaincontroller2.bEnable = false;
1387 gaincontroller2.fixeddigital.fGainDB = 0.0f;
1388
1389 gaincontroller2.adaptivedigital.bEnable = false;
1390 gaincontroller2.adaptivedigital.fHeadRoomDB = 0.0f;
1391 gaincontroller2.adaptivedigital.fMaxGainDB = 0.0f;
1392 gaincontroller2.adaptivedigital.fInitialGainDB = 0.0f;
1393 gaincontroller2.adaptivedigital.fMaxGainChangeDBPerSecond = 0.0f;
1394 gaincontroller2.adaptivedigital.fMaxOutputNoiseLevelDBFS = 0.0f;
1395 }
1396 }
1397 }
1398
1400 public struct WebRTCConstants
1401 {
1402 public const bool DEFAULT_WEBRTC_PREAMPLIFIER_ENABLE = false;
1403 public const float DEFAULT_WEBRTC_PREAMPLIFIER_GAINFACTOR = 1.0f;
1404 public const bool DEFAULT_WEBRTC_GAINCTL_ENABLE = false;
1405 public const float DEFAULT_WEBRTC_GAINDB = 15;
1406 public const bool DEFAULT_WEBRTC_SAT_PROT_ENABLE = false;
1407 public const float DEFAULT_WEBRTC_HEADROOM_DB = 5;
1408 public const float DEFAULT_WEBRTC_MAXGAIN_DB = 50;
1409 public const float DEFAULT_WEBRTC_INITIAL_GAIN_DB = 15;
1410 public const float DEFAULT_WEBRTC_MAXGAIN_DBSEC = 6;
1411 public const float DEFAULT_WEBRTC_MAX_OUT_NOISE = -50;
1412 public const bool DEFAULT_WEBRTC_NOISESUPPRESS_ENABLE = false;
1413 public const int DEFAULT_WEBRTC_NOISESUPPRESS_LEVEL = 2;
1414 public const bool DEFAULT_WEBRTC_ECHO_CANCEL_ENABLE = false;
1415 public const float WEBRTC_GAINCONTROLLER2_FIXEDGAIN_MAX = 49.9f;
1416 }
1417
1421 public enum AudioPreprocessorType : uint
1422 {
1425 NO_AUDIOPREPROCESSOR = 0,
1427 SPEEXDSP_AUDIOPREPROCESSOR = 1,
1429 TEAMTALK_AUDIOPREPROCESSOR = 2,
1432 WEBRTC_AUDIOPREPROCESSOR = 3,
1433 };
1434
1436 [StructLayout(LayoutKind.Explicit)]
1437 public struct AudioPreprocessor
1438 {
1440 [FieldOffset(0)]
1441 public AudioPreprocessorType nPreprocessor;
1443 [FieldOffset(4)]
1444 public SpeexDSP speexdsp;
1446 [FieldOffset(4)]
1447 public TTAudioPreprocessor ttpreprocessor;
1449 [FieldOffset(4)]
1450 public WebRTCAudioPreprocessor webrtc;
1451 }
1452
1454 public struct SpeexDSPConstants
1455 {
1456 public const bool DEFAULT_AGC_ENABLE = true;
1457 public const int DEFAULT_AGC_GAINLEVEL = 8000;
1458 public const int DEFAULT_AGC_INC_MAXDB = 12;
1459 public const int DEFAULT_AGC_DEC_MAXDB = -40;
1460 public const int DEFAULT_AGC_GAINMAXDB = 30;
1461 public const bool DEFAULT_DENOISE_ENABLE = true;
1462 public const int DEFAULT_DENOISE_SUPPRESS = -30;
1463 public const bool DEFAULT_ECHO_ENABLE = true;
1464 public const int DEFAULT_ECHO_SUPPRESS = -40;
1465 public const int DEFAULT_ECHO_SUPPRESS_ACTIVE = -15;
1466 }
1467
1472 [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
1473 public struct WebMVP8Codec
1474 {
1476 [FieldOffset(0)]
1477 public int nRcTargetBitrate;
1483 [FieldOffset(0)]
1484 public int rc_target_bitrate;
1492 [FieldOffset(4)]
1493 public uint nEncodeDeadline;
1494 }
1495
1496 public struct WebMVP8CodecConstants
1497 {
1500 public const int WEBM_VPX_DL_REALTIME = 1;
1503 public const int WEBM_VPX_DL_GOOD_QUALITY = 1000000;
1506 public const int WEBM_VPX_DL_BEST_QUALITY = 0;
1507 }
1508
1513 public enum Codec : uint
1514 {
1516 NO_CODEC = 0,
1519 SPEEX_CODEC = 1,
1522 SPEEX_VBR_CODEC = 2,
1524 OPUS_CODEC = 3,
1526 WEBM_VP8_CODEC = 128
1527 }
1528
1532 [StructLayout(LayoutKind.Explicit)]
1533 public struct AudioCodec
1534 {
1537 [FieldOffset(0)]
1538 public Codec nCodec;
1541 [FieldOffset(4)]
1542 public SpeexCodec speex;
1545 [FieldOffset(4)]
1546 public SpeexVBRCodec speex_vbr;
1549 [FieldOffset(4)]
1550 public OpusCodec opus;
1551 }
1552
1566 [StructLayout(LayoutKind.Explicit)]
1567 public struct AudioConfig
1568 {
1570 [FieldOffset(0)]
1571 public bool bEnableAGC;
1573 [FieldOffset(4)]
1574 public int nGainLevel;
1575
1576 public AudioConfig(bool set_defaults)
1577 {
1578 if (set_defaults)
1579 {
1580 bEnableAGC = true;
1581 nGainLevel = AudioConfigConstants.DEFAULT_AGC_GAINLEVEL;
1582 }
1583 else
1584 {
1585 bEnableAGC = false;
1586 nGainLevel = 0;
1587 }
1588 }
1589 }
1590
1591 public struct AudioConfigConstants
1592 {
1593 public const int DEFAULT_AGC_GAINLEVEL = 8000;
1594 public const int DEFAULT_AGC_INC_MAXDB = 12;
1595 }
1596
1598 [StructLayout(LayoutKind.Explicit)]
1599 public struct VideoCodec
1600 {
1604 [FieldOffset(0)]
1605 public Codec nCodec;
1606 [FieldOffset(4)]
1607 public WebMVP8Codec webm_vp8;
1608 }
1619 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1620 public struct MediaFileInfo
1621 {
1624 public MediaFileStatus nStatus;
1626 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1627 public string szFileName;
1629 public AudioFormat audioFmt;
1631 public VideoFormat videoFmt;
1633 public uint uDurationMSec;
1635 public uint uElapsedMSec;
1636 }
1645 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1646 public struct MediaFilePlayback
1647 {
1652 public uint uOffsetMSec;
1654 public bool bPaused;
1656 public AudioPreprocessor audioPreprocessor;
1657 }
1658
1661 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1662 public struct AudioInputProgress
1663 {
1665 public int nStreamID;
1668 public uint uQueueMSec;
1671 public uint uElapsedMSec;
1672 }
1673
1690 [Flags]
1691 public enum UserRight : uint
1692 {
1695 USERRIGHT_NONE = 0x00000000,
1698 USERRIGHT_MULTI_LOGIN = 0x00000001,
1700 USERRIGHT_VIEW_ALL_USERS = 0x00000002,
1704 USERRIGHT_CREATE_TEMPORARY_CHANNEL = 0x00000004,
1708 USERRIGHT_MODIFY_CHANNELS = 0x00000008,
1711 USERRIGHT_TEXTMESSAGE_BROADCAST = 0x00000010,
1713 USERRIGHT_KICK_USERS = 0x00000020,
1716 USERRIGHT_BAN_USERS = 0x00000040,
1719 USERRIGHT_MOVE_USERS = 0x00000080,
1722 USERRIGHT_OPERATOR_ENABLE = 0x00000100,
1724 USERRIGHT_UPLOAD_FILES = 0x00000200,
1727 USERRIGHT_DOWNLOAD_FILES = 0x00000400,
1730 USERRIGHT_UPDATE_SERVERPROPERTIES = 0x00000800,
1733 USERRIGHT_TRANSMIT_VOICE = 0x00001000,
1736 USERRIGHT_TRANSMIT_VIDEOCAPTURE = 0x00002000,
1739 USERRIGHT_TRANSMIT_DESKTOP = 0x00004000,
1742 USERRIGHT_TRANSMIT_DESKTOPINPUT = 0x00008000,
1745 USERRIGHT_TRANSMIT_MEDIAFILE_AUDIO = 0x00010000,
1748 USERRIGHT_TRANSMIT_MEDIAFILE_VIDEO = 0x00020000,
1751 USERRIGHT_TRANSMIT_MEDIAFILE = USERRIGHT_TRANSMIT_MEDIAFILE_VIDEO | USERRIGHT_TRANSMIT_MEDIAFILE_AUDIO,
1758 USERRIGHT_LOCKED_NICKNAME = 0x00040000,
1761 USERRIGHT_LOCKED_STATUS = 0x00080000,
1764 USERRIGHT_RECORD_VOICE = 0x00100000,
1766 USERRIGHT_VIEW_HIDDEN_CHANNELS = 0x00200000,
1769 USERRIGHT_TEXTMESSAGE_USER = 0x00400000,
1772 USERRIGHT_TEXTMESSAGE_CHANNEL = 0x00800000,
1773
1775 USERRIGHT_ALL = 0xFFFFFFFF & ~USERRIGHT_LOCKED_NICKNAME & ~USERRIGHT_LOCKED_STATUS
1776 }
1777
1784 [Flags]
1785 public enum ServerLogEvent : uint
1786 {
1788 SERVERLOGEVENT_NONE = 0x00000000,
1790 SERVERLOGEVENT_USER_CONNECTED = 0x00000001,
1792 SERVERLOGEVENT_USER_DISCONNECTED = 0x00000002,
1794 SERVERLOGEVENT_USER_LOGGEDIN = 0x00000004,
1796 SERVERLOGEVENT_USER_LOGGEDOUT = 0x00000008,
1798 SERVERLOGEVENT_USER_LOGINFAILED = 0x00000010,
1800 SERVERLOGEVENT_USER_TIMEDOUT = 0x00000020,
1802 SERVERLOGEVENT_USER_KICKED = 0x00000040,
1804 SERVERLOGEVENT_USER_BANNED = 0x00000080,
1806 SERVERLOGEVENT_USER_UNBANNED = 0x00000100,
1808 SERVERLOGEVENT_USER_UPDATED = 0x00000200,
1810 SERVERLOGEVENT_USER_JOINEDCHANNEL = 0x00000400,
1812 SERVERLOGEVENT_USER_LEFTCHANNEL = 0x00000800,
1814 SERVERLOGEVENT_USER_MOVED = 0x00001000,
1816 SERVERLOGEVENT_USER_TEXTMESSAGE_PRIVATE = 0x00002000,
1818 SERVERLOGEVENT_USER_TEXTMESSAGE_CUSTOM = 0x00004000,
1820 SERVERLOGEVENT_USER_TEXTMESSAGE_CHANNEL = 0x00008000,
1822 SERVERLOGEVENT_USER_TEXTMESSAGE_BROADCAST = 0x00010000,
1824 SERVERLOGEVENT_CHANNEL_CREATED = 0x00020000,
1826 SERVERLOGEVENT_CHANNEL_UPDATED = 0x00040000,
1828 SERVERLOGEVENT_CHANNEL_REMOVED = 0x00080000,
1830 SERVERLOGEVENT_FILE_UPLOADED = 0x00100000,
1832 SERVERLOGEVENT_FILE_DOWNLOADED = 0x00200000,
1834 SERVERLOGEVENT_FILE_DELETED = 0x00400000,
1836 SERVERLOGEVENT_SERVER_UPDATED = 0x00800000,
1838 SERVERLOGEVENT_SERVER_SAVECONFIG = 0x01000000,
1839 }
1840
1852 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1853 public struct ServerProperties
1854 {
1856 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1857 public string szServerName;
1860 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1861 public string szMOTD;
1870 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1871 public string szMOTDRaw;
1874 public int nMaxUsers;
1877 public int nMaxLoginAttempts;
1880 public int nMaxLoginsPerIPAddress;
1884 public int nMaxVoiceTxPerSecond;
1889 public int nMaxVideoCaptureTxPerSecond;
1893 public int nMaxMediaFileTxPerSecond;
1897 public int nMaxDesktopTxPerSecond;
1901 public int nMaxTotalTxPerSecond;
1903 public bool bAutoSave;
1905 public int nTcpPort;
1907 public int nUdpPort;
1910 public int nUserTimeout;
1912 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1913 public string szServerVersion;
1915 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1916 public string szServerProtocolVersion;
1925 public int nLoginDelayMSec;
1929 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1930 public string szAccessToken;
1936 public ServerLogEvent uServerLogEvents;
1937 }
1938
1946 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1947 public struct ServerStatistics
1948 {
1951 public long nTotalBytesTX;
1954 public long nTotalBytesRX;
1957 public long nVoiceBytesTX;
1960 public long nVoiceBytesRX;
1963 public long nVideoCaptureBytesTX;
1966 public long nVideoCaptureBytesRX;
1969 public long nMediaFileBytesTX;
1972 public long nMediaFileBytesRX;
1975 public long nDesktopBytesTX;
1978 public long nDesktopBytesRX;
1980 public int nUsersServed;
1982 public int nUsersPeak;
1985 public long nFilesTx;
1988 public long nFilesRx;
1990 public long nUptimeMSec;
1991 }
1992
1998 [Flags]
1999 public enum BanType : uint
2000 {
2002 BANTYPE_NONE = 0x00,
2006 BANTYPE_CHANNEL = 0x01,
2008 BANTYPE_IPADDR = 0x02,
2010 BANTYPE_USERNAME = 0x04
2011 };
2012
2017 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2018 public struct BannedUser
2019 {
2021 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2022 public string szIPAddress;
2024 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2025 public string szChannelPath;
2027 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2028 public string szBanTime;
2030 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2031 public string szNickname;
2033 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2034 public string szUsername;
2036 public BanType uBanTypes;
2038 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2039 public string szOwner;
2040 }
2041
2045 [Flags]
2046 public enum UserType : uint
2047 {
2050 USERTYPE_NONE = 0x0,
2052 USERTYPE_DEFAULT = 0x01,
2054 USERTYPE_ADMIN = 0x02
2055 }
2056
2065 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2066 public struct AbusePrevention
2067 {
2077 public int nCommandsLimit;
2079 public int nCommandsIntervalMSec;
2080 }
2081
2090 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2091 public struct UserAccount
2092 {
2094 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2095 public string szUsername;
2097 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2098 public string szPassword;
2100 public UserType uUserType;
2104 public UserRight uUserRights;
2108 public int nUserData;
2110 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2111 public string szNote;
2116 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2117 public string szInitChannel;
2121 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_CHANNELS_OPERATOR_MAX)]
2122 public int[] autoOperatorChannels;
2126 public int nAudioCodecBpsLimit;
2131 public AbusePrevention abusePrevent;
2134 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2135 public string szLastModified;
2138 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2139 public string szLastLoginTime;
2140 }
2164 [Flags]
2165 public enum Subscription : uint
2166 {
2168 SUBSCRIBE_NONE = 0x00000000,
2171 SUBSCRIBE_USER_MSG = 0x00000001,
2174 SUBSCRIBE_CHANNEL_MSG = 0x00000002,
2177 SUBSCRIBE_BROADCAST_MSG = 0x00000004,
2180 SUBSCRIBE_CUSTOM_MSG = 0x00000008,
2182 SUBSCRIBE_VOICE = 0x00000010,
2184 SUBSCRIBE_VIDEOCAPTURE = 0x00000020,
2186 SUBSCRIBE_DESKTOP = 0x00000040,
2190 SUBSCRIBE_DESKTOPINPUT = 0x00000080,
2193 SUBSCRIBE_MEDIAFILE = 0x00000100,
2196 SUBSCRIBE_INTERCEPT_USER_MSG = 0x00010000,
2199 SUBSCRIBE_INTERCEPT_CHANNEL_MSG = 0x00020000,
2200 /* unused SUBSCRIBE_INTERCEPT_BROADCAST_MSG = 0x00040000 */
2203 SUBSCRIBE_INTERCEPT_CUSTOM_MSG = 0x00080000,
2208 SUBSCRIBE_INTERCEPT_VOICE = 0x00100000,
2213 SUBSCRIBE_INTERCEPT_VIDEOCAPTURE = 0x00200000,
2218 SUBSCRIBE_INTERCEPT_DESKTOP = 0x00400000,
2219 /* unused SUBSCRIBE_INTERCEPT_DESKTOPINPUT = 0x00800000, */
2224 SUBSCRIBE_INTERCEPT_MEDIAFILE = 0x01000000,
2225 }
2226
2230 [Flags]
2231 public enum UserState : uint
2232 {
2234 USERSTATE_NONE = 0x0000000,
2238 USERSTATE_VOICE = 0x00000001,
2240 USERSTATE_MUTE_VOICE = 0x00000002,
2243 USERSTATE_MUTE_MEDIAFILE = 0x00000004,
2248 USERSTATE_DESKTOP = 0x00000008,
2253 USERSTATE_VIDEOCAPTURE = 0x00000010,
2259 USERSTATE_MEDIAFILE_AUDIO = 0x00000020,
2263 USERSTATE_MEDIAFILE_VIDEO = 0x00000040,
2267 USERSTATE_MEDIAFILE = USERSTATE_MEDIAFILE_AUDIO |
2268 USERSTATE_MEDIAFILE_VIDEO
2269 }
2270
2275 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2276 public struct User
2277 {
2281 public int nUserID;
2286 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2287 public string szUsername;
2292 public int nUserData;
2296 public UserType uUserType;
2298 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2299 public string szIPAddress;
2305 public uint uVersion;
2311 public int nChannelID;
2317 public Subscription uLocalSubscriptions;
2323 public Subscription uPeerSubscriptions;
2328 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2329 public string szNickname;
2334 public int nStatusMode;
2339 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2340 public string szStatusMsg;
2343 public UserState uUserState;
2346 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2347 public string szMediaStorageDir;
2353 public int nVolumeVoice;
2359 public int nVolumeMediaFile;
2363 public int nStoppedDelayVoice;
2367 public int nStoppedDelayMediaFile;
2372 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
2373 public float[] soundPositionVoice;
2378 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
2379 public float[] soundPositionMediaFile;
2384 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
2385 public bool[] stereoPlaybackVoice;
2390 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
2391 public bool[] stereoPlaybackMediaFile;
2395 public int nBufferMSecVoice;
2399 public int nBufferMSecMediaFile;
2403 public int nActiveAdaptiveDelayMSec;
2407 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2408 public string szClientName;
2409 }
2410
2415 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2416 public struct UserStatistics
2417 {
2419 public long nVoicePacketsRecv;
2421 public long nVoicePacketsLost;
2424 public long nVideoCapturePacketsRecv;
2426 public long nVideoCaptureFramesRecv;
2429 public long nVideoCaptureFramesLost;
2432 public long nVideoCaptureFramesDropped;
2434 public long nMediaFileAudioPacketsRecv;
2436 public long nMediaFileAudioPacketsLost;
2439 public long nMediaFileVideoPacketsRecv;
2441 public long nMediaFileVideoFramesRecv;
2444 public long nMediaFileVideoFramesLost;
2447 public long nMediaFileVideoFramesDropped;
2448 }
2449
2458 public enum TextMsgType : uint
2459 {
2462 MSGTYPE_USER = 1,
2467 MSGTYPE_CHANNEL = 2,
2470 MSGTYPE_BROADCAST = 3,
2473 MSGTYPE_CUSTOM = 4
2474 }
2475
2483 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2484 public struct TextMessage
2485 {
2487 public TextMsgType nMsgType;
2489 public int nFromUserID;
2491 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2492 public string szFromUsername;
2494 public int nToUserID;
2497 public int nChannelID;
2500 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2501 public string szMessage;
2504 public bool bMore;
2505 }
2513 [Flags]
2514 public enum ChannelType : uint
2515 {
2518 CHANNEL_DEFAULT = 0x0000,
2521 CHANNEL_PERMANENT = 0x0001,
2523 CHANNEL_SOLO_TRANSMIT = 0x0002,
2534 CHANNEL_CLASSROOM = 0x0004,
2539 CHANNEL_OPERATOR_RECVONLY = 0x0008,
2542 CHANNEL_NO_VOICEACTIVATION = 0x0010,
2544 CHANNEL_NO_RECORDING = 0x0020,
2547 CHANNEL_HIDDEN = 0x0040,
2548 }
2549
2561 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2562 public struct Channel
2563 {
2566 public int nParentID;
2569 public int nChannelID;
2571 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2572 public string szName;
2574 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2575 public string szTopic;
2579 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2580 public string szPassword;
2583 public bool bPassword;
2585 public ChannelType uChannelType;
2589 public int nUserData;
2591 public long nDiskQuota;
2594 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2595 public string szOpPassword;
2597 public int nMaxUsers;
2599 public AudioCodec audiocodec;
2602 public AudioConfig audiocfg;
2658 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_TRANSMITUSERS_MAX * 2)]
2659 public int[] transmitUsers;
2664 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_TRANSMITQUEUE_MAX)]
2665 public int[] transmitUsersQueue;
2666
2674 public int nTransmitUsersQueueDelayMSec;
2675
2679 public int nTimeOutTimerVoiceMSec;
2680
2684 public int nTimeOutTimerMediaFileMSec;
2685
2688 public void AddTransmitUser(int nUserID, StreamType uStreamType)
2689 {
2690 int i;
2691 for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2692 {
2693 if (transmitUsers[i * 2] == 0 || transmitUsers[i * 2] == nUserID)
2694 break;
2695 }
2696 if (i < TeamTalkBase.TT_TRANSMITUSERS_MAX)
2697 {
2698 transmitUsers[i * 2] = nUserID;
2699 transmitUsers[i * 2 + 1] |= (int)uStreamType;
2700 }
2701 }
2704 public StreamType GetTransmitStreamTypes(int nUserID)
2705 {
2706 int i;
2707 for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2708 {
2709 if (transmitUsers[i * 2] == nUserID)
2710 return (StreamType)transmitUsers[i * 2 + 1];
2711 }
2712 return StreamType.STREAMTYPE_NONE;
2713 }
2715 public int GetTransmitUserCount()
2716 {
2717 int i;
2718 for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2719 {
2720 if (transmitUsers[i * 2] == 0)
2721 break;
2722 }
2723 return i;
2724 }
2726 public void RemoveTransmitUser(int nUserID, StreamType uStreamType)
2727 {
2728 int i;
2729 for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2730 {
2731 if (transmitUsers[i * 2] == nUserID)
2732 break;
2733 }
2734 if (i < TeamTalkBase.TT_TRANSMITUSERS_MAX)
2735 {
2736 transmitUsers[i * 2] = nUserID;
2737 transmitUsers[i * 2 + 1] &= (int)~uStreamType;
2738
2739 if (transmitUsers[i * 2 + 1] == (int)StreamType.STREAMTYPE_NONE)
2740 {
2741 for (; i < TeamTalkBase.TT_TRANSMITUSERS_MAX - 1; i++)
2742 {
2743 transmitUsers[i * 2] = transmitUsers[(i + 1) * 2 + 1];
2744 transmitUsers[i * 2 + 1] = transmitUsers[(i + 1) * 2 + 1];
2745 }
2746 }
2747 }
2748 }
2749 }
2750
2753 public enum FileTransferStatus : uint
2754 {
2756 FILETRANSFER_CLOSED = 0,
2758 FILETRANSFER_ERROR = 1,
2760 FILETRANSFER_ACTIVE = 2,
2762 FILETRANSFER_FINISHED = 3
2763 }
2764
2768 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2769 public struct FileTransfer
2770 {
2772 public FileTransferStatus nStatus;
2774 public int nTransferID;
2776 public int nChannelID;
2778 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2779 public string szLocalFilePath;
2781 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2782 public string szRemoteFileName;
2784 public long nFileSize;
2786 public long nTransferred;
2788 public bool bInbound;
2789 }
2790
2794 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2795 public struct RemoteFile
2796 {
2798 public int nChannelID;
2800 public int nFileID;
2802 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2803 public string szFileName;
2805 public long nFileSize;
2807 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2808 public string szUsername;
2811 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2812 public string szUploadTime;
2813 }
2824 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2825 public struct EncryptionContext
2826 {
2832 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2833 public string szCertificateFile;
2835 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2836 public string szPrivateKeyFile;
2841 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2842 public string szCAFile;
2845 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2846 public string szCADir;
2853 public bool bVerifyPeer;
2864 public bool bVerifyClientOnce;
2872 public int nVerifyDepth;
2873 }
2874
2882 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2883 public struct ClientKeepAlive
2884 {
2895 public int nConnectionLostMSec;
2899 public int nTcpKeepAliveIntervalMSec;
2905 public int nUdpKeepAliveIntervalMSec;
2911 public int nUdpKeepAliveRTXMSec;
2918 public int nUdpConnectRTXMSec;
2926 public int nUdpConnectTimeoutMSec;
2927 }
2928
2933 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2934 public struct ClientStatistics
2935 {
2937 public long nUdpBytesSent;
2939 public long nUdpBytesRecv;
2941 public long nVoiceBytesSent;
2943 public long nVoiceBytesRecv;
2945 public long nVideoCaptureBytesSent;
2947 public long nVideoCaptureBytesRecv;
2949 public long nMediaFileAudioBytesSent;
2951 public long nMediaFileAudioBytesRecv;
2953 public long nMediaFileVideoBytesSent;
2955 public long nMediaFileVideoBytesRecv;
2957 public long nDesktopBytesSent;
2959 public long nDesktopBytesRecv;
2963 public int nUdpPingTimeMs;
2967 public int nTcpPingTimeMs;
2970 public int nTcpServerSilenceSec;
2973 public int nUdpServerSilenceSec;
2985 public int nSoundInputDeviceDelayMSec;
2986 }
2987
2993 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2994 public struct JitterConfig
2995 {
2997 public int nFixedDelayMSec;
2999 public bool bUseAdativeDejitter;
3002 public int nMaxAdaptiveDelayMSec;
3009 public int nActiveAdaptiveDelayMSec;
3010 }
3011
3012
3022 public enum ClientError : uint
3023 {
3025 CMDERR_SUCCESS = 0,
3026 SUCCESS = 0,
3027
3028 /* COMMAND ERRORS 1000-1999 ARE DUE TO INVALID OR UNSUPPORTED
3029 * COMMANDS */
3030
3032 CMDERR_SYNTAX_ERROR = 1000,
3037 CMDERR_UNKNOWN_COMMAND = 1001,
3040 CMDERR_MISSING_PARAMETER = 1002,
3043 CMDERR_INCOMPATIBLE_PROTOCOLS = 1003,
3048 CMDERR_UNKNOWN_AUDIOCODEC = 1004,
3051 CMDERR_INVALID_USERNAME = 1005,
3052
3053 /* COMMAND ERRORS 2000-2999 ARE DUE TO INSUFFICIENT RIGHTS */
3054
3059 CMDERR_INCORRECT_SERVER_PASSWORD = 2000,
3065 CMDERR_INCORRECT_CHANNEL_PASSWORD = 2001,
3071 CMDERR_INVALID_ACCOUNT = 2002,
3077 CMDERR_MAX_SERVER_USERS_EXCEEDED = 2003,
3083 CMDERR_MAX_CHANNEL_USERS_EXCEEDED = 2004,
3088 CMDERR_SERVER_BANNED = 2005,
3120 CMDERR_NOT_AUTHORIZED = 2006,
3127 CMDERR_MAX_DISKUSAGE_EXCEEDED = 2008,
3128
3134 CMDERR_INCORRECT_OP_PASSWORD = 2010,
3135
3141 CMDERR_AUDIOCODEC_BITRATE_LIMIT_EXCEEDED = 2011,
3142
3148 CMDERR_MAX_LOGINS_PER_IPADDRESS_EXCEEDED = 2012,
3149
3152 CMDERR_MAX_CHANNELS_EXCEEDED = 2013,
3153
3158 CMDERR_COMMAND_FLOOD = 2014,
3159
3165 CMDERR_CHANNEL_BANNED = 2015,
3166
3171 CMDERR_MAX_FILETRANSFERS_EXCEEDED = 2016,
3172
3173 /* COMMAND ERRORS 3000-3999 ARE DUE TO INVALID STATE OF CLIENT INSTANCE */
3174
3180 CMDERR_NOT_LOGGEDIN = 3000,
3181
3185 CMDERR_ALREADY_LOGGEDIN = 3001,
3189 CMDERR_NOT_IN_CHANNEL = 3002,
3194 CMDERR_ALREADY_IN_CHANNEL = 3003,
3198 CMDERR_CHANNEL_ALREADY_EXISTS = 3004,
3216 CMDERR_CHANNEL_NOT_FOUND = 3005,
3227 CMDERR_USER_NOT_FOUND = 3006,
3232 CMDERR_BAN_NOT_FOUND = 3007,
3237 CMDERR_FILETRANSFER_NOT_FOUND = 3008,
3242 CMDERR_OPENFILE_FAILED = 3009,
3247 CMDERR_ACCOUNT_NOT_FOUND = 3010,
3252 CMDERR_FILE_NOT_FOUND = 3011,
3257 CMDERR_FILE_ALREADY_EXISTS = 3012,
3262 CMDERR_FILESHARING_DISABLED = 3013,
3263
3267 CMDERR_CHANNEL_HAS_USERS = 3015,
3268
3272 CMDERR_LOGINSERVICE_UNAVAILABLE = 3016,
3273
3278 CMDERR_CHANNEL_CANNOT_BE_HIDDEN = 3017,
3279
3280 /* ERRORS 10000-10999 ARE NOT COMMAND ERRORS BUT INSTEAD
3281 * ERRORS IN THE CLIENT INSTANCE. */
3282
3287 INTERR_SNDINPUT_FAILURE = 10000,
3292 INTERR_SNDOUTPUT_FAILURE = 10001,
3296 INTERR_AUDIOCODEC_INIT_FAILED = 10002,
3298 INTERR_SPEEXDSP_INIT_FAILED = 10003,
3306 INTERR_AUDIOPREPROCESSOR_INIT_FAILED = 10003,
3314 INTERR_TTMESSAGE_QUEUE_OVERFLOW = 10004,
3321 INTERR_SNDEFFECT_FAILURE = 10005,
3322 }
3323
3324 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
3325 public struct ClientErrorMsg
3326 {
3328 public int nErrorNo;
3330 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
3331 public string szErrorMsg;
3332 }
3333
3343 public enum ClientEvent : uint
3344 {
3345 CLIENTEVENT_NONE = 0,
3357 CLIENTEVENT_CON_SUCCESS = CLIENTEVENT_NONE + 10,
3367 CLIENTEVENT_CON_FAILED = CLIENTEVENT_NONE + 20,
3383 CLIENTEVENT_CON_LOST = CLIENTEVENT_NONE + 30,
3394 CLIENTEVENT_CON_MAX_PAYLOAD_UPDATED = CLIENTEVENT_NONE + 40,
3408 CLIENTEVENT_CMD_PROCESSING = CLIENTEVENT_NONE + 200,
3422 CLIENTEVENT_CMD_ERROR = CLIENTEVENT_NONE + 210,
3434 CLIENTEVENT_CMD_SUCCESS = CLIENTEVENT_NONE + 220,
3452 CLIENTEVENT_CMD_MYSELF_LOGGEDIN = CLIENTEVENT_NONE + 230,
3461 CLIENTEVENT_CMD_MYSELF_LOGGEDOUT = CLIENTEVENT_NONE + 240,
3471 CLIENTEVENT_CMD_MYSELF_KICKED = CLIENTEVENT_NONE + 250,
3482 CLIENTEVENT_CMD_USER_LOGGEDIN = CLIENTEVENT_NONE + 260,
3496 CLIENTEVENT_CMD_USER_LOGGEDOUT = CLIENTEVENT_NONE + 270,
3505 CLIENTEVENT_CMD_USER_UPDATE = CLIENTEVENT_NONE + 280,
3514 CLIENTEVENT_CMD_USER_JOINED = CLIENTEVENT_NONE + 290,
3521 CLIENTEVENT_CMD_USER_LEFT = CLIENTEVENT_NONE + 300,
3531 CLIENTEVENT_CMD_USER_TEXTMSG = CLIENTEVENT_NONE + 310,
3540 CLIENTEVENT_CMD_CHANNEL_NEW = CLIENTEVENT_NONE + 320,
3549 CLIENTEVENT_CMD_CHANNEL_UPDATE = CLIENTEVENT_NONE + 330,
3559 CLIENTEVENT_CMD_CHANNEL_REMOVE = CLIENTEVENT_NONE + 340,
3570 CLIENTEVENT_CMD_SERVER_UPDATE = CLIENTEVENT_NONE + 350,
3579 CLIENTEVENT_CMD_SERVERSTATISTICS = CLIENTEVENT_NONE + 360,
3591 CLIENTEVENT_CMD_FILE_NEW = CLIENTEVENT_NONE + 370,
3598 CLIENTEVENT_CMD_FILE_REMOVE = CLIENTEVENT_NONE + 380,
3607 CLIENTEVENT_CMD_USERACCOUNT = CLIENTEVENT_NONE + 390,
3616 CLIENTEVENT_CMD_BANNEDUSER = CLIENTEVENT_NONE + 400,
3636 CLIENTEVENT_USER_STATECHANGE = CLIENTEVENT_NONE + 500,
3649 CLIENTEVENT_USER_VIDEOCAPTURE = CLIENTEVENT_NONE + 510,
3662 CLIENTEVENT_USER_MEDIAFILE_VIDEO = CLIENTEVENT_NONE + 520,
3677 CLIENTEVENT_USER_DESKTOPWINDOW = CLIENTEVENT_NONE + 530,
3688 CLIENTEVENT_USER_DESKTOPCURSOR = CLIENTEVENT_NONE + 540,
3711 CLIENTEVENT_USER_DESKTOPINPUT = CLIENTEVENT_NONE + 550,
3724 CLIENTEVENT_USER_RECORD_MEDIAFILE = CLIENTEVENT_NONE + 560,
3738 CLIENTEVENT_USER_AUDIOBLOCK = CLIENTEVENT_NONE + 570,
3752 CLIENTEVENT_INTERNAL_ERROR = CLIENTEVENT_NONE + 1000,
3766 CLIENTEVENT_VOICE_ACTIVATION = CLIENTEVENT_NONE + 1010,
3777 CLIENTEVENT_HOTKEY = CLIENTEVENT_NONE + 1020,
3796 CLIENTEVENT_HOTKEY_TEST = CLIENTEVENT_NONE + 1030,
3813 CLIENTEVENT_FILETRANSFER = CLIENTEVENT_NONE + 1040,
3829 CLIENTEVENT_DESKTOPWINDOW_TRANSFER = CLIENTEVENT_NONE + 1050,
3842 CLIENTEVENT_STREAM_MEDIAFILE = CLIENTEVENT_NONE + 1060,
3854 CLIENTEVENT_LOCAL_MEDIAFILE = CLIENTEVENT_NONE + 1070,
3876 CLIENTEVENT_AUDIOINPUT = CLIENTEVENT_NONE + 1080,
3896 CLIENTEVENT_USER_FIRSTVOICESTREAMPACKET = CLIENTEVENT_NONE + 1090,
3897 }
3898
3899
3900 /* List of structures used internally by TeamTalkBase. */
3901 public enum TTType : uint
3902 {
3903 __NONE = 0,
3904 __AUDIOCODEC = 1,
3905 __BANNEDUSER = 2,
3906 __VIDEOFORMAT = 3,
3907 __OPUSCODEC = 4,
3908 __CHANNEL = 5,
3909 __CLIENTSTATISTICS = 6,
3910 __REMOTEFILE = 7,
3911 __FILETRANSFER = 8,
3912 __MEDIAFILESTATUS = 9,
3913 __SERVERPROPERTIES = 10,
3914 __SERVERSTATISTICS = 11,
3915 __SOUNDDEVICE = 12,
3916 __SPEEXCODEC = 13,
3917 __TEXTMESSAGE = 14,
3918 __WEBMVP8CODEC = 15,
3919 __TTMESSAGE = 16,
3920 __USER = 17,
3921 __USERACCOUNT = 18,
3922 __USERSTATISTICS = 19,
3923 __VIDEOCAPTUREDEVICE = 20,
3924 __VIDEOCODEC = 21,
3925 __AUDIOCONFIG = 22,
3926 __SPEEXVBRCODEC = 23,
3927 __VIDEOFRAME = 24,
3928 __AUDIOBLOCK = 25,
3929 __AUDIOFORMAT = 26,
3930 __MEDIAFILEINFO = 27,
3931 __CLIENTERRORMSG = 28,
3932 __TTBOOL = 29,
3933 __INT32 = 30,
3934 __DESKTOPINPUT = 31,
3935 __SPEEXDSP = 32,
3936 __STREAMTYPE = 33,
3937 __AUDIOPREPROCESSORTYPE = 34,
3938 __AUDIOPREPROCESSOR = 35,
3939 __TTAUDIOPREPROCESSOR = 36,
3940 __MEDIAFILEPLAYBACK = 37,
3941 __CLIENTKEEPALIVE = 38,
3942 __UINT32 = 39,
3943 __AUDIOINPUTPROGRESS = 40,
3944 __JITTERCONFIG = 41,
3945 __WEBRTCAUDIOPREPROCESSOR = 42,
3946 __ENCRYPTIONCONTEXT = 43,
3947 __SOUNDDEVICEEFFECTS = 44,
3948 __DESKTOPWINDOW = 45,
3949 __ABUSEPREVENTION = 46,
3950 }
3951
3962 [StructLayout(LayoutKind.Sequential)]
3963 public struct TTMessage
3964 {
3966 public ClientEvent nClientEvent;
3968 public int nSource;
3970 public TTType ttType;
3972 public uint uReserved;
3973 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TTDLL.SIZEOF_TTMESSAGE_DATA)]
3974 public byte[] data;
3975 //UnionData data;
3976
3977 public object DataToObject()
3978 {
3979 switch (ttType)
3980 {
3981 case TTType.__CHANNEL:
3982 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(Channel));
3983 case TTType.__CLIENTERRORMSG:
3984 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ClientErrorMsg));
3985 case TTType.__DESKTOPINPUT:
3986 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(DesktopInput));
3987 case TTType.__FILETRANSFER:
3988 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(FileTransfer));
3989 case TTType.__MEDIAFILEINFO:
3990 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(MediaFileInfo));
3991 case TTType.__REMOTEFILE:
3992 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(RemoteFile));
3993 case TTType.__SERVERPROPERTIES:
3994 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ServerProperties));
3995 case TTType.__SERVERSTATISTICS:
3996 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ServerStatistics));
3997 case TTType.__TEXTMESSAGE:
3998 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(TextMessage));
3999 case TTType.__USER:
4000 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(User));
4001 case TTType.__USERACCOUNT:
4002 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(UserAccount));
4003 case TTType.__BANNEDUSER :
4004 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(BannedUser));
4005 case TTType.__TTBOOL:
4006 return Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this)) != 0;
4007 case TTType.__INT32:
4008 return Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this));
4009 case TTType.__STREAMTYPE :
4010 return (StreamType)Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this));
4011 case TTType.__AUDIOINPUTPROGRESS :
4012 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(AudioInputProgress));
4013 default:
4014 return null;
4015 }
4016 }
4017 }
4018
4019 [StructLayout(LayoutKind.Explicit, Size = 5224)]
4020 struct UnionData
4021 {
4022 [FieldOffset(0)]
4023 public ClientErrorMsg clienterrormsg;
4024 [FieldOffset(0)]
4025 public Channel channel;
4026 [FieldOffset(0)]
4027 public DesktopInput desktopinput;
4028 [FieldOffset(0)]
4029 public FileTransfer filetransfer;
4030 [FieldOffset(0)]
4031 public MediaFileInfo mediafileinfo;
4032 [FieldOffset(0)]
4033 public RemoteFile remotefile;
4034 [FieldOffset(0)]
4035 public ServerProperties serverproperties;
4036 [FieldOffset(0)]
4037 public TextMessage textmessage;
4038 [FieldOffset(0)]
4039 public User user;
4040 [FieldOffset(0)]
4041 public UserAccount useraccount;
4042 [FieldOffset(0)]
4043 public bool bActive;
4044 [FieldOffset(0)]
4045 public int nBytesRemain;
4046 [FieldOffset(0)]
4047 public int nStreamID;
4048 [FieldOffset(0)]
4049 public int nPayloadSize;
4050 }
4051
4069 [Flags]
4070 public enum ClientFlag : uint
4071 {
4074 CLIENT_CLOSED = 0x00000000,
4078 CLIENT_SNDINPUT_READY = 0x00000001,
4082 CLIENT_SNDOUTPUT_READY = 0x00000002,
4088 CLIENT_SNDINOUTPUT_DUPLEX = 0x00000004,
4095 CLIENT_SNDINPUT_VOICEACTIVATED = 0x00000008,
4102 CLIENT_SNDINPUT_VOICEACTIVE = 0x00000010,
4105 CLIENT_SNDOUTPUT_MUTE = 0x00000020,
4111 CLIENT_SNDOUTPUT_AUTO3DPOSITION = 0x00000040,
4115 CLIENT_VIDEOCAPTURE_READY = 0x00000080,
4118 CLIENT_TX_VOICE = 0x00000100,
4121 CLIENT_TX_VIDEOCAPTURE = 0x00000200,
4127 CLIENT_TX_DESKTOP = 0x00000400,
4132 CLIENT_DESKTOP_ACTIVE = 0x00000800,
4136 CLIENT_MUX_AUDIOFILE = 0x00001000,
4139 CLIENT_CONNECTING = 0x00002000,
4144 CLIENT_CONNECTED = 0x00004000,
4147 CLIENT_CONNECTION = CLIENT_CONNECTING | CLIENT_CONNECTED,
4151 CLIENT_AUTHORIZED = 0x00008000,
4156 CLIENT_STREAM_AUDIO = 0x00010000,
4161 CLIENT_STREAM_VIDEO = 0x00020000
4162 }
4163
4171 public abstract class TeamTalkBase : IDisposable
4172 {
4181 public const int TT_STRLEN = 512;
4182
4184 public const int TT_USERID_MAX = 0xFFF;
4185
4188 public const int TT_CHANNELID_MAX = 0xFFF;
4189
4193 public const int TT_VIDEOFORMATS_MAX = 1024;
4194
4200 public const int TT_TRANSMITUSERS_MAX = 128;
4201
4209 public const int TT_CLASSROOM_FREEFORALL = 0xFFF;
4210
4213 public const int TT_CLASSROOM_USERID_INDEX = 0;
4214
4217 public const int TT_CLASSROOM_STREAMTYPE_INDEX = 1;
4218
4221 public const int TT_TRANSMITUSERS_FREEFORALL = 0xFFF;
4222
4225 public const int TT_TRANSMITUSERS_USERID_INDEX = 0;
4226
4229 public const int TT_TRANSMITUSERS_STREAMTYPE_INDEX = 1;
4230
4244 public const int TT_LOCAL_USERID = 0;
4245
4253 public const int TT_LOCAL_TX_USERID = 0x1002;
4254
4262 public const int TT_MUXED_USERID = 0x1001; /* TT_USERID_MAX + 2 */
4263
4268 public const int TT_CHANNELS_OPERATOR_MAX = 16;
4269
4273 public const int TT_TRANSMITQUEUE_MAX = 16;
4274
4277 public const int TT_SAMPLERATES_MAX = 16;
4278
4283 public const int TT_DESKTOPINPUT_MAX = 16;
4284
4293 public const uint TT_MEDIAPLAYBACK_OFFSET_IGNORE = 0xFFFFFFFF;
4294
4295
4297 public static string GetVersion() { return Marshal.PtrToStringAuto(TTDLL.TT_GetVersion()); }
4298
4309 protected TeamTalkBase(bool poll_based)
4310 {
4311 Assembly assembly = Assembly.GetExecutingAssembly();
4312 AssemblyName name = assembly.GetName();
4313 Version dllversion = new Version(Marshal.PtrToStringUni((c_tt.TTDLL.TT_GetVersion())));
4314 if (!name.Version.Equals(dllversion))
4315 {
4316 string errmsg = String.Format("Invalid {2} version loaded. {2} is version {0} and {3} is version {1}",
4317 dllversion.ToString(), name.Version.ToString(), c_tt.TTDLL.dllname, c_tt.TTDLL.mgtdllname);
4318
4319 // throw new Exception(errmsg);
4320
4321 System.Diagnostics.Debug.WriteLine(errmsg);
4322 }
4323
4324 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOCODEC) == Marshal.SizeOf(new AudioCodec()));
4325 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__BANNEDUSER) == Marshal.SizeOf(new BannedUser()));
4326 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOFORMAT) == Marshal.SizeOf(new VideoFormat()));
4327 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__OPUSCODEC) == Marshal.SizeOf(new OpusCodec()));
4328 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CHANNEL) == Marshal.SizeOf(new Channel()));
4329 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTSTATISTICS) == Marshal.SizeOf(new ClientStatistics()));
4330 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__REMOTEFILE) == Marshal.SizeOf(new RemoteFile()));
4331 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__FILETRANSFER) == Marshal.SizeOf(new FileTransfer()));
4332 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILESTATUS) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(MediaFileStatus))));
4333 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SERVERPROPERTIES) == Marshal.SizeOf(new ServerProperties()));
4334 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SERVERSTATISTICS) == Marshal.SizeOf(new ServerStatistics()));
4335 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SOUNDDEVICE) == Marshal.SizeOf(new SoundDevice()));
4336 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXCODEC) == Marshal.SizeOf(new SpeexCodec()));
4337 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TEXTMESSAGE) == Marshal.SizeOf(new TextMessage()));
4338 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__WEBMVP8CODEC) == Marshal.SizeOf(new WebMVP8Codec()));
4339 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TTMESSAGE) == Marshal.SizeOf(new TTMessage()));
4340 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USER) == Marshal.SizeOf(new User()));
4341 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USERACCOUNT) == Marshal.SizeOf(new UserAccount()));
4342 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USERSTATISTICS) == Marshal.SizeOf(new UserStatistics()));
4343 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOCAPTUREDEVICE) == Marshal.SizeOf(new VideoCaptureDevice()));
4344 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOCODEC) == Marshal.SizeOf(new VideoCodec()));
4345 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOCONFIG) == Marshal.SizeOf(new AudioConfig()));
4346 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXVBRCODEC) == Marshal.SizeOf(new SpeexVBRCodec()));
4347 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOFRAME) == Marshal.SizeOf(new VideoFrame()));
4348 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOBLOCK) == Marshal.SizeOf(new AudioBlock()));
4349 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOFORMAT) == Marshal.SizeOf(new AudioFormat()));
4350 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILEINFO) == Marshal.SizeOf(new MediaFileInfo()));
4351 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTERRORMSG) == Marshal.SizeOf(new ClientErrorMsg()));
4352 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__DESKTOPINPUT) == Marshal.SizeOf(new DesktopInput()));
4353 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXDSP) == Marshal.SizeOf(new SpeexDSP()));
4354 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__STREAMTYPE) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(StreamType))));
4355 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOPREPROCESSORTYPE) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(AudioPreprocessorType))));
4356 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__WEBRTCAUDIOPREPROCESSOR) == Marshal.SizeOf(new WebRTCAudioPreprocessor()));
4357 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TTAUDIOPREPROCESSOR) == Marshal.SizeOf(new TTAudioPreprocessor()));
4358 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOPREPROCESSOR) == Marshal.SizeOf(new AudioPreprocessor()));
4359 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILEPLAYBACK) == Marshal.SizeOf(new MediaFilePlayback()));
4360 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTKEEPALIVE) == Marshal.SizeOf(new ClientKeepAlive()));
4361 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOINPUTPROGRESS) == Marshal.SizeOf(new AudioInputProgress()));
4362 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__JITTERCONFIG) == Marshal.SizeOf(new JitterConfig()));
4363 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__ENCRYPTIONCONTEXT) == Marshal.SizeOf(new EncryptionContext()));
4364
4365 if (poll_based)
4366 m_ttInst = TTDLL.TT_InitTeamTalkPoll();
4367 else
4368 {
4369 m_eventhandler = new MyEventHandler(this);
4370 #if PocketPC
4371 IntPtr hWnd = m_eventhandler.Hwnd;
4372 #else
4373 m_eventhandler.CreateControl();
4374 IntPtr hWnd = m_eventhandler.Handle;
4375 #endif
4376 m_ttInst = TTDLL.TT_InitTeamTalk(hWnd, MyEventHandler.WM_TEAMTALK_CLIENTEVENT);
4377 }
4378 }
4379
4384 ~TeamTalkBase()
4385 {
4386 DeleteMe();
4387 }
4388
4389
4390 #region IDisposable Members
4391
4392 public void Dispose()
4393 {
4394 DeleteMe();
4395 }
4396
4397 private void DeleteMe()
4398 {
4399 if (m_ttInst != IntPtr.Zero)
4400 {
4401 TTDLL.TT_CloseTeamTalk(m_ttInst);
4402 m_ttInst = IntPtr.Zero;
4403 }
4404 }
4405
4406 #endregion
4407
4425 public bool GetMessage(ref TTMessage pMsg, int nWaitMs)
4426 {
4427 return TTDLL.TT_GetMessage(m_ttInst, ref pMsg, ref nWaitMs);
4428 }
4429
4456 public bool PumpMessage(ClientEvent nClientEvent,
4457 int nIdentifier)
4458 {
4459 return TTDLL.TT_PumpMessage(m_ttInst, nClientEvent, nIdentifier);
4460 }
4461
4470 public BearWare.ClientFlag GetFlags()
4471 {
4472 return TTDLL.TT_GetFlags(m_ttInst);
4473 }
4474
4478 public ClientFlag Flags
4479 {
4480 get { return GetFlags(); }
4481 }
4482
4492 public static bool SetLicenseInformation(string szRegName, string szRegKey)
4493 {
4494 return TTDLL.TT_SetLicenseInformation(szRegName, szRegKey);
4495 }
4496
4501 public void ProcessMsg(TTMessage msg)
4502 {
4503 switch (msg.nClientEvent)
4504 {
4505 case ClientEvent.CLIENTEVENT_CON_SUCCESS:
4506 if(OnConnectionSuccess != null)
4507 OnConnectionSuccess();
4508 break;
4509 case ClientEvent.CLIENTEVENT_CON_FAILED:
4510 if (OnConnectionFailed != null)
4511 OnConnectionFailed();
4512 break;
4513 case ClientEvent.CLIENTEVENT_CON_LOST:
4514 if (OnConnectionLost != null)
4515 OnConnectionLost();
4516 break;
4517 case ClientEvent.CLIENTEVENT_CON_MAX_PAYLOAD_UPDATED :
4518 if (OnConnectionMaxPayloadUpdated != null)
4519 OnConnectionMaxPayloadUpdated((int)msg.DataToObject());
4520 break;
4521 case ClientEvent.CLIENTEVENT_CMD_PROCESSING:
4522 if (OnCmdProcessing != null)
4523 OnCmdProcessing(msg.nSource, (bool)msg.DataToObject());
4524 break;
4525 case ClientEvent.CLIENTEVENT_CMD_ERROR:
4526 if (OnCmdError != null)
4527 OnCmdError((int)msg.nSource, (ClientErrorMsg)msg.DataToObject());
4528 break;
4529 case ClientEvent.CLIENTEVENT_CMD_SUCCESS :
4530 if (OnCmdSuccess != null)
4531 OnCmdSuccess((int)msg.nSource);
4532 break;
4533 case ClientEvent.CLIENTEVENT_CMD_MYSELF_LOGGEDIN:
4534 if (OnCmdMyselfLoggedIn != null)
4535 OnCmdMyselfLoggedIn((int)msg.nSource, (UserAccount)msg.DataToObject());
4536 break;
4537 case ClientEvent.CLIENTEVENT_CMD_MYSELF_LOGGEDOUT:
4538 if (OnCmdMyselfLoggedOut != null)
4539 OnCmdMyselfLoggedOut();
4540 break;
4541 case ClientEvent.CLIENTEVENT_CMD_MYSELF_KICKED:
4542 if (msg.ttType == TTType.__USER)
4543 {
4544 if (OnCmdMyselfKicked != null)
4545 OnCmdMyselfKicked((User)msg.DataToObject());
4546 }
4547 else if (OnCmdMyselfKicked != null)
4548 OnCmdMyselfKicked(new User());
4549 break;
4550 case ClientEvent.CLIENTEVENT_CMD_USER_LOGGEDIN:
4551 if (OnCmdUserLoggedIn != null)
4552 OnCmdUserLoggedIn((User)msg.DataToObject());
4553 break;
4554 case ClientEvent.CLIENTEVENT_CMD_USER_LOGGEDOUT:
4555 if (OnCmdUserLoggedOut != null)
4556 OnCmdUserLoggedOut((User)msg.DataToObject());
4557 break;
4558 case ClientEvent.CLIENTEVENT_CMD_USER_UPDATE:
4559 if (OnCmdUserUpdate != null)
4560 OnCmdUserUpdate((User)msg.DataToObject());
4561 break;
4562 case ClientEvent.CLIENTEVENT_CMD_USER_JOINED:
4563 if (OnCmdUserJoinedChannel != null)
4564 OnCmdUserJoinedChannel((User)msg.DataToObject());
4565 break;
4566 case ClientEvent.CLIENTEVENT_CMD_USER_LEFT:
4567 if (OnCmdUserLeftChannel != null)
4568 OnCmdUserLeftChannel((User)msg.DataToObject());
4569 break;
4570 case ClientEvent.CLIENTEVENT_CMD_USER_TEXTMSG:
4571 if (OnCmdUserTextMessage != null)
4572 OnCmdUserTextMessage((TextMessage)msg.DataToObject());
4573 break;
4574 case ClientEvent.CLIENTEVENT_CMD_CHANNEL_NEW:
4575 if (OnCmdChannelNew != null)
4576 OnCmdChannelNew((Channel)msg.DataToObject());
4577 break;
4578 case ClientEvent.CLIENTEVENT_CMD_CHANNEL_UPDATE:
4579 if (OnCmdChannelUpdate != null)
4580 OnCmdChannelUpdate((Channel)msg.DataToObject());
4581 break;
4582 case ClientEvent.CLIENTEVENT_CMD_CHANNEL_REMOVE:
4583 if (OnCmdChannelRemove != null)
4584 OnCmdChannelRemove((Channel)msg.DataToObject());
4585 break;
4586 case ClientEvent.CLIENTEVENT_CMD_SERVER_UPDATE:
4587 if (OnCmdServerUpdate != null)
4588 OnCmdServerUpdate((ServerProperties)msg.DataToObject());
4589 break;
4590 case ClientEvent.CLIENTEVENT_CMD_SERVERSTATISTICS :
4591 if (OnCmdServerStatistics != null)
4592 OnCmdServerStatistics((ServerStatistics)msg.DataToObject());
4593 break;
4594 case ClientEvent.CLIENTEVENT_CMD_FILE_NEW:
4595 if (OnCmdFileNew != null)
4596 OnCmdFileNew((RemoteFile)msg.DataToObject());
4597 break;
4598 case ClientEvent.CLIENTEVENT_CMD_FILE_REMOVE:
4599 if (OnCmdFileRemove != null)
4600 OnCmdFileRemove((RemoteFile)msg.DataToObject());
4601 break;
4602 case ClientEvent.CLIENTEVENT_CMD_USERACCOUNT :
4603 if (OnCmdUserAccount != null)
4604 OnCmdUserAccount((UserAccount)msg.DataToObject());
4605 break;
4606 case ClientEvent.CLIENTEVENT_CMD_BANNEDUSER :
4607 if (OnCmdBannedUser != null)
4608 OnCmdBannedUser((BannedUser)msg.DataToObject());
4609 break;
4610
4611 case ClientEvent.CLIENTEVENT_USER_STATECHANGE :
4612 if (OnUserStateChange != null)
4613 OnUserStateChange((User)msg.DataToObject());
4614 break;
4615 case ClientEvent.CLIENTEVENT_USER_VIDEOCAPTURE:
4616 if (OnUserVideoCapture != null)
4617 OnUserVideoCapture(msg.nSource, (int)msg.DataToObject());
4618 break;
4619 case ClientEvent.CLIENTEVENT_USER_MEDIAFILE_VIDEO:
4620 if (OnUserMediaFileVideo != null)
4621 OnUserMediaFileVideo((int)msg.nSource, (int)msg.DataToObject());
4622 break;
4623 case ClientEvent.CLIENTEVENT_USER_DESKTOPWINDOW:
4624 if (OnUserDesktopWindow != null)
4625 OnUserDesktopWindow((int)msg.nSource, (int)msg.DataToObject());
4626 break;
4627 case ClientEvent.CLIENTEVENT_USER_DESKTOPCURSOR:
4628 if (OnUserDesktopCursor != null)
4629 OnUserDesktopCursor((int)msg.nSource, (DesktopInput)msg.DataToObject());
4630 break;
4631 case ClientEvent.CLIENTEVENT_USER_DESKTOPINPUT :
4632 if (OnUserDesktopInput != null)
4633 OnUserDesktopInput((int)msg.nSource, (DesktopInput)msg.DataToObject());
4634 break;
4635 case ClientEvent.CLIENTEVENT_USER_RECORD_MEDIAFILE :
4636 if(OnUserRecordMediaFile != null)
4637 OnUserRecordMediaFile((int)msg.nSource, (MediaFileInfo)msg.DataToObject());
4638 break;
4639 case ClientEvent.CLIENTEVENT_USER_AUDIOBLOCK :
4640 if(OnUserAudioBlock != null)
4641 OnUserAudioBlock((int)msg.nSource, (StreamType)msg.DataToObject());
4642 break;
4643 case ClientEvent.CLIENTEVENT_INTERNAL_ERROR :
4644 if(OnInternalError!= null)
4645 OnInternalError((ClientErrorMsg)msg.DataToObject());
4646 break;
4647 case ClientEvent.CLIENTEVENT_VOICE_ACTIVATION :
4648 if(OnVoiceActivation != null)
4649 OnVoiceActivation((bool)msg.DataToObject());
4650 break;
4651 case ClientEvent.CLIENTEVENT_HOTKEY :
4652 if(OnHotKeyToggle != null)
4653 OnHotKeyToggle(msg.nSource, (bool)msg.DataToObject());
4654 break;
4655 case ClientEvent.CLIENTEVENT_HOTKEY_TEST :
4656 if(OnHotKeyTest != null)
4657 OnHotKeyTest(msg.nSource, (bool)msg.DataToObject());
4658 break;
4659 case ClientEvent.CLIENTEVENT_FILETRANSFER :
4660 if(OnFileTransfer != null)
4661 OnFileTransfer((FileTransfer)msg.DataToObject());
4662 break;
4663 case ClientEvent.CLIENTEVENT_DESKTOPWINDOW_TRANSFER :
4664 if(OnDesktopWindowTransfer != null)
4665 OnDesktopWindowTransfer(msg.nSource, (int)msg.DataToObject());
4666 break;
4667 case ClientEvent.CLIENTEVENT_STREAM_MEDIAFILE :
4668 if(OnStreamMediaFile != null)
4669 OnStreamMediaFile((MediaFileInfo)msg.DataToObject());
4670 break;
4671 case ClientEvent.CLIENTEVENT_LOCAL_MEDIAFILE:
4672 if (OnLocalMediaFile != null)
4673 OnLocalMediaFile((MediaFileInfo)msg.DataToObject());
4674 break;
4675 case ClientEvent.CLIENTEVENT_AUDIOINPUT:
4676 if (OnAudioInput != null)
4677 OnAudioInput((AudioInputProgress)msg.DataToObject());
4678 break;
4679 case ClientEvent.CLIENTEVENT_USER_FIRSTVOICESTREAMPACKET:
4680 if (OnUserFirstVoiceStreamPacket != null)
4681 OnUserFirstVoiceStreamPacket((User)msg.DataToObject(), msg.nSource);
4682 break;
4683 }
4684 }
4685
4698 public static bool GetDefaultSoundDevices(ref int lpnInputDeviceID,
4699 ref int lpnOutputDeviceID)
4700 {
4701 return TTDLL.TT_GetDefaultSoundDevices(ref lpnInputDeviceID, ref lpnOutputDeviceID);
4702 }
4707 public static bool GetDefaultSoundDevicesEx(SoundSystem nSndSystem,
4708 ref int lpnInputDeviceID,
4709 ref int lpnOutputDeviceID)
4710 {
4711 return TTDLL.TT_GetDefaultSoundDevicesEx(nSndSystem, ref lpnInputDeviceID, ref lpnOutputDeviceID);
4712 }
4721 public static bool GetSoundDevices(out SoundDevice[] lpSoundDevices)
4722 {
4723 int count = 0;
4724 bool b = TTDLL.TT_GetSoundDevices_NULL(IntPtr.Zero, ref count);
4725 SoundDevice[] devs = new SoundDevice[count];
4726 b = TTDLL.TT_GetSoundDevices(devs, ref count);
4727 lpSoundDevices = b ? devs : null;
4728 return b;
4729 }
4745 public static bool RestartSoundSystem()
4746 {
4747 return TTDLL.TT_RestartSoundSystem();
4748 }
4753 public static IntPtr StartSoundLoopbackTest(int nInputDeviceID, int nOutputDeviceID,
4754 int nSampleRate, int nChannels,
4755 bool bDuplexMode, SpeexDSP lpSpeexDSP)
4756 {
4757 return TTDLL.TT_StartSoundLoopbackTest(nInputDeviceID, nOutputDeviceID,
4758 nSampleRate, nChannels, bDuplexMode,
4759 ref lpSpeexDSP);
4760 }
4792 public static IntPtr StartSoundLoopbackTest(int nInputDeviceID, int nOutputDeviceID,
4793 int nSampleRate, int nChannels,
4794 bool bDuplexMode, AudioPreprocessor lpAudioPreprocessor,
4795 BearWare.SoundDeviceEffects lpSoundDeviceEffects)
4796 {
4797 return TTDLL.TT_StartSoundLoopbackTestEx(nInputDeviceID, nOutputDeviceID,
4798 nSampleRate, nChannels, bDuplexMode,
4799 ref lpAudioPreprocessor, ref lpSoundDeviceEffects);
4800 }
4807 public static bool CloseSoundLoopbackTest(IntPtr lpTTSoundLoop)
4808 {
4809 return TTDLL.TT_CloseSoundLoopbackTest(lpTTSoundLoop);
4810 }
4839 public bool InitSoundInputDevice(int nInputDeviceID)
4840 {
4841 return TTDLL.TT_InitSoundInputDevice(m_ttInst, nInputDeviceID);
4842 }
4843
4874 public bool InitSoundInputSharedDevice(int nSampleRate,int nChannels, int nFrameSize)
4875 {
4876 return TTDLL.TT_InitSoundInputSharedDevice(nSampleRate, nChannels, nFrameSize);
4877 }
4878
4907 public bool InitSoundOutputDevice(int nOutputDeviceID)
4908 {
4909 return TTDLL.TT_InitSoundOutputDevice(m_ttInst, nOutputDeviceID);
4910 }
4941 public bool InitSoundOutputSharedDevice(int nSampleRate, int nChannels,int nFrameSize)
4942 {
4943 return TTDLL.TT_InitSoundOutputSharedDevice(nSampleRate, nChannels, nFrameSize);
4944 }
4978 public bool InitSoundDuplexDevices(int nInputDeviceID, int nOutputDeviceID)
4979 {
4980 return TTDLL.TT_InitSoundDuplexDevices(m_ttInst, nInputDeviceID, nOutputDeviceID);
4981 }
5001 public bool CloseSoundInputDevice()
5002 {
5003 return TTDLL.TT_CloseSoundInputDevice(m_ttInst);
5004 }
5023 public bool CloseSoundOutputDevice()
5024 {
5025 return TTDLL.TT_CloseSoundOutputDevice(m_ttInst);
5026 }
5033 public bool CloseSoundDuplexDevices()
5034 {
5035 return TTDLL.TT_CloseSoundDuplexDevices(m_ttInst);
5036 }
5072 public bool SetSoundDeviceEffects(SoundDeviceEffects lpSoundDeviceEffect)
5073 {
5074 return TTDLL.TT_SetSoundDeviceEffects(m_ttInst, ref lpSoundDeviceEffect);
5075 }
5080 public bool GetSoundDeviceEffects(ref SoundDeviceEffects lpSoundDeviceEffect)
5081 {
5082 return TTDLL.TT_GetSoundDeviceEffects(m_ttInst, ref lpSoundDeviceEffect);
5083 }
5100 public int GetSoundInputLevel()
5101 {
5102 return TTDLL.TT_GetSoundInputLevel(m_ttInst);
5103 }
5119 public bool SetSoundInputGainLevel(int nLevel)
5120 {
5121 return TTDLL.TT_SetSoundInputGainLevel(m_ttInst, nLevel);
5122 }
5129 public int GetSoundInputGainLevel()
5130 {
5131 return TTDLL.TT_GetSoundInputGainLevel(m_ttInst);
5132 }
5133
5149 public bool SetSoundInputPreprocess(SpeexDSP lpSpeexDSP)
5150 {
5151 return TTDLL.TT_SetSoundInputPreprocess(m_ttInst, ref lpSpeexDSP);
5152 }
5153
5162 public bool GetSoundInputPreprocess(ref SpeexDSP lpSpeexDSP)
5163 {
5164 return TTDLL.TT_GetSoundInputPreprocess(m_ttInst, ref lpSpeexDSP);
5165 }
5177 public bool SetSoundInputPreprocess(AudioPreprocessor lpAudioPreprocessor)
5178 {
5179 return TTDLL.TT_SetSoundInputPreprocessEx(m_ttInst, ref lpAudioPreprocessor);
5180 }
5181
5189 public bool GetSoundInputPreprocess(ref AudioPreprocessor lpAudioPreprocessor)
5190 {
5191 return TTDLL.TT_GetSoundInputPreprocessEx(m_ttInst, ref lpAudioPreprocessor);
5192 }
5200 public bool SetSoundOutputVolume(int nVolume)
5201 {
5202 return TTDLL.TT_SetSoundOutputVolume(m_ttInst, nVolume);
5203 }
5210 public int GetSoundOutputVolume()
5211 {
5212 return TTDLL.TT_GetSoundOutputVolume(m_ttInst);
5213 }
5221 public bool SetSoundOutputMute(bool bMuteAll)
5222 {
5223 return TTDLL.TT_SetSoundOutputMute(m_ttInst, bMuteAll);
5224 }
5235 public bool Enable3DSoundPositioning(bool bEnable)
5236 {
5237 return TTDLL.TT_Enable3DSoundPositioning(m_ttInst, bEnable);
5238 }
5248 public bool AutoPositionUsers()
5249 {
5250 return TTDLL.TT_AutoPositionUsers(m_ttInst);
5251 }
5252
5316 public bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes,
5317 bool bEnable)
5318 {
5319 return TTDLL.TT_EnableAudioBlockEvent(m_ttInst, nUserID, uStreamTypes, bEnable);
5320 }
5349 public bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes,
5350 AudioFormat lpAudioFormat, bool bEnable)
5351 {
5352 return TTDLL.TT_EnableAudioBlockEventEx(m_ttInst, nUserID, uStreamTypes, ref lpAudioFormat, bEnable);
5353 }
5388 public bool InsertAudioBlock(AudioBlock lpAudioBlock)
5389 {
5390 return TTDLL.TT_InsertAudioBlock(m_ttInst, ref lpAudioBlock);
5391 }
5392
5410 public bool EnableVoiceTransmission(bool bEnable)
5411 {
5412 return TTDLL.TT_EnableVoiceTransmission(m_ttInst, bEnable);
5413 }
5414
5440 public bool EnableVoiceActivation(bool bEnable)
5441 {
5442 return TTDLL.TT_EnableVoiceActivation(m_ttInst, bEnable);
5443 }
5455 public bool SetVoiceActivationLevel(int nLevel)
5456 {
5457 return TTDLL.TT_SetVoiceActivationLevel(m_ttInst, nLevel);
5458 }
5465 public int GetVoiceActivationLevel()
5466 {
5467 return TTDLL.TT_GetVoiceActivationLevel(m_ttInst);
5468 }
5481 public bool SetVoiceActivationStopDelay(int nDelayMSec)
5482 {
5483 return TTDLL.TT_SetVoiceActivationStopDelay(m_ttInst, nDelayMSec);
5484 }
5485
5495 public int GetVoiceActivationStopDelay()
5496 {
5497 return TTDLL.TT_GetVoiceActivationStopDelay(m_ttInst);
5498 }
5499
5542 public bool StartRecordingMuxedAudioFile(AudioCodec lpAudioCodec,
5543 string szAudioFileName,
5544 AudioFileFormat uAFF)
5545 {
5546 return TTDLL.TT_StartRecordingMuxedAudioFile(m_ttInst,
5547 ref lpAudioCodec,
5548 szAudioFileName,
5549 uAFF);
5550 }
5551
5571 public bool StartRecordingMuxedAudioFile(int nChannelID,
5572 string szAudioFileName,
5573 AudioFileFormat uAFF)
5574 {
5575 return TTDLL.TT_StartRecordingMuxedAudioFileEx(m_ttInst,
5576 nChannelID,
5577 szAudioFileName,
5578 uAFF);
5579 }
5580
5581
5613 public bool StartRecordingMuxedStreams(StreamType uStreamTypes,
5614 AudioCodec lpAudioCodec,
5615 string szAudioFileName,
5616 AudioFileFormat uAFF)
5617 {
5618 return TTDLL.TT_StartRecordingMuxedStreams(m_ttInst, uStreamTypes, ref lpAudioCodec, szAudioFileName, uAFF);
5619 }
5620
5632 public bool StopRecordingMuxedAudioFile()
5633 {
5634 return TTDLL.TT_StopRecordingMuxedAudioFile(m_ttInst);
5635 }
5636
5643 public bool StopRecordingMuxedAudioFile(int nChannelID)
5644 {
5645 return TTDLL.TT_StopRecordingMuxedAudioFileEx(m_ttInst, nChannelID);
5646 }
5647
5670 public bool StartVideoCaptureTransmission(VideoCodec lpVideoCodec)
5671 {
5672 return TTDLL.TT_StartVideoCaptureTransmission(m_ttInst, ref lpVideoCodec);
5673 }
5674
5679 public bool StopVideoCaptureTransmission()
5680 {
5681 return TTDLL.TT_StopVideoCaptureTransmission(m_ttInst);
5682 }
5683
5695 public static bool GetVideoCaptureDevices(out VideoCaptureDevice[] lpVideoDevices)
5696 {
5697 //To speed up query we only query for a max of 25.
5698 //Hopefully no one has more than 25 capture devices.
5699 VideoCaptureDevice[] devs = new VideoCaptureDevice[25];
5700 int count = devs.Length;
5701 bool b = TTDLL.TT_GetVideoCaptureDevices(devs, ref count);
5702 if (b)
5703 {
5704 lpVideoDevices = new VideoCaptureDevice[count];
5705 for (int i = 0; i < count; i++)
5706 lpVideoDevices[i] = devs[i];
5707 }
5708 else lpVideoDevices = null;
5709
5710 return b;
5711 }
5723 public bool InitVideoCaptureDevice(string szDeviceID,
5724 VideoFormat lpVideoFormat)
5725 {
5726 return TTDLL.TT_InitVideoCaptureDevice(m_ttInst, szDeviceID, ref lpVideoFormat);
5727 }
5732 public bool CloseVideoCaptureDevice()
5733 {
5734 return TTDLL.TT_CloseVideoCaptureDevice(m_ttInst);
5735 }
5750 public bool PaintVideoFrame(int nUserID,
5751 System.IntPtr hDC,
5752 int XDest,
5753 int YDest,
5754 int nDestWidth,
5755 int nDestHeight,
5756 ref VideoFrame lpVideoFrame)
5757 {
5758 return TTDLL.TT_PaintVideoFrame(nUserID, hDC, XDest, YDest, nDestWidth,
5759 nDestHeight, ref lpVideoFrame);
5760 }
5761
5793 public bool PaintVideoFrameEx(int nUserID,
5794 System.IntPtr hDC,
5795 int XDest,
5796 int YDest,
5797 int nDestWidth,
5798 int nDestHeight,
5799 int XSrc,
5800 int YSrc,
5801 int nSrcWidth,
5802 int nSrcHeight,
5803 ref VideoFrame lpVideoFrame)
5804 {
5805 return TTDLL.TT_PaintVideoFrameEx(nUserID, hDC, XDest, YDest, nDestWidth, nDestHeight,
5806 XSrc, YSrc, nSrcWidth, nSrcHeight,
5807 ref lpVideoFrame);
5808 }
5809
5828 public VideoFrame AcquireUserVideoCaptureFrame(int nUserID, out Bitmap bmp)
5829 {
5830 bmp = null;
5831 IntPtr ptr = TTDLL.TT_AcquireUserVideoCaptureFrame(m_ttInst, nUserID);
5832 if(ptr == IntPtr.Zero)
5833 return new VideoFrame();
5834
5835 VideoFrame frm = (VideoFrame)Marshal.PtrToStructure(ptr, typeof(VideoFrame));
5836 vidcapframes.Add(frm.frameBuffer, ptr);
5837
5838 PixelFormat pixelformat = PixelFormat.Format32bppRgb;
5839 bmp = new Bitmap(frm.nWidth, frm.nHeight, frm.nWidth*4, pixelformat, frm.frameBuffer);
5840 return frm;
5841 }
5842
5843 Dictionary<IntPtr, IntPtr> vidcapframes = new Dictionary<IntPtr, IntPtr>();
5844
5852 public bool ReleaseUserVideoCaptureFrame(VideoFrame lpVideoFrame)
5853 {
5854 IntPtr ptr;
5855 if (vidcapframes.TryGetValue(lpVideoFrame.frameBuffer, out ptr))
5856 {
5857 vidcapframes.Remove(lpVideoFrame.frameBuffer);
5858 return TTDLL.TT_ReleaseUserVideoCaptureFrame(m_ttInst, ptr);
5859 }
5860 return false;
5861 }
5862
5875 /*
5876 public bool GetUserVideoFrame(int nUserID,
5877 ref System.Drawing.Bitmap lpPicture)
5878 {
5879 CaptureFormat cap;
5880 if (!TTDLL.TT_GetUserVideoFrame(m_ttInst, nUserID, IntPtr.Zero, 0, out cap))
5881 return false;
5882
5883 PixelFormat pixelformat = PixelFormat.Format32bppRgb;
5884
5885 if (lpPicture == null ||
5886 lpPicture.Width != cap.nWidth ||
5887 lpPicture.Height != cap.nHeight
5888 #if PocketPC
5889 )
5890 #else
5891 || lpPicture.PixelFormat != pixelformat)
5892 #endif
5893 {
5894 lpPicture = new Bitmap(cap.nWidth, cap.nHeight,
5895 pixelformat);
5896 }
5897
5898 // Lock the bitmap's bits.
5899 System.Drawing.Rectangle rect = new System.Drawing.Rectangle(0, 0, lpPicture.Width, lpPicture.Height);
5900 BitmapData bmpData = lpPicture.LockBits(rect, ImageLockMode.ReadWrite, pixelformat);
5901
5902 // Get the address of the first line.
5903 IntPtr ptr = bmpData.Scan0;
5904
5905 bool b = TTDLL.TT_GetUserVideoFrame(m_ttInst, nUserID, ptr,
5906 cap.nWidth * cap.nHeight * 4, out cap);
5907 // Unlock the bits.
5908 lpPicture.UnlockBits(bmpData);
5909 return b;
5910 }
5911 * */
5912
5920 public bool StartStreamingMediaFileToChannel(string szMediaFilePath,
5921 VideoCodec lpVideoCodec)
5922 {
5923 return TTDLL.TT_StartStreamingMediaFileToChannel(m_ttInst, szMediaFilePath,
5924 ref lpVideoCodec);
5925 }
5926
5956 public bool StartStreamingMediaFileToChannel(string szMediaFilePath,
5957 MediaFilePlayback lpMediaFilePlayback,
5958 VideoCodec lpVideoCodec)
5959 {
5960 return TTDLL.TT_StartStreamingMediaFileToChannelEx(m_ttInst, szMediaFilePath,
5961 ref lpMediaFilePlayback,
5962 ref lpVideoCodec);
5963 }
5964
5981 public bool UpdateStreamingMediaFileToChannel(MediaFilePlayback lpMediaFilePlayback,
5982 VideoCodec lpVideoCodec)
5983 {
5984 return TTDLL.TT_UpdateStreamingMediaFileToChannel(m_ttInst, ref lpMediaFilePlayback, ref lpVideoCodec);
5985 }
5986
5994 public bool StopStreamingMediaFileToChannel()
5995 {
5996 return TTDLL.TT_StopStreamingMediaFileToChannel(m_ttInst);
5997 }
5998
6023 public int InitLocalPlayback(string szMediaFilePath, MediaFilePlayback lpMediaFilePlayback)
6024 {
6025 return TTDLL.TT_InitLocalPlayback(m_ttInst, szMediaFilePath, ref lpMediaFilePlayback);
6026 }
6027
6039 public bool UpdateLocalPlayback(int nPlaybackSessionID,
6040 MediaFilePlayback lpMediaFilePlayback)
6041 {
6042 return TTDLL.TT_UpdateLocalPlayback(m_ttInst, nPlaybackSessionID, ref lpMediaFilePlayback);
6043 }
6044
6053 public bool StopLocalPlayback(int nPlaybackSessionID)
6054 {
6055 return TTDLL.TT_StopLocalPlayback(m_ttInst, nPlaybackSessionID);
6056 }
6057
6065 public static bool GetMediaFileInfo(string szMediaFilePath,
6066 ref MediaFileInfo lpMediaFileInfo)
6067 {
6068 return TTDLL.TT_GetMediaFileInfo(szMediaFilePath, ref lpMediaFileInfo);
6069 }
6070
6090 public VideoFrame AcquireUserMediaVideoFrame(int nUserID, out Bitmap bmp)
6091 {
6092 bmp = null;
6093 IntPtr ptr = TTDLL.TT_AcquireUserMediaVideoFrame(m_ttInst, nUserID);
6094 if (ptr == IntPtr.Zero)
6095 return new VideoFrame();
6096
6097 VideoFrame frm = (VideoFrame)Marshal.PtrToStructure(ptr, typeof(VideoFrame));
6098 mediaframes.Add(frm.frameBuffer, ptr);
6099
6100 PixelFormat pixelformat = PixelFormat.Format32bppRgb;
6101 bmp = new Bitmap(frm.nWidth, frm.nHeight, frm.nWidth * 4, pixelformat, frm.frameBuffer);
6102 return frm;
6103 }
6104
6112 public bool ReleaseUserMediaVideoFrame(VideoFrame lpVideoFrame)
6113 {
6114 IntPtr ptr;
6115 if (mediaframes.TryGetValue(lpVideoFrame.frameBuffer, out ptr))
6116 {
6117 mediaframes.Remove(lpVideoFrame.frameBuffer);
6118 return TTDLL.TT_ReleaseUserMediaVideoFrame(m_ttInst, ptr);
6119 }
6120 return false;
6121 }
6122
6123 Dictionary<IntPtr, IntPtr> mediaframes = new Dictionary<IntPtr, IntPtr>();
6124
6167 public int SendDesktopWindow(DesktopWindow lpDesktopWindow,
6168 BitmapFormat nConvertBmpFormat)
6169 {
6170 return TTDLL.TT_SendDesktopWindow(m_ttInst, ref lpDesktopWindow, nConvertBmpFormat);
6171 }
6172
6180 public bool CloseDesktopWindow()
6181 {
6182 return TTDLL.TT_CloseDesktopWindow(m_ttInst);
6183 }
6184
6201 public static System.Drawing.Color Palette_GetColorTable(BitmapFormat nBmpPalette,
6202 int nIndex)
6203 {
6204 IntPtr ptr = TTDLL.TT_Palette_GetColorTable(nBmpPalette, nIndex);
6205 switch(nBmpPalette)
6206 {
6207 case BitmapFormat.BMP_RGB8_PALETTE:
6208 return Color.FromArgb(Marshal.ReadInt32(ptr));
6209 }
6210 return new Color();
6211 }
6212
6223 public int SendDesktopWindowFromHWND(System.IntPtr hWnd,
6224 BitmapFormat nBitmapFormat,
6225 DesktopProtocol nDesktopProtocol)
6226 {
6227 return TTDLL.TT_SendDesktopWindowFromHWND(m_ttInst, hWnd, nBitmapFormat, nDesktopProtocol);
6228 }
6229
6244 public bool PaintDesktopWindow(int nUserID,
6245 System.IntPtr hDC,
6246 int XDest,
6247 int YDest,
6248 int nDestWidth,
6249 int nDestHeight)
6250 {
6251 return TTDLL.TT_PaintDesktopWindow(m_ttInst, nUserID, hDC, XDest, YDest, nDestWidth, nDestHeight);
6252 }
6253
6286 public bool PaintDesktopWindowEx(int nUserID,
6287 System.IntPtr hDC,
6288 int XDest,
6289 int YDest,
6290 int nDestWidth,
6291 int nDestHeight,
6292 int XSrc,
6293 int YSrc,
6294 int nSrcWidth,
6295 int nSrcHeight)
6296 {
6297 return TTDLL.TT_PaintDesktopWindowEx(m_ttInst, nUserID, hDC, XDest,
6298 YDest, nDestWidth, nDestHeight,
6299 XSrc, YSrc, nSrcWidth, nSrcHeight);
6300 }
6301
6314 public bool SendDesktopCursorPosition(ushort nPosX,
6315 ushort nPosY)
6316 {
6317 return TTDLL.TT_SendDesktopCursorPosition(m_ttInst, nPosX, nPosY);
6318 }
6319
6343 public bool SendDesktopInput(int nUserID,
6344 DesktopInput[] lpDesktopInputs)
6345 {
6346 return TTDLL.TT_SendDesktopInput(m_ttInst, nUserID, lpDesktopInputs, lpDesktopInputs.Length);
6347 }
6348
6372 public DesktopWindow AcquireUserDesktopWindow(int nUserID)
6373 {
6374 IntPtr ptr = TTDLL.TT_AcquireUserDesktopWindow(m_ttInst, nUserID);
6375 if (ptr == IntPtr.Zero)
6376 return new DesktopWindow();
6377 DesktopWindow lpDesktopWindow = (DesktopWindow)Marshal.PtrToStructure(ptr, typeof(DesktopWindow));
6378 desktopwindows.Add(lpDesktopWindow.frameBuffer, ptr);
6379 return lpDesktopWindow;
6380 }
6381
6388 public DesktopWindow AcquireUserDesktopWindowEx(int nUserID, BitmapFormat nBitmapFormat)
6389 {
6390 IntPtr ptr = TTDLL.TT_AcquireUserDesktopWindowEx(m_ttInst, nUserID, nBitmapFormat);
6391 if (ptr == IntPtr.Zero)
6392 return new DesktopWindow();
6393 DesktopWindow lpDesktopWindow = (DesktopWindow)Marshal.PtrToStructure(ptr, typeof(DesktopWindow));
6394 desktopwindows.Add(lpDesktopWindow.frameBuffer, ptr);
6395 return lpDesktopWindow;
6396 }
6397
6398 Dictionary<IntPtr, IntPtr> desktopwindows = new Dictionary<IntPtr, IntPtr>();
6401 public bool ReleaseUserDesktopWindow(DesktopWindow lpDesktopWindow)
6402 {
6403 IntPtr ptr;
6404 if (desktopwindows.TryGetValue(lpDesktopWindow.frameBuffer, out ptr))
6405 {
6406 desktopwindows.Remove(lpDesktopWindow.frameBuffer);
6407 return TTDLL.TT_ReleaseUserDesktopWindow(m_ttInst, ptr);
6408 }
6409 return false;
6410 }
6411
6428 public bool SetEncryptionContext(EncryptionContext lpEncryptionContext)
6429 {
6430 return TTDLL.TT_SetEncryptionContext(m_ttInst, ref lpEncryptionContext);
6431 }
6432
6461 public bool Connect(string szHostAddress,
6462 int nTcpPort,
6463 int nUdpPort,
6464 int nLocalTcpPort,
6465 int nLocalUdpPort,
6466 bool bEncrypted)
6467 {
6468 return TTDLL.TT_Connect(m_ttInst, szHostAddress, nTcpPort, nUdpPort,
6469 nLocalTcpPort, nLocalUdpPort, bEncrypted);
6470 }
6471
6495 public bool ConnectSysID(string szHostAddress,
6496 int nTcpPort,
6497 int nUdpPort,
6498 int nLocalTcpPort,
6499 int nLocalUdpPort,
6500 bool bEncrypted,
6501 string szSystemID)
6502 {
6503 return TTDLL.TT_ConnectSysID(m_ttInst, szHostAddress,
6504 nTcpPort, nUdpPort, nLocalTcpPort,
6505 nLocalUdpPort, bEncrypted, szSystemID);
6506 }
6507
6528 public bool ConnectEx(string szHostAddress,
6529 int nTcpPort,
6530 int nUdpPort,
6531 string szBindIPAddr,
6532 int nLocalTcpPort,
6533 int nLocalUdpPort,
6534 bool bEncrypted)
6535 {
6536 return TTDLL.TT_ConnectEx(m_ttInst, szHostAddress, nTcpPort, nUdpPort,
6537 szBindIPAddr, nLocalTcpPort, nLocalUdpPort,
6538 bEncrypted);
6539 }
6540
6545 public bool Disconnect()
6546 {
6547 return TTDLL.TT_Disconnect(m_ttInst);
6548 }
6558 public bool QueryMaxPayload(int nUserID)
6559 {
6560 return TTDLL.TT_QueryMaxPayload(m_ttInst, nUserID);
6561 }
6567 public bool GetClientStatistics(ref ClientStatistics lpClientStatistics)
6568 {
6569 return TTDLL.TT_GetClientStatistics(m_ttInst, ref lpClientStatistics);
6570 }
6571
6586 public bool SetClientKeepAlive(ClientKeepAlive lpClientKeepAlive)
6587 {
6588 return TTDLL.TT_SetClientKeepAlive(m_ttInst, ref lpClientKeepAlive);
6589 }
6590
6597 public bool GetClientKeepAlive(ref ClientKeepAlive lpClientKeepAlive)
6598 {
6599 return TTDLL.TT_GetClientKeepAlive(m_ttInst, ref lpClientKeepAlive);
6600 }
6623 public int DoPing()
6624 {
6625 return TTDLL.TT_DoPing(m_ttInst);
6626 }
6627
6639 public int DoLogin(string szNickname, string szUsername, string szPassword)
6640 {
6641 return TTDLL.TT_DoLogin(m_ttInst, szNickname, szUsername, szPassword);
6642 }
6643
6673 public int DoLoginEx(string szNickname, string szUsername, string szPassword,
6674 string szClientName)
6675 {
6676 return TTDLL.TT_DoLoginEx(m_ttInst, szNickname, szUsername, szPassword, szClientName);
6677 }
6691 public int DoLogout()
6692 {
6693 return TTDLL.TT_DoLogout(m_ttInst);
6694 }
6734 public int DoJoinChannel(Channel lpChannel)
6735 {
6736 return TTDLL.TT_DoJoinChannel(m_ttInst, ref lpChannel);
6737 }
6761 public int DoJoinChannelByID(int nChannelID, string szPassword)
6762 {
6763 return TTDLL.TT_DoJoinChannelByID(m_ttInst, nChannelID, szPassword);
6764 }
6784 public int DoLeaveChannel()
6785 {
6786 return TTDLL.TT_DoLeaveChannel(m_ttInst);
6787 }
6805 public int DoChangeNickname(string szNewNick)
6806 {
6807 return TTDLL.TT_DoChangeNickname(m_ttInst, szNewNick);
6808 }
6828 public int DoChangeStatus(int nStatusMode, string szStatusMessage)
6829 {
6830 return TTDLL.TT_DoChangeStatus(m_ttInst, nStatusMode, szStatusMessage);
6831 }
6850 public int DoTextMessage(TextMessage lpTextMessage)
6851 {
6852 return TTDLL.TT_DoTextMessage(m_ttInst, ref lpTextMessage);
6853 }
6874 public int DoChannelOp(int nUserID, int nChannelID, bool bMakeOperator)
6875 {
6876 return TTDLL.TT_DoChannelOp(m_ttInst, nUserID, nChannelID, bMakeOperator);
6877 }
6897 public int DoChannelOpEx(int nUserID,
6898 int nChannelID,
6899 string szOpPassword,
6900 bool bMakeOperator)
6901 {
6902 return TTDLL.TT_DoChannelOpEx(m_ttInst, nUserID, nChannelID, szOpPassword, bMakeOperator);
6903 }
6926 public int DoKickUser(int nUserID, int nChannelID)
6927 {
6928 return TTDLL.TT_DoKickUser(m_ttInst, nUserID, nChannelID);
6929 }
6964 public int DoSendFile(int nChannelID, string szLocalFilePath)
6965 {
6966 return TTDLL.TT_DoSendFile(m_ttInst, nChannelID, szLocalFilePath);
6967 }
6997 public int DoRecvFile(int nChannelID, int nFileID, string szLocalFilePath)
6998 {
6999 return TTDLL.TT_DoRecvFile(m_ttInst, nChannelID, nFileID, szLocalFilePath);
7000 }
7023 public int DoDeleteFile(int nChannelID, int nFileID)
7024 {
7025 return TTDLL.TT_DoDeleteFile(m_ttInst, nChannelID, nFileID);
7026 }
7041 public int DoSubscribe(int nUserID, Subscription uSubscriptions)
7042 {
7043 return TTDLL.TT_DoSubscribe(m_ttInst, nUserID, uSubscriptions);
7044 }
7060 public int DoUnsubscribe(int nUserID, Subscription uSubscriptions)
7061 {
7062 return TTDLL.TT_DoUnsubscribe(m_ttInst, nUserID, uSubscriptions);
7063 }
7089 public int DoMakeChannel(Channel lpChannel)
7090 {
7091 return TTDLL.TT_DoMakeChannel(m_ttInst, ref lpChannel);
7092 }
7125 public int DoUpdateChannel(Channel lpChannel)
7126 {
7127 return TTDLL.TT_DoUpdateChannel(m_ttInst, ref lpChannel);
7128 }
7147 public int DoRemoveChannel(int nChannelID)
7148 {
7149 return TTDLL.TT_DoRemoveChannel(m_ttInst, nChannelID);
7150 }
7170 public int DoMoveUser(int nUserID, int nChannelID)
7171 {
7172 return TTDLL.TT_DoMoveUser(m_ttInst, nUserID, nChannelID);
7173 }
7190 public int DoUpdateServer(ServerProperties lpServerProperties)
7191 {
7192 return TTDLL.TT_DoUpdateServer(m_ttInst, ref lpServerProperties);
7193 }
7218 public int DoListUserAccounts(int nIndex, int nCount)
7219 {
7220 return TTDLL.TT_DoListUserAccounts(m_ttInst, nIndex, nCount);
7221 }
7244 public int DoNewUserAccount(UserAccount lpUserAccount)
7245 {
7246 return TTDLL.TT_DoNewUserAccount(m_ttInst, ref lpUserAccount);
7247 }
7266 public int DoDeleteUserAccount(string szUsername)
7267 {
7268 return TTDLL.TT_DoDeleteUserAccount(m_ttInst, szUsername);
7269 }
7297 public int DoBanUser(int nUserID, int nChannelID)
7298 {
7299 return TTDLL.TT_DoBanUser(m_ttInst, nUserID, nChannelID);
7300 }
7301
7313 public int DoBanUserEx(int nUserID, BanType uBanTypes)
7314 {
7315 return TTDLL.TT_DoBanUserEx(m_ttInst, nUserID, uBanTypes);
7316 }
7317
7336 public int DoBan(BannedUser lpBannedUser)
7337 {
7338 return TTDLL.TT_DoBan(m_ttInst, ref lpBannedUser);
7339 }
7340
7361 public int DoBanIPAddress(string szIPAddress, int nChannelID)
7362 {
7363 return TTDLL.TT_DoBanIPAddress(m_ttInst, szIPAddress, nChannelID);
7364 }
7365
7386 public int DoUnBanUser(string szIPAddress, int nChannelID)
7387 {
7388 return TTDLL.TT_DoUnBanUser(m_ttInst, szIPAddress, nChannelID);
7389 }
7390
7400 public int DoUnBanUserEx(BannedUser lpBannedUser)
7401 {
7402 return TTDLL.TT_DoUnBanUserEx(m_ttInst, ref lpBannedUser);
7403 }
7404
7425 public int DoListBans(int nChannelID, int nIndex, int nCount)
7426 {
7427 return TTDLL.TT_DoListBans(m_ttInst, nChannelID, nIndex, nCount);
7428 }
7446 public int DoSaveConfig()
7447 {
7448 return TTDLL.TT_DoSaveConfig(m_ttInst);
7449 }
7466 public int DoQueryServerStats()
7467 {
7468 return TTDLL.TT_DoQueryServerStats(m_ttInst);
7469 }
7482 public int DoQuit()
7483 {
7484 return TTDLL.TT_DoQuit(m_ttInst);
7485 }
7497 public bool GetServerProperties(ref ServerProperties lpServerProperties)
7498 {
7499 return TTDLL.TT_GetServerProperties(m_ttInst, ref lpServerProperties);
7500 }
7511 public bool GetServerUsers(out User[] lpUsers)
7512 {
7513 int count = 0;
7514 bool b = TTDLL.TT_GetServerUsers_NULL(m_ttInst, IntPtr.Zero, ref count);
7515 User[] users = new User[count];
7516 b = TTDLL.TT_GetServerUsers(m_ttInst, users, ref count);
7517 lpUsers = b ? users : null;
7518 return b;
7519 }
7532 public int GetRootChannelID()
7533 {
7534 return TTDLL.TT_GetRootChannelID(m_ttInst);
7535 }
7542 public int GetMyChannelID()
7543 {
7544 return TTDLL.TT_GetMyChannelID(m_ttInst);
7545 }
7549 public int ChannelID { get { return GetMyChannelID(); } }
7557 public bool GetChannel(int nChannelID, ref Channel lpChannel)
7558 {
7559 return TTDLL.TT_GetChannel(m_ttInst, nChannelID, ref lpChannel);
7560 }
7567 public bool GetChannelPath(int nChannelID, ref string szChannelPath)
7568 {
7569 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
7570 bool b = TTDLL.TT_GetChannelPath(m_ttInst, nChannelID, ptr);
7571 if(b)
7572 szChannelPath = Marshal.PtrToStringUni(ptr);
7573 Marshal.FreeHGlobal(ptr);
7574 return b;
7575 }
7582 public int GetChannelIDFromPath(string szChannelPath)
7583 {
7584 return TTDLL.TT_GetChannelIDFromPath(m_ttInst, szChannelPath);
7585 }
7594 public bool GetChannelUsers(int nChannelID, out User[] lpUsers)
7595 {
7596 int count = 0;
7597 bool b = TTDLL.TT_GetChannelUsers_NULL(m_ttInst, nChannelID, IntPtr.Zero, ref count);
7598 User[] users = new User[count];
7599 b = TTDLL.TT_GetChannelUsers(m_ttInst, nChannelID, users, ref count);
7600 lpUsers = b ? users : null;
7601 return b;
7602 }
7611 public bool GetChannelFiles(int nChannelID, out RemoteFile[] lpRemoteFiles)
7612 {
7613 int count = 0;
7614 bool b = TTDLL.TT_GetChannelFiles_NULL(m_ttInst, nChannelID, IntPtr.Zero, ref count);
7615 RemoteFile[] files = new RemoteFile[count];
7616 b = TTDLL.TT_GetChannelFiles(m_ttInst, nChannelID, files, ref count);
7617 lpRemoteFiles = b ? files : null;
7618 return b;
7619 }
7627 public bool GetChannelFile(int nChannelID, int nFileID, ref RemoteFile lpRemoteFile)
7628 {
7629 return TTDLL.TT_GetChannelFile(m_ttInst, nChannelID, nFileID, ref lpRemoteFile);
7630 }
7637 public bool IsChannelOperator(int nUserID, int nChannelID)
7638 {
7639 return TTDLL.TT_IsChannelOperator(m_ttInst, nUserID, nChannelID);
7640 }
7647 public bool GetServerChannels(out Channel[] lpChannels)
7648 {
7649 int count = 0;
7650 bool b = TTDLL.TT_GetServerChannels_NULL(m_ttInst, IntPtr.Zero, ref count);
7651 Channel[] channels = new Channel[count];
7652 b = TTDLL.TT_GetServerChannels(m_ttInst, channels, ref count);
7653 lpChannels = b ? channels : null;
7654 return b;
7655 }
7669 public int GetMyUserID()
7670 {
7671 return TTDLL.TT_GetMyUserID(m_ttInst);
7672 }
7673
7684 public bool GetMyUserAccount(ref UserAccount lpUserAccount)
7685 {
7686 return TTDLL.TT_GetMyUserAccount(m_ttInst, ref lpUserAccount);
7687 }
7688
7692 public int UserID { get { return GetMyUserID(); } }
7693
7704 public UserType GetMyUserType()
7705 {
7706 return TTDLL.TT_GetMyUserType(m_ttInst);
7707 }
7708
7712 public BearWare.UserType UserType { get { return GetMyUserType(); } }
7713
7717 public BearWare.UserRight UserRights { get { return GetMyUserRights(); } }
7718
7720 public BearWare.UserRight GetMyUserRights()
7721 {
7722 return TTDLL.TT_GetMyUserRights(m_ttInst);
7723 }
7724
7734 public int GetMyUserData()
7735 {
7736 return TTDLL.TT_GetMyUserData(m_ttInst);
7737 }
7738
7742 public int UserData { get { return GetMyUserData(); } }
7743
7750 public bool GetUser(int nUserID, ref User lpUser)
7751 {
7752 return TTDLL.TT_GetUser(m_ttInst, nUserID, ref lpUser);
7753 }
7759 public bool GetUserStatistics(int nUserID, ref UserStatistics lpUserStatistics)
7760 {
7761 return TTDLL.TT_GetUserStatistics(m_ttInst, nUserID, ref lpUserStatistics);
7762 }
7771 public bool GetUserByUsername(string szUsername, ref User lpUser)
7772 {
7773 return TTDLL.TT_GetUserByUsername(m_ttInst, szUsername, ref lpUser);
7774 }
7791 public bool SetUserVolume(int nUserID, StreamType nStreamType, int nVolume)
7792 {
7793 return TTDLL.TT_SetUserVolume(m_ttInst, nUserID, nStreamType, nVolume);
7794 }
7806 public bool SetUserMute(int nUserID, StreamType nStreamType, bool bMute)
7807 {
7808 return TTDLL.TT_SetUserMute(m_ttInst, nUserID, nStreamType, bMute);
7809 }
7822 public bool SetUserStoppedPlaybackDelay(int nUserID,
7823 StreamType nStreamType,
7824 int nDelayMSec)
7825 {
7826 return TTDLL.TT_SetUserStoppedPlaybackDelay(m_ttInst, nUserID, nStreamType, nDelayMSec);
7827 }
7828
7853 public bool SetUserJitterControl(int nUserID,
7854 StreamType nStreamType,
7855 JitterConfig lpJitterConfig)
7856 {
7857 return TTDLL.TT_SetUserJitterControl(m_ttInst, nUserID, nStreamType, ref lpJitterConfig);
7858 }
7859
7870 public bool GetUserJitterControl(int nUserID,
7871 StreamType nStreamType,
7872 ref JitterConfig lpJitterConfig)
7873 {
7874 return TTDLL.TT_GetUserJitterControl(m_ttInst, nUserID, nStreamType, ref lpJitterConfig);
7875 }
7876
7892 public bool SetUserPosition(int nUserID, StreamType nStreamType,
7893 float x, float y, float z)
7894 {
7895 return TTDLL.TT_SetUserPosition(m_ttInst, nUserID, nStreamType, x, y, z);
7896 }
7908 public bool SetUserStereo(int nUserID, StreamType nStreamType, bool bLeftSpeaker, bool bRightSpeaker)
7909 {
7910 return TTDLL.TT_SetUserStereo(m_ttInst, nUserID, nStreamType, bLeftSpeaker, bRightSpeaker);
7911 }
7947 public bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars,
7948 AudioFileFormat uAFF)
7949 {
7950 return TTDLL.TT_SetUserMediaStorageDir(m_ttInst, nUserID, szFolderPath, szFileNameVars, uAFF);
7951 }
7952
7977 public bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars,
7978 AudioFileFormat uAFF, int nStopRecordingExtraDelayMSec)
7979 {
7980 return TTDLL.TT_SetUserMediaStorageDirEx(m_ttInst, nUserID, szFolderPath, szFileNameVars, uAFF, nStopRecordingExtraDelayMSec);
7981 }
7982
8007 public bool SetUserAudioStreamBufferSize(int nUserID, StreamType uStreamType,
8008 int nMSec)
8009 {
8010 return TTDLL.TT_SetUserAudioStreamBufferSize(m_ttInst, nUserID, uStreamType, nMSec);
8011 }
8031 public AudioBlock AcquireUserAudioBlock(StreamType uStreamTypes, int nUserID)
8032 {
8033 IntPtr ptr = TTDLL.TT_AcquireUserAudioBlock(m_ttInst, uStreamTypes, nUserID);
8034 if (ptr == IntPtr.Zero)
8035 return new AudioBlock();
8036 AudioBlock lpAudioBlock = (AudioBlock)Marshal.PtrToStructure(ptr, typeof(AudioBlock));
8037 audioblocks.Add(lpAudioBlock.lpRawAudio, ptr);
8038 return lpAudioBlock;
8039 }
8040
8041 Dictionary<IntPtr, IntPtr> audioblocks = new Dictionary<IntPtr, IntPtr>();
8042
8056 public bool ReleaseUserAudioBlock(AudioBlock lpAudioBlock)
8057 {
8058 IntPtr ptr;
8059 if (audioblocks.TryGetValue(lpAudioBlock.lpRawAudio, out ptr))
8060 {
8061 audioblocks.Remove(lpAudioBlock.lpRawAudio);
8062 return TTDLL.TT_ReleaseUserAudioBlock(m_ttInst, ptr);
8063 }
8064 return false;
8065 }
8079 public bool GetFileTransferInfo(int nTransferID, ref FileTransfer lpFileTransfer)
8080 {
8081 return TTDLL.TT_GetFileTransferInfo(m_ttInst, nTransferID, ref lpFileTransfer);
8082 }
8083
8092 public bool CancelFileTranfer(int nTransferID)
8093 {
8094 return TTDLL.TT_CancelFileTransfer(m_ttInst, nTransferID);
8095 }
8096
8107 public static string GetErrorMessage(ClientError nError)
8108 {
8109 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8110 TTDLL.TT_GetErrorMessage((int)nError, ptr);
8111 string s = Marshal.PtrToStringUni(ptr);
8112 Marshal.FreeHGlobal(ptr);
8113 return s;
8114 }
8115
8142 public bool HotKey_Register(int nHotKeyID, int[] lpnVKCodes)
8143 {
8144 return TTDLL.TT_HotKey_Register(m_ttInst, nHotKeyID, lpnVKCodes, lpnVKCodes.Length);
8145 }
8151 public bool HotKey_Unregister(int nHotKeyID)
8152 {
8153 return TTDLL.TT_HotKey_Unregister(m_ttInst, nHotKeyID);
8154 }
8160 public int HotKey_IsActive(int nHotKeyID)
8161 {
8162 return TTDLL.TT_HotKey_IsActive(m_ttInst, nHotKeyID);
8163 }
8173 public bool HotKey_InstallTestHook()
8174 {
8175 if (m_eventhandler != null)
8176 {
8177 #if PocketPC
8178 IntPtr hWnd = m_eventhandler.Hwnd;
8179 #else
8180 IntPtr hWnd = m_eventhandler.Handle;
8181 #endif
8182 return TTDLL.TT_HotKey_InstallTestHook(m_ttInst, hWnd,
8183 MyEventHandler.WM_TEAMTALK_CLIENTEVENT);
8184 }
8185 return false;
8186 }
8192 public bool HotKey_RemoveTestHook()
8193 {
8194 return TTDLL.TT_HotKey_RemoveTestHook(m_ttInst);
8195 }
8202 public bool HotKey_GetKeyString(int nVKCode, ref string szKeyName)
8203 {
8204 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8205 bool b = TTDLL.TT_HotKey_GetKeyString(m_ttInst, nVKCode, ptr);
8206 if(b)
8207 szKeyName = Marshal.PtrToStringUni(ptr);
8208 Marshal.FreeHGlobal(ptr);
8209 return b;
8210 }
8213 public bool DBG_SetSoundInputTone(StreamType uStreamTypes, int nFrequency)
8214 {
8215 return TTDLL.TT_DBG_SetSoundInputTone(m_ttInst, uStreamTypes, nFrequency);
8216 }
8217
8218
8219 public bool DBG_WriteAudioFileTone(MediaFileInfo lpMediaFileInfo,
8220 int nFrequency)
8221 {
8222 return TTDLL.TT_DBG_WriteAudioFileTone(ref lpMediaFileInfo, nFrequency);
8223 }
8224
8231 public delegate void Connection();
8240 public event Connection OnConnectionSuccess;
8248 public event Connection OnConnectionFailed;
8256 public event Connection OnConnectionLost;
8257
8263 public delegate void MaxPayloadUpdate(int nPayloadSize);
8264
8272 public event MaxPayloadUpdate OnConnectionMaxPayloadUpdated;
8273
8281 public delegate void CommandProcessing(int nCmdID, bool bActive);
8282
8293 public event CommandProcessing OnCmdProcessing;
8294
8299 public delegate void CommandError(int nCmdID, ClientErrorMsg clienterrormsg);
8300
8309 public event CommandError OnCmdError;
8310
8314 public delegate void CommandSuccess(int nCmdID);
8315
8323 public event CommandSuccess OnCmdSuccess;
8324
8330 public delegate void MyselfLoggedIn(int nMyUserID, UserAccount useraccount);
8331
8340 public event MyselfLoggedIn OnCmdMyselfLoggedIn;
8341
8343 public delegate void MyselfLoggedOut();
8351 public event MyselfLoggedOut OnCmdMyselfLoggedOut;
8352
8358 public delegate void MyselfKicked(User user);
8364 public event MyselfKicked OnCmdMyselfKicked;
8365
8370 public delegate void UserUpdate(User user);
8371
8375 public delegate void UserStreamUpdate(User user, int nStreamID);
8376
8384 public event UserUpdate OnCmdUserLoggedIn;
8385
8394 public event UserUpdate OnCmdUserLoggedOut;
8395
8400 public event UserUpdate OnCmdUserUpdate;
8401
8406 public event UserUpdate OnCmdUserJoinedChannel;
8407
8412 public event UserUpdate OnCmdUserLeftChannel;
8413
8419 public delegate void UserTextMessage(TextMessage textmessage);
8420
8425 public event UserTextMessage OnCmdUserTextMessage;
8426
8427
8430 public delegate void ChannelUpdate(Channel channel);
8431
8438 public event ChannelUpdate OnCmdChannelNew;
8439
8444 public event ChannelUpdate OnCmdChannelUpdate;
8445
8449 public event ChannelUpdate OnCmdChannelRemove;
8450
8452 public delegate void ServerUpdate(ServerProperties serverproperties);
8453
8459 public event ServerUpdate OnCmdServerUpdate;
8460
8462 public delegate void ServerStats(ServerStatistics serverstatistics);
8463
8468 public event ServerStats OnCmdServerStatistics;
8469
8471 public delegate void FileUpdate(RemoteFile remotefile);
8472
8477 public event FileUpdate OnCmdFileNew;
8478
8483 public event FileUpdate OnCmdFileRemove;
8484
8486 public delegate void ListUserAccount(UserAccount useraccount);
8487
8490 public event ListUserAccount OnCmdUserAccount;
8491
8493 public delegate void ListBannedUser(BannedUser banneduser);
8494
8497 public event ListBannedUser OnCmdBannedUser;
8498
8503 public event UserStreamUpdate OnUserFirstVoiceStreamPacket;
8504
8508 public event UserUpdate OnUserStateChange;
8509
8511 public delegate void UserVideoFrame(int nUserID, int nStreamID);
8512
8517 public event UserVideoFrame OnUserVideoCapture;
8518
8523 public event UserVideoFrame OnUserMediaFileVideo;
8524
8533 public delegate void NewDesktopWindow(int nUserID, int nStreamID);
8534
8543 public event NewDesktopWindow OnUserDesktopWindow;
8544
8546 public delegate void UserDesktopInput(int nSrcUserID, DesktopInput desktopinput);
8547
8553 public event UserDesktopInput OnUserDesktopCursor;
8554
8560 public event UserDesktopInput OnUserDesktopInput;
8561
8563 public delegate void UserRecordMediaFile(int nUserID, MediaFileInfo mediafileinfo);
8564
8569 public event UserRecordMediaFile OnUserRecordMediaFile;
8570
8572 public delegate void NewAudioBlock(int nUserID, StreamType nStreamType);
8573
8583 public event NewAudioBlock OnUserAudioBlock;
8584
8586 public delegate void ErrorOccured(ClientErrorMsg clienterrormsg);
8587
8592 public event ErrorOccured OnInternalError;
8593
8596 public delegate void VoiceActivation(bool bVoiceActive);
8597
8602 public event VoiceActivation OnVoiceActivation;
8603
8609 public delegate void HotKeyToggle(int nHotKeyID, bool bActive);
8610
8619 public event HotKeyToggle OnHotKeyToggle;
8620
8625 public delegate void HotKeyTest(int nVkCode, bool bActive);
8626
8643 public event HotKeyTest OnHotKeyTest;
8644
8648 public delegate void FileTransferUpdate(FileTransfer filetransfer);
8649
8661 public event FileTransferUpdate OnFileTransfer;
8662
8672 public delegate void DesktopTransferUpdate(int nSessionID, int nBytesRemain);
8673
8683 public event DesktopTransferUpdate OnDesktopWindowTransfer;
8684
8686 public delegate void StreamMediaFile(MediaFileInfo mediafileinfo);
8687
8692 public event StreamMediaFile OnStreamMediaFile;
8693
8695 public delegate void LocalMediaFile(MediaFileInfo mediafileinfo);
8696
8701 public event LocalMediaFile OnLocalMediaFile;
8702
8704 public delegate void AudioInput(AudioInputProgress aip);
8705
8710 public event AudioInput OnAudioInput;
8711
8714 //TTDLL instance
8715 private IntPtr m_ttInst;
8716 //TTDLL event handler
8717 c_tt.MyEventHandler m_eventhandler;
8718 }
8719
8728 public class TeamTalk5 : TeamTalkBase
8729 {
8730 public const int DEFAULT_TCPPORT = 10333;
8731 public const int DEFAULT_UDPPORT = 10333;
8732
8734 public TeamTalk5(bool poll_based)
8735 : base(poll_based)
8736 {
8737 }
8738 }
8739
8745 public class TeamTalk5Pro : TeamTalkBase
8746 {
8747 public const int DEFAULT_TCPPORT = 10443;
8748 public const int DEFAULT_UDPPORT = 10443;
8749
8751 public TeamTalk5Pro(bool poll_based)
8752 : base(poll_based)
8753 {
8754 }
8755 }
8764 public enum TTKeyTranslate : uint
8765 {
8767 TTKEY_NO_TRANSLATE = 0,
8771 TTKEY_WINKEYCODE_TO_TTKEYCODE = 1,
8773 TTKEY_TTKEYCODE_TO_WINKEYCODE = 2,
8777 TTKEY_MACKEYCODE_TO_TTKEYCODE = 3,
8780 TTKEY_TTKEYCODE_TO_MACKEYCODE = 4
8781 }
8782
8804 public enum MixerControl : uint
8805 {
8806 WAVEOUT_MASTER,
8807 WAVEOUT_WAVE,
8808 WAVEOUT_MICROPHONE,
8809
8810 WAVEIN_MICROPHONE,
8811 WAVEIN_LINEIN,
8812 WAVEIN_WAVEOUT,
8813 }
8814
8818 public class WindowsMixer
8819 {
8826 public static int GetMixerCount()
8827 {
8828 return TTDLL.TT_Mixer_GetMixerCount();
8829 }
8836 public static bool GetMixerName(int nMixerIndex,
8837 ref string szMixerName)
8838 {
8839 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8840 bool b = TTDLL.TT_Mixer_GetMixerName(nMixerIndex, ptr);
8841 if(b)
8842 szMixerName = Marshal.PtrToStringUni(ptr);
8843
8844 Marshal.FreeHGlobal(ptr);
8845 return b;
8846 }
8854 public static bool GetWaveInName(int nWaveDeviceID,
8855 ref string szMixerName)
8856 {
8857 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8858 bool b = TTDLL.TT_Mixer_GetWaveInName(nWaveDeviceID, ptr);
8859 if(b)
8860 szMixerName = Marshal.PtrToStringUni(ptr);
8861 Marshal.FreeHGlobal(ptr);
8862 return b;
8863 }
8871 public static bool GetWaveOutName(int nWaveDeviceID,
8872 ref string szMixerName)
8873 {
8874 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8875 bool b = TTDLL.TT_Mixer_GetWaveOutName(nWaveDeviceID, ptr);
8876 if(b)
8877 szMixerName = Marshal.PtrToStringUni(ptr);
8878
8879 Marshal.FreeHGlobal(ptr);
8880 return b;
8881 }
8882
8893 public static bool SetWaveOutMute(int nWaveDeviceID, MixerControl nControl, bool bMute)
8894 {
8895 return TTDLL.TT_Mixer_SetWaveOutMute(nWaveDeviceID, nControl, bMute);
8896 }
8906 public static int GetWaveOutMute(int nWaveDeviceID, MixerControl nControl)
8907 {
8908 return TTDLL.TT_Mixer_GetWaveOutMute(nWaveDeviceID, nControl);
8909 }
8918 public static bool SetWaveOutVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
8919 {
8920 return TTDLL.TT_Mixer_SetWaveOutVolume(nWaveDeviceID, nControl, nVolume);
8921 }
8930 public static int GetWaveOutVolume(int nWaveDeviceID, MixerControl nControl)
8931 {
8932 return TTDLL.TT_Mixer_GetWaveOutVolume(nWaveDeviceID, nControl);
8933 }
8941 public static bool SetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
8942 {
8943 return TTDLL.TT_Mixer_SetWaveInSelected(nWaveDeviceID, nControl);
8944 }
8953 public static int GetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
8954 {
8955 return TTDLL.TT_Mixer_GetWaveInSelected(nWaveDeviceID, nControl);
8956 }
8965 public static bool SetWaveInVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
8966 {
8967 return TTDLL.TT_Mixer_SetWaveInVolume(nWaveDeviceID, nControl, nVolume);
8968 }
8977 public static int GetWaveInVolume(int nWaveDeviceID, MixerControl nControl)
8978 {
8979 return TTDLL.TT_Mixer_GetWaveInVolume(nWaveDeviceID, nControl);
8980 }
8987 public static bool SetWaveInBoost(int nWaveDeviceID, bool bEnable)
8988 {
8989 return TTDLL.TT_Mixer_SetWaveInBoost(nWaveDeviceID, bEnable);
8990 }
8997 public static int GetWaveInBoost(int nWaveDeviceID)
8998 {
8999 return TTDLL.TT_Mixer_GetWaveInBoost(nWaveDeviceID);
9000 }
9007 public static bool SetWaveInMute(int nWaveDeviceID, bool bEnable)
9008 {
9009 return TTDLL.TT_Mixer_SetWaveInMute(nWaveDeviceID, bEnable);
9010 }
9017 public static int GetWaveInMute(int nWaveDeviceID)
9018 {
9019 return TTDLL.TT_Mixer_GetWaveInMute(nWaveDeviceID);
9020 }
9029 public static int GetWaveInControlCount(int nWaveDeviceID)
9030 {
9031 return TTDLL.TT_Mixer_GetWaveInControlCount(nWaveDeviceID);
9032 }
9043 public static bool GetWaveInControlName(int nWaveDeviceID, int nControlIndex,
9044 ref string szDeviceName)
9045 {
9046 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
9047 bool b = TTDLL.TT_Mixer_GetWaveInControlName(nWaveDeviceID, nControlIndex, ptr);
9048 if(b)
9049 szDeviceName = Marshal.PtrToStringUni(ptr);
9050 Marshal.FreeHGlobal(ptr);
9051 return b;
9052 }
9062 public static bool SetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
9063 {
9064 return TTDLL.TT_Mixer_SetWaveInControlSelected(nWaveDeviceID, nControlIndex);
9065 }
9075 public static bool GetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
9076 {
9077 return TTDLL.TT_Mixer_GetWaveInControlSelected(nWaveDeviceID, nControlIndex);
9078 }
9079 }
9088 public class WindowsFirewall
9089 {
9095 public static bool IsEnabled()
9096 {
9097 return TTDLL.TT_Firewall_IsEnabled();
9098 }
9108 public static bool Enable(bool bEnable)
9109 {
9110 return TTDLL.TT_Firewall_Enable(bEnable);
9111 }
9118 public static bool AppExceptionExists(string szExecutable)
9119 {
9120 return TTDLL.TT_Firewall_AppExceptionExists(szExecutable);
9121 }
9131 public static bool AddAppException(string szName, string szExecutable)
9132 {
9133 return TTDLL.TT_Firewall_AddAppException(szName, szExecutable);
9134 }
9144 public static bool RemoveAppException(string szExecutable)
9145 {
9146 return TTDLL.TT_Firewall_RemoveAppException(szExecutable);
9147 }
9148 }
9154 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
9155 public struct ShareWindow
9156 {
9158 public IntPtr hWnd;
9160 public int nWndX;
9162 public int nWndY;
9164 public int nWidth;
9166 public int nHeight;
9168 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
9169 public string szWindowTitle;
9170 }
9171
9175 public class WindowsHelper
9176 {
9179 public static System.IntPtr GetDesktopActiveHWND()
9180 {
9181 return TTDLL.TT_Windows_GetDesktopActiveHWND();
9182 }
9183
9185 public static System.IntPtr GetDesktopHWND()
9186 {
9187 return TTDLL.TT_Windows_GetDesktopHWND();
9188 }
9189
9191 public static bool GetDesktopWindowHWND(int nIndex,
9192 ref System.IntPtr lpHWnd)
9193 {
9194 return TTDLL.TT_Windows_GetDesktopWindowHWND(nIndex, ref lpHWnd);
9195 }
9196
9199 public static bool GetWindow(System.IntPtr hWnd,
9200 ref ShareWindow lpShareWindow)
9201 {
9202 return TTDLL.TT_Windows_GetWindow(hWnd, ref lpShareWindow);
9203 }
9204
9224 public static int DesktopInputKeyTranslate(TTKeyTranslate nTranslate,
9225 DesktopInput[] lpDesktopInputs,
9226 out DesktopInput[] lpTranslatedDesktopInputs)
9227 {
9228 lpTranslatedDesktopInputs = new DesktopInput[lpDesktopInputs.Length];
9229 return TTDLL.TT_DesktopInput_KeyTranslate(nTranslate, lpDesktopInputs,
9230 lpTranslatedDesktopInputs,
9231 lpDesktopInputs.Length);
9232 }
9233
9254 public static int DesktopInputExecute(DesktopInput[] lpDesktopInputs)
9255 {
9256 return TTDLL.TT_DesktopInput_Execute(lpDesktopInputs, lpDesktopInputs.Length);
9257 }
9258
9259 }
9260 }
BearWare.TeamTalk5
Class used to load TeamTalk5.dll and instantiate a TeamTalk client in TeamTalk 5 SDK Standard Edition...
Definition: TeamTalk.cs:8729
BearWare.TeamTalk5.TeamTalk5
TeamTalk5(bool poll_based)
Simply calls TeamTalkBase.TeamTalkBase()
Definition: TeamTalk.cs:8734
BearWare.TeamTalk5.DEFAULT_TCPPORT
const int DEFAULT_TCPPORT
Definition: TeamTalk.cs:8730
BearWare.TeamTalk5.DEFAULT_UDPPORT
const int DEFAULT_UDPPORT
Definition: TeamTalk.cs:8731
BearWare.TeamTalk5Pro
Class used to load TeamTalk5Pro.dll and instantiate a TeamTalk client in TeamTalk 5 SDK Professional ...
Definition: TeamTalk.cs:8746
BearWare.TeamTalk5Pro.DEFAULT_UDPPORT
const int DEFAULT_UDPPORT
Definition: TeamTalk.cs:8748
BearWare.TeamTalk5Pro.DEFAULT_TCPPORT
const int DEFAULT_TCPPORT
Definition: TeamTalk.cs:8747
BearWare.TeamTalk5Pro.TeamTalk5Pro
TeamTalk5Pro(bool poll_based)
Simply calls TeamTalkBase.TeamTalkBase()
Definition: TeamTalk.cs:8751
BearWare.TeamTalkBase
Abstract class which encapsulates the TeamTalk 5 client. Instantiate either BearWare....
Definition: TeamTalk.cs:4172
BearWare.TeamTalkBase.DBG_WriteAudioFileTone
bool DBG_WriteAudioFileTone(MediaFileInfo lpMediaFileInfo, int nFrequency)
Definition: TeamTalk.cs:8219
BearWare.TeamTalkBase.DBG_SetSoundInputTone
bool DBG_SetSoundInputTone(StreamType uStreamTypes, int nFrequency)
Definition: TeamTalk.cs:8213
BearWare.WindowsFirewall
A wrapper for the Windows Firewall API.
Definition: TeamTalk.cs:9089
BearWare.WindowsFirewall.Enable
static bool Enable(bool bEnable)
Enable/disable the Windows Firewall.
Definition: TeamTalk.cs:9108
BearWare.WindowsFirewall.RemoveAppException
static bool RemoveAppException(string szExecutable)
Remove an application from the Windows Firewall exception list.
Definition: TeamTalk.cs:9144
BearWare.WindowsFirewall.IsEnabled
static bool IsEnabled()
Check if the Windows Firewall is currently enabled.
Definition: TeamTalk.cs:9095
BearWare.WindowsFirewall.AddAppException
static bool AddAppException(string szName, string szExecutable)
Add an application to the Windows Firewall exception list.
Definition: TeamTalk.cs:9131
BearWare.WindowsFirewall.AppExceptionExists
static bool AppExceptionExists(string szExecutable)
Check if an executable is already in the Windows Firewall exception list.
Definition: TeamTalk.cs:9118
BearWare.WindowsHelper
Helper class for extracting Windows HWND handles and controlling mouse and keyboard.
Definition: TeamTalk.cs:9176
BearWare.WindowsHelper.GetWindow
static bool GetWindow(System.IntPtr hWnd, ref ShareWindow lpShareWindow)
Get the properties of a window from its window handle (HWND).
Definition: TeamTalk.cs:9199
BearWare.WindowsHelper.GetDesktopWindowHWND
static bool GetDesktopWindowHWND(int nIndex, ref System.IntPtr lpHWnd)
Get the all the handles (HWND) of visible windows.
Definition: TeamTalk.cs:9191
BearWare.WindowsHelper.GetDesktopActiveHWND
static System.IntPtr GetDesktopActiveHWND()
Get the handle (HWND) of the window which is currently active (focused) on the Windows desktop.
Definition: TeamTalk.cs:9179
BearWare.WindowsHelper.DesktopInputKeyTranslate
static int DesktopInputKeyTranslate(TTKeyTranslate nTranslate, DesktopInput[] lpDesktopInputs, out DesktopInput[] lpTranslatedDesktopInputs)
Translate platform key-code to and from TeamTalk's intermediate format.
Definition: TeamTalk.cs:9224
BearWare.WindowsHelper.DesktopInputExecute
static int DesktopInputExecute(DesktopInput[] lpDesktopInputs)
Execute desktop (mouse or keyboard) input.
Definition: TeamTalk.cs:9254
BearWare.WindowsHelper.GetDesktopHWND
static System.IntPtr GetDesktopHWND()
Get the handle (HWND) of the Windows desktop (full desktop).
Definition: TeamTalk.cs:9185
BearWare.WindowsMixer
A wrapper for the Windows Mixer API.
Definition: TeamTalk.cs:8819
BearWare.WindowsMixer.SetWaveOutVolume
static bool SetWaveOutVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
Set the volume of a Windows Mixer Wave-Out device from the 'enum' of devices.
Definition: TeamTalk.cs:8918
BearWare.WindowsMixer.GetWaveInVolume
static int GetWaveInVolume(int nWaveDeviceID, MixerControl nControl)
Get the volume of a Windows Mixer Wave-In device from the 'enum' of devices.
Definition: TeamTalk.cs:8977
BearWare.WindowsMixer.SetWaveOutMute
static bool SetWaveOutMute(int nWaveDeviceID, MixerControl nControl, bool bMute)
Mute or unmute a Windows Mixer Wave-Out device from the 'enum' of devices.
Definition: TeamTalk.cs:8893
BearWare.WindowsMixer.GetWaveOutName
static bool GetWaveOutName(int nWaveDeviceID, ref string szMixerName)
Get the name of the mixer associated with a wave-out device.
Definition: TeamTalk.cs:8871
BearWare.WindowsMixer.SetWaveInControlSelected
static bool SetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
Set the selected state of a Wave-In device in the Windows Mixer.
Definition: TeamTalk.cs:9062
BearWare.WindowsMixer.SetWaveInBoost
static bool SetWaveInBoost(int nWaveDeviceID, bool bEnable)
Enable and disable microphone boost.
Definition: TeamTalk.cs:8987
BearWare.WindowsMixer.GetWaveInControlSelected
static bool GetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
Get the selected state of a Wave-In device in the Windows Mixer.
Definition: TeamTalk.cs:9075
BearWare.WindowsMixer.GetWaveInName
static bool GetWaveInName(int nWaveDeviceID, ref string szMixerName)
Get the name of the mixer associated with a wave-in device.
Definition: TeamTalk.cs:8854
BearWare.WindowsMixer.SetWaveInSelected
static bool SetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
Set the selected state of a Windows Mixer Wave-In device from the 'enum' of devices.
Definition: TeamTalk.cs:8941
BearWare.WindowsMixer.GetWaveInBoost
static int GetWaveInBoost(int nWaveDeviceID)
See if microphone boost is enabled.
Definition: TeamTalk.cs:8997
BearWare.WindowsMixer.SetWaveInMute
static bool SetWaveInMute(int nWaveDeviceID, bool bEnable)
Mute/unmute microphone input.
Definition: TeamTalk.cs:9007
BearWare.WindowsMixer.GetMixerCount
static int GetMixerCount()
Get the number of Windows Mixers available.
Definition: TeamTalk.cs:8826
BearWare.WindowsMixer.GetWaveOutVolume
static int GetWaveOutVolume(int nWaveDeviceID, MixerControl nControl)
Get the volume of a Windows Mixer Wave-Out device from the 'enum' of devices.
Definition: TeamTalk.cs:8930
BearWare.WindowsMixer.SetWaveInVolume
static bool SetWaveInVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
Set the volume of a Windows Mixer Wave-In device from the 'enum' of devices.
Definition: TeamTalk.cs:8965
BearWare.WindowsMixer.GetWaveInSelected
static int GetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
Get the selected state of a Windows Mixer Wave-In device from the 'enum' of devices.
Definition: TeamTalk.cs:8953
BearWare.WindowsMixer.GetWaveInMute
static int GetWaveInMute(int nWaveDeviceID)
See if microphone is muted.
Definition: TeamTalk.cs:9017
BearWare.WindowsMixer.GetWaveInControlCount
static int GetWaveInControlCount(int nWaveDeviceID)
Get the number of Windows Mixer Wave-In devices.
Definition: TeamTalk.cs:9029
BearWare.WindowsMixer.GetWaveOutMute
static int GetWaveOutMute(int nWaveDeviceID, MixerControl nControl)
Get the mute state of a Windows Mixer Wave-Out device from the 'enum' of devices.
Definition: TeamTalk.cs:8906
BearWare.WindowsMixer.GetWaveInControlName
static bool GetWaveInControlName(int nWaveDeviceID, int nControlIndex, ref string szDeviceName)
Get the name of the Wave-In device with the specified index.
Definition: TeamTalk.cs:9043
BearWare.WindowsMixer.GetMixerName
static bool GetMixerName(int nMixerIndex, ref string szMixerName)
Get the name of a Windows Mixer based on its name.
Definition: TeamTalk.cs:8836
BearWare.TeamTalkBase.GetRootChannelID
int GetRootChannelID()
Get the root channel's ID.
Definition: TeamTalk.cs:7532
BearWare.TeamTalkBase.TT_TRANSMITUSERS_STREAMTYPE_INDEX
const int TT_TRANSMITUSERS_STREAMTYPE_INDEX
Definition: TeamTalk.cs:4229
BearWare.FileTransferStatus
FileTransferStatus
Status of a file transfer.
Definition: TeamTalk.cs:2754
BearWare.TeamTalkBase.GetChannelFile
bool GetChannelFile(int nChannelID, int nFileID, ref RemoteFile lpRemoteFile)
Get information about a file which can be downloaded.
Definition: TeamTalk.cs:7627
BearWare.TeamTalkBase.TT_TRANSMITQUEUE_MAX
const int TT_TRANSMITQUEUE_MAX
Definition: TeamTalk.cs:4273
BearWare.TeamTalkBase.ChannelID
int ChannelID
Same as GetMyChannelID().
Definition: TeamTalk.cs:7549
BearWare.TeamTalkBase.TT_CLASSROOM_STREAMTYPE_INDEX
const int TT_CLASSROOM_STREAMTYPE_INDEX
Definition: TeamTalk.cs:4217
BearWare.TeamTalkBase.TT_CLASSROOM_FREEFORALL
const int TT_CLASSROOM_FREEFORALL
Definition: TeamTalk.cs:4209
BearWare.TeamTalkBase.GetChannelIDFromPath
int GetChannelIDFromPath(string szChannelPath)
Get the channel ID of the supplied path. Channels are separated by '/'.
Definition: TeamTalk.cs:7582
BearWare.TeamTalkBase.TT_TRANSMITUSERS_USERID_INDEX
const int TT_TRANSMITUSERS_USERID_INDEX
Definition: TeamTalk.cs:4225
BearWare.ChannelType
ChannelType
The types of channels supported.
Definition: TeamTalk.cs:2515
BearWare.TeamTalkBase.IsChannelOperator
bool IsChannelOperator(int nUserID, int nChannelID)
Check whether user is operator of a channel.
Definition: TeamTalk.cs:7637
BearWare.TeamTalkBase.GetMyChannelID
int GetMyChannelID()
Get the channel which the local client instance is currently participating in.
Definition: TeamTalk.cs:7542
BearWare.TeamTalkBase.GetServerChannels
bool GetServerChannels(out Channel[] lpChannels)
Get all the channels on the server.
Definition: TeamTalk.cs:7647
BearWare.TeamTalkBase.GetChannelUsers
bool GetChannelUsers(int nChannelID, out User[] lpUsers)
Get the IDs of all users in a channel.
Definition: TeamTalk.cs:7594
BearWare.TeamTalkBase.GetChannel
bool GetChannel(int nChannelID, ref Channel lpChannel)
Get the channel with a specific ID.
Definition: TeamTalk.cs:7557
BearWare.TeamTalkBase.TT_CLASSROOM_USERID_INDEX
const int TT_CLASSROOM_USERID_INDEX
Definition: TeamTalk.cs:4213
BearWare.TeamTalkBase.TT_TRANSMITUSERS_FREEFORALL
const int TT_TRANSMITUSERS_FREEFORALL
Definition: TeamTalk.cs:4221
BearWare.TeamTalkBase.GetChannelPath
bool GetChannelPath(int nChannelID, ref string szChannelPath)
Get the channel's path. Channels are separated by '/'.
Definition: TeamTalk.cs:7567
BearWare.TeamTalkBase.GetChannelFiles
bool GetChannelFiles(int nChannelID, out RemoteFile[] lpRemoteFiles)
Get the list of the files in a channel which can be downloaded.
Definition: TeamTalk.cs:7611
BearWare.TeamTalkBase.TT_TRANSMITUSERS_MAX
const int TT_TRANSMITUSERS_MAX
The maximum number of users allowed to transmit when a BearWare.Channel is configured with BearWare....
Definition: TeamTalk.cs:4200
BearWare.TeamTalkBase.CancelFileTranfer
bool CancelFileTranfer(int nTransferID)
Cancel an active file transfer.
Definition: TeamTalk.cs:8092
BearWare.TeamTalkBase.GetFileTransferInfo
bool GetFileTransferInfo(int nTransferID, ref FileTransfer lpFileTransfer)
Get information about an active file transfer.
Definition: TeamTalk.cs:8079
BearWare.FileTransferStatus.FILETRANSFER_CLOSED
@ FILETRANSFER_CLOSED
BearWare.FileTransferStatus.FILETRANSFER_ACTIVE
@ FILETRANSFER_ACTIVE
File transfer active.
BearWare.FileTransferStatus.FILETRANSFER_FINISHED
@ FILETRANSFER_FINISHED
File transfer finished.
BearWare.FileTransferStatus.FILETRANSFER_ERROR
@ FILETRANSFER_ERROR
Error during file transfer.
BearWare.ChannelType.CHANNEL_NO_VOICEACTIVATION
@ CHANNEL_NO_VOICEACTIVATION
Don't allow voice transmission if it's trigged by voice activation.
BearWare.ChannelType.CHANNEL_PERMANENT
@ CHANNEL_PERMANENT
A channel which persists even when the last user leaves the channel.
BearWare.ChannelType.CHANNEL_OPERATOR_RECVONLY
@ CHANNEL_OPERATOR_RECVONLY
Only channel operators (and administrators) will receive audio/video/desktop transmissions....
BearWare.ChannelType.CHANNEL_DEFAULT
@ CHANNEL_DEFAULT
A default channel is a channel which disappears after the last user leaves the channel.
BearWare.ChannelType.CHANNEL_CLASSROOM
@ CHANNEL_CLASSROOM
Voice and video transmission in the channel is controlled by a channel operator.
BearWare.ChannelType.CHANNEL_NO_RECORDING
@ CHANNEL_NO_RECORDING
Don't allow recording to files in the channel.
BearWare.ChannelType.CHANNEL_SOLO_TRANSMIT
@ CHANNEL_SOLO_TRANSMIT
Only one user can transmit at a time.
BearWare.ChannelType.CHANNEL_HIDDEN
@ CHANNEL_HIDDEN
Hidden channel which can only be seen with BearWare.UserRight.USERRIGHT_VIEW_HIDDEN_CHANNELS.
BearWare.Codec
Codec
The codecs supported.
Definition: TeamTalk.cs:1514
BearWare.AudioPreprocessorType
AudioPreprocessorType
The types of supported audio preprocessors.
Definition: TeamTalk.cs:1422
BearWare.Codec.WEBM_VP8_CODEC
@ WEBM_VP8_CODEC
WebM video codec.
BearWare.Codec.SPEEX_VBR_CODEC
@ SPEEX_VBR_CODEC
Speex audio codec in VBR mode, http://www.speex.org.
BearWare.Codec.NO_CODEC
@ NO_CODEC
No codec specified.
BearWare.Codec.SPEEX_CODEC
@ SPEEX_CODEC
Speex audio codec, http://www.speex.org.
BearWare.Codec.OPUS_CODEC
@ OPUS_CODEC
OPUS audio codec.
BearWare.AudioPreprocessorType.SPEEXDSP_AUDIOPREPROCESSOR
@ SPEEXDSP_AUDIOPREPROCESSOR
Use the BearWare.SpeexDSP audio preprocessor.
BearWare.AudioPreprocessorType.WEBRTC_AUDIOPREPROCESSOR
@ WEBRTC_AUDIOPREPROCESSOR
Use WebRTC's audio preprocessor from BearWare.WebRTCAudioPreprocessor. https://webrtc....
BearWare.AudioPreprocessorType.TEAMTALK_AUDIOPREPROCESSOR
@ TEAMTALK_AUDIOPREPROCESSOR
Use TeamTalk's internal audio preprocessor BearWare.TTAudioPreprocessor.
BearWare.AudioPreprocessorType.NO_AUDIOPREPROCESSOR
@ NO_AUDIOPREPROCESSOR
Value for specifying that no audio preprocessing should occur.
BearWare.TeamTalkBase.DoRecvFile
int DoRecvFile(int nChannelID, int nFileID, string szLocalFilePath)
Download a file from the specified channel.
Definition: TeamTalk.cs:6997
BearWare.TeamTalkBase.DoPing
int DoPing()
Ping server and wait for server to reply.
Definition: TeamTalk.cs:6623
BearWare.TeamTalkBase.DoJoinChannel
int DoJoinChannel(Channel lpChannel)
Create a new channel and join it.
Definition: TeamTalk.cs:6734
BearWare.TeamTalkBase.DoListBans
int DoListBans(int nChannelID, int nIndex, int nCount)
Issue a command to list the banned users.
Definition: TeamTalk.cs:7425
BearWare.TeamTalkBase.DoUnBanUser
int DoUnBanUser(string szIPAddress, int nChannelID)
Unban the user with the specified IP-address.
Definition: TeamTalk.cs:7386
BearWare.TeamTalkBase.DoMoveUser
int DoMoveUser(int nUserID, int nChannelID)
Issue command to move a user from one channel to another.
Definition: TeamTalk.cs:7170
BearWare.TeamTalkBase.DoBanUser
int DoBanUser(int nUserID, int nChannelID)
Issue a ban command on a user in a specific channel.
Definition: TeamTalk.cs:7297
BearWare.TeamTalkBase.DoChannelOpEx
int DoChannelOpEx(int nUserID, int nChannelID, string szOpPassword, bool bMakeOperator)
Make another user operator of a channel using the szOpPassword of BearWare.Channel.
Definition: TeamTalk.cs:6897
BearWare.TeamTalkBase.DoBanUserEx
int DoBanUserEx(int nUserID, BanType uBanTypes)
Ban the user with nUserID using the ban types specified.
Definition: TeamTalk.cs:7313
BearWare.TeamTalkBase.DoChangeStatus
int DoChangeStatus(int nStatusMode, string szStatusMessage)
Change the client instance's currect status.
Definition: TeamTalk.cs:6828
BearWare.TeamTalkBase.DoSendFile
int DoSendFile(int nChannelID, string szLocalFilePath)
Send a file to the specified channel.
Definition: TeamTalk.cs:6964
BearWare.TeamTalkBase.DoLogin
int DoLogin(string szNickname, string szUsername, string szPassword)
Same as DologinEx() but without the option to specify szClientName. Kept for backwards compatibility.
Definition: TeamTalk.cs:6639
BearWare.TeamTalkBase.DoChannelOp
int DoChannelOp(int nUserID, int nChannelID, bool bMakeOperator)
Make another user operator of a channel.
Definition: TeamTalk.cs:6874
BearWare.TeamTalkBase.DoDeleteUserAccount
int DoDeleteUserAccount(string szUsername)
Issue command to delete a user account on the server.
Definition: TeamTalk.cs:7266
BearWare.TeamTalkBase.DoUnsubscribe
int DoUnsubscribe(int nUserID, Subscription uSubscriptions)
Unsubscribe to user events/data. This can be used to ignore messages or voice data from a specific us...
Definition: TeamTalk.cs:7060
BearWare.TeamTalkBase.DoQueryServerStats
int DoQueryServerStats()
Get the server's current statistics.
Definition: TeamTalk.cs:7466
BearWare.TeamTalkBase.DoMakeChannel
int DoMakeChannel(Channel lpChannel)
Make a new channel on the server.
Definition: TeamTalk.cs:7089
BearWare.TeamTalkBase.DoKickUser
int DoKickUser(int nUserID, int nChannelID)
Kick user from either channel or server.
Definition: TeamTalk.cs:6926
BearWare.TeamTalkBase.DoSaveConfig
int DoSaveConfig()
Save the server's current state to its settings file (typically the server's .xml file).
Definition: TeamTalk.cs:7446
BearWare.TeamTalkBase.DoDeleteFile
int DoDeleteFile(int nChannelID, int nFileID)
Delete a file from a channel.
Definition: TeamTalk.cs:7023
BearWare.TeamTalkBase.DoQuit
int DoQuit()
Quit from server.
Definition: TeamTalk.cs:7482
BearWare.TeamTalkBase.DoUpdateChannel
int DoUpdateChannel(Channel lpChannel)
Update a channel's properties.
Definition: TeamTalk.cs:7125
BearWare.TeamTalkBase.DoLeaveChannel
int DoLeaveChannel()
Leave the current channel.
Definition: TeamTalk.cs:6784
BearWare.TeamTalkBase.DoUnBanUserEx
int DoUnBanUserEx(BannedUser lpBannedUser)
Unban the properties specified in BearWare.BannedUser.
Definition: TeamTalk.cs:7400
BearWare.TeamTalkBase.DoNewUserAccount
int DoNewUserAccount(UserAccount lpUserAccount)
Issue command to create a new user account on the server.
Definition: TeamTalk.cs:7244
BearWare.TeamTalkBase.DoSubscribe
int DoSubscribe(int nUserID, Subscription uSubscriptions)
Subscribe to user events and/or data.
Definition: TeamTalk.cs:7041
BearWare.TeamTalkBase.DoBanIPAddress
int DoBanIPAddress(string szIPAddress, int nChannelID)
Issue a ban command on an IP-address user.
Definition: TeamTalk.cs:7361
BearWare.TeamTalkBase.DoLoginEx
int DoLoginEx(string szNickname, string szUsername, string szPassword, string szClientName)
Logon to a server.
Definition: TeamTalk.cs:6673
BearWare.TeamTalkBase.DoBan
int DoBan(BannedUser lpBannedUser)
Ban the properties specified in lpBannedUser.
Definition: TeamTalk.cs:7336
BearWare.TeamTalkBase.DoJoinChannelByID
int DoJoinChannelByID(int nChannelID, string szPassword)
Join an existing channel.
Definition: TeamTalk.cs:6761
BearWare.TeamTalkBase.DoLogout
int DoLogout()
Logout of the server.
Definition: TeamTalk.cs:6691
BearWare.TeamTalkBase.DoChangeNickname
int DoChangeNickname(string szNewNick)
Change the client instance's nick name.
Definition: TeamTalk.cs:6805
BearWare.TeamTalkBase.DoListUserAccounts
int DoListUserAccounts(int nIndex, int nCount)
Issue command to list user accounts on the server.
Definition: TeamTalk.cs:7218
BearWare.TeamTalkBase.DoUpdateServer
int DoUpdateServer(ServerProperties lpServerProperties)
Update server properties.
Definition: TeamTalk.cs:7190
BearWare.TeamTalkBase.DoRemoveChannel
int DoRemoveChannel(int nChannelID)
Remove a channel from a server.
Definition: TeamTalk.cs:7147
BearWare.TeamTalkBase.DoTextMessage
int DoTextMessage(TextMessage lpTextMessage)
Send a text message to either a user or a channel.
Definition: TeamTalk.cs:6850
BearWare.TeamTalkBase.Connect
bool Connect(string szHostAddress, int nTcpPort, int nUdpPort, int nLocalTcpPort, int nLocalUdpPort, bool bEncrypted)
Connect to a server.
Definition: TeamTalk.cs:6461
BearWare.TeamTalkBase.SetClientKeepAlive
bool SetClientKeepAlive(ClientKeepAlive lpClientKeepAlive)
Update the client instance's default keep alive settings.
Definition: TeamTalk.cs:6586
BearWare.TeamTalkBase.ConnectSysID
bool ConnectSysID(string szHostAddress, int nTcpPort, int nUdpPort, int nLocalTcpPort, int nLocalUdpPort, bool bEncrypted, string szSystemID)
Same as Connect() but the option of providing a unique system-ID.
Definition: TeamTalk.cs:6495
BearWare.TeamTalkBase.GetClientStatistics
bool GetClientStatistics(ref ClientStatistics lpClientStatistics)
Retrieve client statistics of bandwidth usage and response times.
Definition: TeamTalk.cs:6567
BearWare.TeamTalkBase.QueryMaxPayload
bool QueryMaxPayload(int nUserID)
Query the maximum size of UDP data packets to the user or server.
Definition: TeamTalk.cs:6558
BearWare.TeamTalkBase.ConnectEx
bool ConnectEx(string szHostAddress, int nTcpPort, int nUdpPort, string szBindIPAddr, int nLocalTcpPort, int nLocalUdpPort, bool bEncrypted)
Bind to specific IP-address prior to connecting to server.
Definition: TeamTalk.cs:6528
BearWare.TeamTalkBase.SetEncryptionContext
bool SetEncryptionContext(EncryptionContext lpEncryptionContext)
Setup encryption properties prior to Connect().
Definition: TeamTalk.cs:6428
BearWare.TeamTalkBase.Disconnect
bool Disconnect()
Disconnect from the server.
Definition: TeamTalk.cs:6545
BearWare.TeamTalkBase.GetClientKeepAlive
bool GetClientKeepAlive(ref ClientKeepAlive lpClientKeepAlive)
Get the client instance's current keep alive settings.
Definition: TeamTalk.cs:6597
BearWare.DesktopInputConstants.DESKTOPINPUT_MOUSEPOS_IGNORE
const ushort DESKTOPINPUT_MOUSEPOS_IGNORE
Definition: TeamTalk.cs:869
BearWare.TeamTalkBase.AcquireUserDesktopWindowEx
DesktopWindow AcquireUserDesktopWindowEx(int nUserID, BitmapFormat nBitmapFormat)
Same as TeamTalkBase.AcquireUserDesktopWindow() except an extra option for converting bitmap to a dif...
Definition: TeamTalk.cs:6388
BearWare.TeamTalkBase.SendDesktopWindow
int SendDesktopWindow(DesktopWindow lpDesktopWindow, BitmapFormat nConvertBmpFormat)
Transmit a desktop window (bitmap) to users in the same channel.
Definition: TeamTalk.cs:6167
BearWare.DesktopInputConstants.DESKTOPINPUT_KEYCODE_IGNORE
const uint DESKTOPINPUT_KEYCODE_IGNORE
Definition: TeamTalk.cs:860
BearWare.TTKeyTranslate
TTKeyTranslate
Translate to and from TeamTalk's intermediate key-codes (TTKEYCODE).
Definition: TeamTalk.cs:8765
BearWare.DesktopKeyState
DesktopKeyState
The state of a key (or mouse button), i.e. if it's pressed or released.
Definition: TeamTalk.cs:796
BearWare.TeamTalkBase.AcquireUserDesktopWindow
DesktopWindow AcquireUserDesktopWindow(int nUserID)
Get a user's desktop window (bitmap image).
Definition: TeamTalk.cs:6372
BearWare.TeamTalkBase.PaintDesktopWindow
bool PaintDesktopWindow(int nUserID, System.IntPtr hDC, int XDest, int YDest, int nDestWidth, int nDestHeight)
Paint user's desktop window using a Windows' DC (device context).
Definition: TeamTalk.cs:6244
BearWare.TeamTalkBase.SendDesktopWindowFromHWND
int SendDesktopWindowFromHWND(System.IntPtr hWnd, BitmapFormat nBitmapFormat, DesktopProtocol nDesktopProtocol)
Transmit the specified window in a desktop session.
Definition: TeamTalk.cs:6223
BearWare.DesktopInputConstants.DESKTOPINPUT_KEYCODE_LMOUSEBTN
const uint DESKTOPINPUT_KEYCODE_LMOUSEBTN
Definition: TeamTalk.cs:877
BearWare.DesktopProtocol
DesktopProtocol
The protocols supported for transferring a BearWare.DesktopWindow.
Definition: TeamTalk.cs:752
BearWare.TeamTalkBase.PaintDesktopWindowEx
bool PaintDesktopWindowEx(int nUserID, System.IntPtr hDC, int XDest, int YDest, int nDestWidth, int nDestHeight, int XSrc, int YSrc, int nSrcWidth, int nSrcHeight)
Paint user's desktop window using a Windows' DC (device context).
Definition: TeamTalk.cs:6286
BearWare.DesktopInputConstants.DESKTOPINPUT_KEYCODE_RMOUSEBTN
const uint DESKTOPINPUT_KEYCODE_RMOUSEBTN
Definition: TeamTalk.cs:885
BearWare.TeamTalkBase.CloseDesktopWindow
bool CloseDesktopWindow()
Close the current desktop session.
Definition: TeamTalk.cs:6180
BearWare.TeamTalkBase.TT_DESKTOPINPUT_MAX
const int TT_DESKTOPINPUT_MAX
Definition: TeamTalk.cs:4283
BearWare.TeamTalkBase.SendDesktopInput
bool SendDesktopInput(int nUserID, DesktopInput[] lpDesktopInputs)
Send a mouse or keyboard event to a shared desktop window.
Definition: TeamTalk.cs:6343
BearWare.TeamTalkBase.ReleaseUserDesktopWindow
bool ReleaseUserDesktopWindow(DesktopWindow lpDesktopWindow)
Release memory allocated by the BearWare.DesktopWindow.
Definition: TeamTalk.cs:6401
BearWare.BitmapFormat
BitmapFormat
The bitmap format used for a BearWare.DesktopWindow.
Definition: TeamTalk.cs:725
BearWare.DesktopInputConstants.DESKTOPINPUT_KEYCODE_MMOUSEBTN
const uint DESKTOPINPUT_KEYCODE_MMOUSEBTN
Definition: TeamTalk.cs:893
BearWare.TeamTalkBase.SendDesktopCursorPosition
bool SendDesktopCursorPosition(ushort nPosX, ushort nPosY)
Send the position of mouse cursor to users in the same channel.
Definition: TeamTalk.cs:6314
BearWare.TeamTalkBase.Palette_GetColorTable
static System.Drawing.Color Palette_GetColorTable(BitmapFormat nBmpPalette, int nIndex)
Get RGB values of the palette for the bitmap format.
Definition: TeamTalk.cs:6201
BearWare.TTKeyTranslate.TTKEY_MACKEYCODE_TO_TTKEYCODE
@ TTKEY_MACKEYCODE_TO_TTKEYCODE
Translate from Mac OS X Carbon kVK_* key-code to TTKEYCODE. The Mac OS X key-codes are defined in Car...
BearWare.TTKeyTranslate.TTKEY_TTKEYCODE_TO_WINKEYCODE
@ TTKEY_TTKEYCODE_TO_WINKEYCODE
Translate from TTKEYCODE to Windows scan-code.
BearWare.TTKeyTranslate.TTKEY_WINKEYCODE_TO_TTKEYCODE
@ TTKEY_WINKEYCODE_TO_TTKEYCODE
Translate from Windows scan-code to TTKEYCODE. The Windows scan-code can be retrieved in Windows' WM_...
BearWare.TTKeyTranslate.TTKEY_TTKEYCODE_TO_MACKEYCODE
@ TTKEY_TTKEYCODE_TO_MACKEYCODE
Translate from TTKEYCODE to Mac OS X Carbon kVK_* key-code.
BearWare.TTKeyTranslate.TTKEY_NO_TRANSLATE
@ TTKEY_NO_TRANSLATE
Perform no translation.
BearWare.DesktopKeyState.DESKTOPKEYSTATE_DOWN
@ DESKTOPKEYSTATE_DOWN
The key is pressed.
BearWare.DesktopKeyState.DESKTOPKEYSTATE_NONE
@ DESKTOPKEYSTATE_NONE
The key is ignored.
BearWare.DesktopKeyState.DESKTOPKEYSTATE_UP
@ DESKTOPKEYSTATE_UP
The key is released.
BearWare.DesktopProtocol.DESKTOPPROTOCOL_ZLIB_1
@ DESKTOPPROTOCOL_ZLIB_1
Desktop protocol based on ZLIB for image compression and UDP for data transmission.
BearWare.BitmapFormat.BMP_RGB8_PALETTE
@ BMP_RGB8_PALETTE
The bitmap is a 256-colored bitmap requiring a palette. The default 256 colored palette is the Netsca...
BearWare.BitmapFormat.BMP_RGB24
@ BMP_RGB24
The bitmap is a 24-bit colored bitmap. The maximum size of a 24-bit bitmap is 4095 blocks of 85 by 16...
BearWare.BitmapFormat.BMP_RGB32
@ BMP_RGB32
The bitmap is a 32-bit colored bitmap. The maximum size of a 32-bit bitmap is 4095 blocks of 51 by 20...
BearWare.BitmapFormat.BMP_NONE
@ BMP_NONE
Used to denote nothing selected.
BearWare.BitmapFormat.BMP_RGB16_555
@ BMP_RGB16_555
The bitmap is a 16-bit colored bitmap. The maximum pixels.
BearWare.TeamTalkBase.GetErrorMessage
static string GetErrorMessage(ClientError nError)
Get textual discription of an error message.
Definition: TeamTalk.cs:8107
BearWare.ClientError
ClientError
Errors which can occur either as a result of client commands or as a result of internal errors.
Definition: TeamTalk.cs:3023
BearWare.ClientError.CMDERR_CHANNEL_ALREADY_EXISTS
@ CMDERR_CHANNEL_ALREADY_EXISTS
Channel already exists.
BearWare.ClientError.CMDERR_MAX_DISKUSAGE_EXCEEDED
@ CMDERR_MAX_DISKUSAGE_EXCEEDED
Cannot upload file because disk quota will be exceeded.
BearWare.ClientError.CMDERR_BAN_NOT_FOUND
@ CMDERR_BAN_NOT_FOUND
Banned IP-address does not exist.
BearWare.ClientError.CMDERR_MISSING_PARAMETER
@ CMDERR_MISSING_PARAMETER
Command cannot be performed due to missing parameter. Only used internally.
BearWare.ClientError.INTERR_SNDEFFECT_FAILURE
@ INTERR_SNDEFFECT_FAILURE
BearWare.SoundDeviceEffects failed to initialize.
BearWare.ClientError.CMDERR_COMMAND_FLOOD
@ CMDERR_COMMAND_FLOOD
Command flooding prevented by server.
BearWare.ClientError.CMDERR_INCORRECT_OP_PASSWORD
@ CMDERR_INCORRECT_OP_PASSWORD
Invalid password for becoming channel operator.
BearWare.ClientError.CMDERR_INCOMPATIBLE_PROTOCOLS
@ CMDERR_INCOMPATIBLE_PROTOCOLS
The server uses a protocol which is incompatible with the client instance.
BearWare.ClientError.CMDERR_CHANNEL_CANNOT_BE_HIDDEN
@ CMDERR_CHANNEL_CANNOT_BE_HIDDEN
Cannot apply BearWare.ChannelType.CHANNEL_HIDDEN to BearWare.Channel's channel type.
BearWare.ClientError.CMDERR_OPENFILE_FAILED
@ CMDERR_OPENFILE_FAILED
Server failed to open file.
BearWare.ClientError.CMDERR_CHANNEL_BANNED
@ CMDERR_CHANNEL_BANNED
Banned from joining a channel.
BearWare.ClientError.CMDERR_SUCCESS
@ CMDERR_SUCCESS
Command indicating success.
BearWare.ClientError.CMDERR_ALREADY_LOGGEDIN
@ CMDERR_ALREADY_LOGGEDIN
Already logged in.
BearWare.ClientError.INTERR_TTMESSAGE_QUEUE_OVERFLOW
@ INTERR_TTMESSAGE_QUEUE_OVERFLOW
BearWare.TTMessage event queue overflowed.
BearWare.ClientError.CMDERR_INCORRECT_CHANNEL_PASSWORD
@ CMDERR_INCORRECT_CHANNEL_PASSWORD
Invalid channel password.
BearWare.ClientError.CMDERR_MAX_SERVER_USERS_EXCEEDED
@ CMDERR_MAX_SERVER_USERS_EXCEEDED
Login failed due to maximum number of users on server.
BearWare.ClientError.INTERR_SNDOUTPUT_FAILURE
@ INTERR_SNDOUTPUT_FAILURE
A sound output device failed.
BearWare.ClientError.INTERR_AUDIOPREPROCESSOR_INIT_FAILED
@ INTERR_AUDIOPREPROCESSOR_INIT_FAILED
BearWare.AudioPreprocessor failed to initialize.
BearWare.ClientError.CMDERR_INVALID_USERNAME
@ CMDERR_INVALID_USERNAME
Invalid username for BearWare.UserAccount.
BearWare.ClientError.CMDERR_USER_NOT_FOUND
@ CMDERR_USER_NOT_FOUND
User not found.
BearWare.ClientError.CMDERR_AUDIOCODEC_BITRATE_LIMIT_EXCEEDED
@ CMDERR_AUDIOCODEC_BITRATE_LIMIT_EXCEEDED
The selected BearWare.AudioCodec exceeds what the server allows.
BearWare.ClientError.INTERR_AUDIOCODEC_INIT_FAILED
@ INTERR_AUDIOCODEC_INIT_FAILED
Audio codec used by channel failed to initialize. Ensure the settings specified in BearWare....
BearWare.ClientError.CMDERR_FILE_ALREADY_EXISTS
@ CMDERR_FILE_ALREADY_EXISTS
File already exist.
BearWare.ClientError.CMDERR_MAX_CHANNEL_USERS_EXCEEDED
@ CMDERR_MAX_CHANNEL_USERS_EXCEEDED
Cannot join channel because it has maximum number of users.
BearWare.ClientError.CMDERR_FILE_NOT_FOUND
@ CMDERR_FILE_NOT_FOUND
File does not exist.
BearWare.ClientError.INTERR_SNDINPUT_FAILURE
@ INTERR_SNDINPUT_FAILURE
A sound input device failed.
BearWare.ClientError.CMDERR_NOT_LOGGEDIN
@ CMDERR_NOT_LOGGEDIN
Client instance has not been authenticated.
BearWare.ClientError.CMDERR_SERVER_BANNED
@ CMDERR_SERVER_BANNED
IP-address has been banned from server.
BearWare.ClientError.CMDERR_ACCOUNT_NOT_FOUND
@ CMDERR_ACCOUNT_NOT_FOUND
Cannot find user account.
BearWare.ClientError.CMDERR_SYNTAX_ERROR
@ CMDERR_SYNTAX_ERROR
Command has syntax error. Only used internally.
BearWare.ClientError.CMDERR_CHANNEL_HAS_USERS
@ CMDERR_CHANNEL_HAS_USERS
Cannot process command since channel is not empty.
BearWare.ClientError.CMDERR_FILETRANSFER_NOT_FOUND
@ CMDERR_FILETRANSFER_NOT_FOUND
File transfer doesn't exists.
BearWare.ClientError.CMDERR_UNKNOWN_COMMAND
@ CMDERR_UNKNOWN_COMMAND
The server doesn't support the issued command.
BearWare.ClientError.CMDERR_ALREADY_IN_CHANNEL
@ CMDERR_ALREADY_IN_CHANNEL
Cannot join same channel twice.
BearWare.ClientError.CMDERR_FILESHARING_DISABLED
@ CMDERR_FILESHARING_DISABLED
Server does not allow file transfers.
BearWare.ClientError.SUCCESS
@ SUCCESS
BearWare.ClientError.CMDERR_INVALID_ACCOUNT
@ CMDERR_INVALID_ACCOUNT
Invalid username or password for account.
BearWare.ClientError.CMDERR_MAX_FILETRANSFERS_EXCEEDED
@ CMDERR_MAX_FILETRANSFERS_EXCEEDED
Maximum number of file transfers exceeded.
BearWare.ClientError.CMDERR_MAX_CHANNELS_EXCEEDED
@ CMDERR_MAX_CHANNELS_EXCEEDED
The maximum number of channels has been exceeded.
BearWare.ClientError.CMDERR_UNKNOWN_AUDIOCODEC
@ CMDERR_UNKNOWN_AUDIOCODEC
The server does not support the audio codec specified by the client. Introduced in version 4....
BearWare.ClientError.INTERR_SPEEXDSP_INIT_FAILED
@ INTERR_SPEEXDSP_INIT_FAILED
Same as BearWare.ClientError.INTERR_AUDIOPREPROCESSOR_INIT_FAILED.
BearWare.ClientError.CMDERR_MAX_LOGINS_PER_IPADDRESS_EXCEEDED
@ CMDERR_MAX_LOGINS_PER_IPADDRESS_EXCEEDED
The maximum number of logins allowed per IP-address has been exceeded.
BearWare.ClientError.CMDERR_NOT_IN_CHANNEL
@ CMDERR_NOT_IN_CHANNEL
Cannot leave channel because not in channel.
BearWare.ClientError.CMDERR_CHANNEL_NOT_FOUND
@ CMDERR_CHANNEL_NOT_FOUND
Channel does not exist.
BearWare.ClientError.CMDERR_NOT_AUTHORIZED
@ CMDERR_NOT_AUTHORIZED
Command not authorized.
BearWare.ClientError.CMDERR_LOGINSERVICE_UNAVAILABLE
@ CMDERR_LOGINSERVICE_UNAVAILABLE
The login service is currently unavailable.
BearWare.ClientError.CMDERR_INCORRECT_SERVER_PASSWORD
@ CMDERR_INCORRECT_SERVER_PASSWORD
Invalid server password.
BearWare.TeamTalkBase.ServerStats
delegate void ServerStats(ServerStatistics serverstatistics)
Delegate for event OnCmdServerStatistics.
BearWare.TeamTalkBase.UserUpdate
delegate void UserUpdate(User user)
Delegate for events OnCmdUserLoggedIn, OnCmdUserLoggedOut, OnCmdUserUpdate, OnCmdUserJoinedChannel an...
BearWare.TeamTalkBase.OnUserDesktopCursor
UserDesktopInput OnUserDesktopCursor
A user has sent the position of the mouse cursor.
Definition: TeamTalk.cs:8553
BearWare.TeamTalkBase.OnCmdUserJoinedChannel
UserUpdate OnCmdUserJoinedChannel
A user has joined a channel.
Definition: TeamTalk.cs:8406
BearWare.TeamTalkBase.OnCmdProcessing
CommandProcessing OnCmdProcessing
A command issued by Do* methods is being processed.
Definition: TeamTalk.cs:8293
BearWare.TeamTalkBase.OnHotKeyTest
HotKeyTest OnHotKeyTest
A button was pressed or released on the user's keyboard or mouse.
Definition: TeamTalk.cs:8643
BearWare.TeamTalkBase.NewAudioBlock
delegate void NewAudioBlock(int nUserID, StreamType nStreamType)
Delegate for event OnUserAudioBlock.
BearWare.TeamTalkBase.OnConnectionLost
Connection OnConnectionLost
Connection to server has been lost.
Definition: TeamTalk.cs:8256
BearWare.TeamTalkBase.OnDesktopWindowTransfer
DesktopTransferUpdate OnDesktopWindowTransfer
Used for tracking when a desktop window has been transmitted to the server.
Definition: TeamTalk.cs:8683
BearWare.TeamTalkBase.UserRecordMediaFile
delegate void UserRecordMediaFile(int nUserID, MediaFileInfo mediafileinfo)
Delegate for event OnUserRecordMediaFile.
BearWare.TeamTalkBase.OnCmdError
CommandError OnCmdError
The server rejected a command issued by the local client instance.
Definition: TeamTalk.cs:8309
BearWare.TeamTalkBase.OnConnectionMaxPayloadUpdated
MaxPayloadUpdate OnConnectionMaxPayloadUpdated
The maximum size of the payload put into UDP packets has been updated.
Definition: TeamTalk.cs:8272
BearWare.TeamTalkBase.StreamMediaFile
delegate void StreamMediaFile(MediaFileInfo mediafileinfo)
Delegate for event OnStreamMediaFile.
BearWare.TeamTalkBase.OnCmdUserUpdate
UserUpdate OnCmdUserUpdate
User changed properties.
Definition: TeamTalk.cs:8400
BearWare.TeamTalkBase.MyselfLoggedOut
delegate void MyselfLoggedOut()
Delegate for event OnCmdMyselfLoggedOut.
BearWare.TeamTalkBase.CommandSuccess
delegate void CommandSuccess(int nCmdID)
Delegate for event CommandSuccess.
BearWare.TeamTalkBase.UserVideoFrame
delegate void UserVideoFrame(int nUserID, int nStreamID)
A delegate for the event OnUserVideoCapture.
BearWare.TeamTalkBase.OnCmdChannelUpdate
ChannelUpdate OnCmdChannelUpdate
A channel's properties has been updated.
Definition: TeamTalk.cs:8444
BearWare.TeamTalkBase.ErrorOccured
delegate void ErrorOccured(ClientErrorMsg clienterrormsg)
Delegate for event OnInternalError.
BearWare.TeamTalkBase.OnUserAudioBlock
NewAudioBlock OnUserAudioBlock
A new audio block can be extracted.
Definition: TeamTalk.cs:8583
BearWare.TeamTalkBase.OnVoiceActivation
VoiceActivation OnVoiceActivation
Voice activation has triggered transmission.
Definition: TeamTalk.cs:8602
BearWare.TeamTalkBase.OnCmdMyselfLoggedOut
MyselfLoggedOut OnCmdMyselfLoggedOut
The client instance logged out of a server.
Definition: TeamTalk.cs:8351
BearWare.TeamTalkBase.OnCmdMyselfLoggedIn
MyselfLoggedIn OnCmdMyselfLoggedIn
The client instance successfully logged on to server.
Definition: TeamTalk.cs:8340
BearWare.TeamTalkBase.DesktopTransferUpdate
delegate void DesktopTransferUpdate(int nSessionID, int nBytesRemain)
Delegate for event OnDesktopWindowTransfer().
BearWare.TeamTalkBase.VoiceActivation
delegate void VoiceActivation(bool bVoiceActive)
Delegate for event OnVoiceActivation.
BearWare.TeamTalkBase.ServerUpdate
delegate void ServerUpdate(ServerProperties serverproperties)
Delegate for event OnCmdServerUpdate.
BearWare.TeamTalkBase.UserTextMessage
delegate void UserTextMessage(TextMessage textmessage)
Delegate for events OnCmdUserTextMessage.
BearWare.TeamTalkBase.OnHotKeyToggle
HotKeyToggle OnHotKeyToggle
A hotkey has been acticated or deactivated.
Definition: TeamTalk.cs:8619
BearWare.TeamTalkBase.MyselfKicked
delegate void MyselfKicked(User user)
Delegate for event OnCmdMyselfKicked.
BearWare.TeamTalkBase.OnLocalMediaFile
LocalMediaFile OnLocalMediaFile
Media file is being played locally.
Definition: TeamTalk.cs:8701
BearWare.TeamTalkBase.MaxPayloadUpdate
delegate void MaxPayloadUpdate(int nPayloadSize)
Delegate for event OnConnectionMaxPayloadUpdated().
BearWare.TeamTalkBase.OnCmdUserTextMessage
UserTextMessage OnCmdUserTextMessage
A user has sent a text-message.
Definition: TeamTalk.cs:8425
BearWare.TeamTalkBase.ChannelUpdate
delegate void ChannelUpdate(Channel channel)
Delegate for OnCmdChannelNew, OnCmdChannelUpdate and OnCmdChannelRemove.
BearWare.TeamTalkBase.HotKeyToggle
delegate void HotKeyToggle(int nHotKeyID, bool bActive)
Delegate for event OnHotKeyToggle.
BearWare.TeamTalkBase.OnAudioInput
AudioInput OnAudioInput
Audio input progress as result of TeamTalkBase.InsertAudioBlock()
Definition: TeamTalk.cs:8710
BearWare.TeamTalkBase.OnConnectionSuccess
Connection OnConnectionSuccess
Connected successfully to the server.
Definition: TeamTalk.cs:8240
BearWare.TeamTalkBase.OnCmdUserLoggedOut
UserUpdate OnCmdUserLoggedOut
A user logged out of the server.
Definition: TeamTalk.cs:8394
BearWare.TeamTalkBase.UserStreamUpdate
delegate void UserStreamUpdate(User user, int nStreamID)
Delegate for events OnUserFirstVoiceStreamPacket.
BearWare.TeamTalkBase.OnInternalError
ErrorOccured OnInternalError
A internal error occured.
Definition: TeamTalk.cs:8592
BearWare.TeamTalkBase.OnCmdSuccess
CommandSuccess OnCmdSuccess
The server successfully processed a command issued by the local client instance.
Definition: TeamTalk.cs:8323
BearWare.TeamTalkBase.OnStreamMediaFile
StreamMediaFile OnStreamMediaFile
Media file being streamed to a channel is processing.
Definition: TeamTalk.cs:8692
BearWare.TeamTalkBase.UserDesktopInput
delegate void UserDesktopInput(int nSrcUserID, DesktopInput desktopinput)
Delegate for event OnUserDesktopCursor().
BearWare.TeamTalkBase.HotKeyTest
delegate void HotKeyTest(int nVkCode, bool bActive)
Delegate for event OnHotKeyTest.
BearWare.TeamTalkBase.OnCmdMyselfKicked
MyselfKicked OnCmdMyselfKicked
The client instance was kicked from a channel.
Definition: TeamTalk.cs:8364
BearWare.TeamTalkBase.OnUserMediaFileVideo
UserVideoFrame OnUserMediaFileVideo
A new video frame was received from a user.
Definition: TeamTalk.cs:8523
BearWare.TeamTalkBase.OnUserVideoCapture
UserVideoFrame OnUserVideoCapture
A new video frame was received from a user.
Definition: TeamTalk.cs:8517
BearWare.TeamTalkBase.OnCmdChannelNew
ChannelUpdate OnCmdChannelNew
A new channel has been created.
Definition: TeamTalk.cs:8438
BearWare.TeamTalkBase.FileTransferUpdate
delegate void FileTransferUpdate(FileTransfer filetransfer)
Delegate for event OnFileTransfer.
BearWare.TeamTalkBase.OnCmdUserAccount
ListUserAccount OnCmdUserAccount
A new user account has been listed by the server. Event handler for BearWare.ClientEvent....
Definition: TeamTalk.cs:8490
BearWare.TeamTalkBase.OnUserFirstVoiceStreamPacket
UserStreamUpdate OnUserFirstVoiceStreamPacket
The first voice packet of a new voice stream has been received.
Definition: TeamTalk.cs:8503
BearWare.TeamTalkBase.OnCmdFileNew
FileUpdate OnCmdFileNew
A new file is added to a channel.
Definition: TeamTalk.cs:8477
BearWare.TeamTalkBase.NewDesktopWindow
delegate void NewDesktopWindow(int nUserID, int nStreamID)
Delegate for event OnUserDesktopWindow.
BearWare.TeamTalkBase.CommandProcessing
delegate void CommandProcessing(int nCmdID, bool bActive)
Delegate for event OnCmdProcessing.
BearWare.TeamTalkBase.OnCmdBannedUser
ListBannedUser OnCmdBannedUser
A new banned user has been listed by the server. Event handler for BearWare.ClientEvent....
Definition: TeamTalk.cs:8497
BearWare.TeamTalkBase.AudioInput
delegate void AudioInput(AudioInputProgress aip)
Delegate for event OnAudioInput.
BearWare.TTType
TTType
Definition: TeamTalk.cs:3902
BearWare.TeamTalkBase.OnCmdServerStatistics
ServerStats OnCmdServerStatistics
Server statistics available.
Definition: TeamTalk.cs:8468
BearWare.TeamTalkBase.OnUserStateChange
UserUpdate OnUserStateChange
A user's state has been updated.
Definition: TeamTalk.cs:8508
BearWare.TeamTalkBase.ListBannedUser
delegate void ListBannedUser(BannedUser banneduser)
A delegate for event OnCmdUserAccount.
BearWare.TeamTalkBase.OnUserRecordMediaFile
UserRecordMediaFile OnUserRecordMediaFile
An media file recording has changed status.
Definition: TeamTalk.cs:8569
BearWare.TeamTalkBase.LocalMediaFile
delegate void LocalMediaFile(MediaFileInfo mediafileinfo)
Delegate for event OnLocalMediaFile.
BearWare.TeamTalkBase.CommandError
delegate void CommandError(int nCmdID, ClientErrorMsg clienterrormsg)
Delegate for event OnCmdError.
BearWare.TeamTalkBase.FileUpdate
delegate void FileUpdate(RemoteFile remotefile)
A delegate for events OnCmdFileNew and OnCmdFileRemove.
BearWare.ClientEvent
ClientEvent
TeamTalk client event messages.
Definition: TeamTalk.cs:3344
BearWare.TeamTalkBase.ListUserAccount
delegate void ListUserAccount(UserAccount useraccount)
A delegate for event OnCmdUserAccount.
BearWare.TeamTalkBase.OnUserDesktopWindow
NewDesktopWindow OnUserDesktopWindow
A new or updated desktop window has been received from a user.
Definition: TeamTalk.cs:8543
BearWare.TeamTalkBase.OnCmdUserLoggedIn
UserUpdate OnCmdUserLoggedIn
A new user logged on to the server.
Definition: TeamTalk.cs:8384
BearWare.TeamTalkBase.OnCmdFileRemove
FileUpdate OnCmdFileRemove
A file has been removed from a channel.
Definition: TeamTalk.cs:8483
BearWare.TeamTalkBase.OnCmdServerUpdate
ServerUpdate OnCmdServerUpdate
Server has updated its settings (server name, MOTD, etc.)
Definition: TeamTalk.cs:8459
BearWare.TeamTalkBase.OnCmdUserLeftChannel
UserUpdate OnCmdUserLeftChannel
User has left a channel.
Definition: TeamTalk.cs:8412
BearWare.TeamTalkBase.OnFileTransfer
FileTransferUpdate OnFileTransfer
A file transfer is processing.
Definition: TeamTalk.cs:8661
BearWare.TeamTalkBase.OnConnectionFailed
Connection OnConnectionFailed
Failed to connect to server.
Definition: TeamTalk.cs:8248
BearWare.TeamTalkBase.Connection
delegate void Connection()
Delegate for events OnConnectionSuccess, OnConnectionFailed and OnConnectionLost.
BearWare.TeamTalkBase.OnUserDesktopInput
UserDesktopInput OnUserDesktopInput
Desktop input (mouse or keyboard input) has been received from a user.
Definition: TeamTalk.cs:8560
BearWare.TeamTalkBase.OnCmdChannelRemove
ChannelUpdate OnCmdChannelRemove
A channel has been removed. Event handler for BearWare.ClientEvent.CLIENTEVENT_CMD_CHANNEL_REMOVE.
Definition: TeamTalk.cs:8449
BearWare.TeamTalkBase.MyselfLoggedIn
delegate void MyselfLoggedIn(int nMyUserID, UserAccount useraccount)
Delegate for event OnCmdMyselfLoggedIn.
BearWare.TTType.__ABUSEPREVENTION
@ __ABUSEPREVENTION
BearWare.TTType.__UINT32
@ __UINT32
BearWare.TTType.__USERSTATISTICS
@ __USERSTATISTICS
BearWare.TTType.__MEDIAFILESTATUS
@ __MEDIAFILESTATUS
BearWare.TTType.__SOUNDDEVICEEFFECTS
@ __SOUNDDEVICEEFFECTS
BearWare.TTType.__TTMESSAGE
@ __TTMESSAGE
BearWare.TTType.__DESKTOPINPUT
@ __DESKTOPINPUT
BearWare.TTType.__SOUNDDEVICE
@ __SOUNDDEVICE
BearWare.TTType.__VIDEOCAPTUREDEVICE
@ __VIDEOCAPTUREDEVICE
BearWare.TTType.__STREAMTYPE
@ __STREAMTYPE
BearWare.TTType.__CLIENTSTATISTICS
@ __CLIENTSTATISTICS
BearWare.TTType.__USER
@ __USER
BearWare.TTType.__AUDIOCONFIG
@ __AUDIOCONFIG
BearWare.TTType.__OPUSCODEC
@ __OPUSCODEC
BearWare.TTType.__AUDIOFORMAT
@ __AUDIOFORMAT
BearWare.TTType.__AUDIOCODEC
@ __AUDIOCODEC
BearWare.TTType.__DESKTOPWINDOW
@ __DESKTOPWINDOW
BearWare.TTType.__MEDIAFILEPLAYBACK
@ __MEDIAFILEPLAYBACK
BearWare.TTType.__SERVERPROPERTIES
@ __SERVERPROPERTIES
BearWare.TTType.__VIDEOFRAME
@ __VIDEOFRAME
BearWare.TTType.__AUDIOPREPROCESSORTYPE
@ __AUDIOPREPROCESSORTYPE
BearWare.TTType.__SPEEXVBRCODEC
@ __SPEEXVBRCODEC
BearWare.TTType.__CLIENTERRORMSG
@ __CLIENTERRORMSG
BearWare.TTType.__INT32
@ __INT32
BearWare.TTType.__CLIENTKEEPALIVE
@ __CLIENTKEEPALIVE
BearWare.TTType.__JITTERCONFIG
@ __JITTERCONFIG
BearWare.TTType.__TEXTMESSAGE
@ __TEXTMESSAGE
BearWare.TTType.__TTAUDIOPREPROCESSOR
@ __TTAUDIOPREPROCESSOR
BearWare.TTType.__SPEEXCODEC
@ __SPEEXCODEC
BearWare.TTType.__SPEEXDSP
@ __SPEEXDSP
BearWare.TTType.__FILETRANSFER
@ __FILETRANSFER
BearWare.TTType.__CHANNEL
@ __CHANNEL
BearWare.TTType.__REMOTEFILE
@ __REMOTEFILE
BearWare.TTType.__WEBRTCAUDIOPREPROCESSOR
@ __WEBRTCAUDIOPREPROCESSOR
BearWare.TTType.__AUDIOPREPROCESSOR
@ __AUDIOPREPROCESSOR
BearWare.TTType.__MEDIAFILEINFO
@ __MEDIAFILEINFO
BearWare.TTType.__AUDIOINPUTPROGRESS
@ __AUDIOINPUTPROGRESS
BearWare.TTType.__SERVERSTATISTICS
@ __SERVERSTATISTICS
BearWare.TTType.__AUDIOBLOCK
@ __AUDIOBLOCK
BearWare.TTType.__USERACCOUNT
@ __USERACCOUNT
BearWare.TTType.__NONE
@ __NONE
BearWare.TTType.__BANNEDUSER
@ __BANNEDUSER
BearWare.TTType.__VIDEOCODEC
@ __VIDEOCODEC
BearWare.TTType.__TTBOOL
@ __TTBOOL
BearWare.TTType.__WEBMVP8CODEC
@ __WEBMVP8CODEC
BearWare.TTType.__VIDEOFORMAT
@ __VIDEOFORMAT
BearWare.TTType.__ENCRYPTIONCONTEXT
@ __ENCRYPTIONCONTEXT
BearWare.ClientEvent.CLIENTEVENT_CMD_FILE_REMOVE
@ CLIENTEVENT_CMD_FILE_REMOVE
A file has been removed from a channel.
BearWare.ClientEvent.CLIENTEVENT_CMD_CHANNEL_UPDATE
@ CLIENTEVENT_CMD_CHANNEL_UPDATE
A channel's properties has been updated.
BearWare.ClientEvent.CLIENTEVENT_USER_DESKTOPCURSOR
@ CLIENTEVENT_USER_DESKTOPCURSOR
A user has sent the position of the mouse cursor.
BearWare.ClientEvent.CLIENTEVENT_STREAM_MEDIAFILE
@ CLIENTEVENT_STREAM_MEDIAFILE
Media file being streamed to a channel is processing.
BearWare.ClientEvent.CLIENTEVENT_CMD_SUCCESS
@ CLIENTEVENT_CMD_SUCCESS
The server successfully processed a command issued by the local client instance.
BearWare.ClientEvent.CLIENTEVENT_CMD_MYSELF_KICKED
@ CLIENTEVENT_CMD_MYSELF_KICKED
The client instance was kicked from a channel.
BearWare.ClientEvent.CLIENTEVENT_USER_STATECHANGE
@ CLIENTEVENT_USER_STATECHANGE
A user state has changed.
BearWare.ClientEvent.CLIENTEVENT_CMD_MYSELF_LOGGEDOUT
@ CLIENTEVENT_CMD_MYSELF_LOGGEDOUT
The client instance logged out of the server.
BearWare.ClientEvent.CLIENTEVENT_FILETRANSFER
@ CLIENTEVENT_FILETRANSFER
A file transfer is processing.
BearWare.ClientEvent.CLIENTEVENT_CMD_USER_JOINED
@ CLIENTEVENT_CMD_USER_JOINED
A user has joined a channel.
BearWare.ClientEvent.CLIENTEVENT_HOTKEY
@ CLIENTEVENT_HOTKEY
A hotkey has been acticated or deactivated.
BearWare.ClientEvent.CLIENTEVENT_CMD_USER_UPDATE
@ CLIENTEVENT_CMD_USER_UPDATE
User changed properties.
BearWare.ClientEvent.CLIENTEVENT_LOCAL_MEDIAFILE
@ CLIENTEVENT_LOCAL_MEDIAFILE
Media file played locally is procesing.
BearWare.ClientEvent.CLIENTEVENT_HOTKEY_TEST
@ CLIENTEVENT_HOTKEY_TEST
A button was pressed or released on the user's keyboard or mouse.
BearWare.ClientEvent.CLIENTEVENT_USER_AUDIOBLOCK
@ CLIENTEVENT_USER_AUDIOBLOCK
A new audio block can be extracted.
BearWare.ClientEvent.CLIENTEVENT_CON_MAX_PAYLOAD_UPDATED
@ CLIENTEVENT_CON_MAX_PAYLOAD_UPDATED
The maximum size of the payload put into UDP packets has been updated.
BearWare.ClientEvent.CLIENTEVENT_USER_FIRSTVOICESTREAMPACKET
@ CLIENTEVENT_USER_FIRSTVOICESTREAMPACKET
The first voice packet of a new voice stream has been received.
BearWare.ClientEvent.CLIENTEVENT_CMD_SERVER_UPDATE
@ CLIENTEVENT_CMD_SERVER_UPDATE
Server has updated its settings (server name, MOTD, etc.)
BearWare.ClientEvent.CLIENTEVENT_USER_MEDIAFILE_VIDEO
@ CLIENTEVENT_USER_MEDIAFILE_VIDEO
A new video frame from a video media file was received from a user.
BearWare.ClientEvent.CLIENTEVENT_CON_LOST
@ CLIENTEVENT_CON_LOST
Connection to server has been lost.
BearWare.ClientEvent.CLIENTEVENT_CMD_FILE_NEW
@ CLIENTEVENT_CMD_FILE_NEW
A new file is added to a channel.
BearWare.ClientEvent.CLIENTEVENT_USER_DESKTOPINPUT
@ CLIENTEVENT_USER_DESKTOPINPUT
Desktop input (mouse or keyboard input) has been received from a user.
BearWare.ClientEvent.CLIENTEVENT_CMD_MYSELF_LOGGEDIN
@ CLIENTEVENT_CMD_MYSELF_LOGGEDIN
The client instance successfully logged on to server.
BearWare.ClientEvent.CLIENTEVENT_CON_SUCCESS
@ CLIENTEVENT_CON_SUCCESS
Connected successfully to the server.
BearWare.ClientEvent.CLIENTEVENT_USER_RECORD_MEDIAFILE
@ CLIENTEVENT_USER_RECORD_MEDIAFILE
A media file recording has changed status.
BearWare.ClientEvent.CLIENTEVENT_NONE
@ CLIENTEVENT_NONE
BearWare.ClientEvent.CLIENTEVENT_USER_DESKTOPWINDOW
@ CLIENTEVENT_USER_DESKTOPWINDOW
A new or updated desktop window has been received from a user.
BearWare.ClientEvent.CLIENTEVENT_CMD_ERROR
@ CLIENTEVENT_CMD_ERROR
The server rejected a command issued by the local client instance.
BearWare.ClientEvent.CLIENTEVENT_AUDIOINPUT
@ CLIENTEVENT_AUDIOINPUT
Progress is audio being injected as BearWare.StreamType.STREAMTYPE_VOICE.
BearWare.ClientEvent.CLIENTEVENT_CMD_USER_LEFT
@ CLIENTEVENT_CMD_USER_LEFT
User has left a channel.
BearWare.ClientEvent.CLIENTEVENT_CMD_PROCESSING
@ CLIENTEVENT_CMD_PROCESSING
A command issued by TeamTalkBase.Do* methods is being processed.
BearWare.ClientEvent.CLIENTEVENT_CMD_BANNEDUSER
@ CLIENTEVENT_CMD_BANNEDUSER
A banned user has been received from the server.
BearWare.ClientEvent.CLIENTEVENT_CON_FAILED
@ CLIENTEVENT_CON_FAILED
Failed to connect to server.
BearWare.ClientEvent.CLIENTEVENT_CMD_CHANNEL_NEW
@ CLIENTEVENT_CMD_CHANNEL_NEW
A new channel has been created.
BearWare.ClientEvent.CLIENTEVENT_CMD_SERVERSTATISTICS
@ CLIENTEVENT_CMD_SERVERSTATISTICS
Server statistics available.
BearWare.ClientEvent.CLIENTEVENT_USER_VIDEOCAPTURE
@ CLIENTEVENT_USER_VIDEOCAPTURE
A new video frame from a video capture device was received from a user.
BearWare.ClientEvent.CLIENTEVENT_CMD_USERACCOUNT
@ CLIENTEVENT_CMD_USERACCOUNT
A user account has been received from the server.
BearWare.ClientEvent.CLIENTEVENT_CMD_USER_TEXTMSG
@ CLIENTEVENT_CMD_USER_TEXTMSG
A user has sent a text-message.
BearWare.ClientEvent.CLIENTEVENT_CMD_USER_LOGGEDOUT
@ CLIENTEVENT_CMD_USER_LOGGEDOUT
A client logged out of the server.
BearWare.ClientEvent.CLIENTEVENT_INTERNAL_ERROR
@ CLIENTEVENT_INTERNAL_ERROR
An internal error occurred in the client instance.
BearWare.ClientEvent.CLIENTEVENT_CMD_USER_LOGGEDIN
@ CLIENTEVENT_CMD_USER_LOGGEDIN
A new user logged on to the server.
BearWare.ClientEvent.CLIENTEVENT_CMD_CHANNEL_REMOVE
@ CLIENTEVENT_CMD_CHANNEL_REMOVE
A channel has been removed.
BearWare.ClientEvent.CLIENTEVENT_VOICE_ACTIVATION
@ CLIENTEVENT_VOICE_ACTIVATION
Voice activation has triggered transmission.
BearWare.ClientEvent.CLIENTEVENT_DESKTOPWINDOW_TRANSFER
@ CLIENTEVENT_DESKTOPWINDOW_TRANSFER
Used for tracking when a desktop window has been transmitted to the server.
BearWare.TeamTalkBase.HotKey_Register
bool HotKey_Register(int nHotKeyID, int[] lpnVKCodes)
Register a global hotkey.
Definition: TeamTalk.cs:8142
BearWare.TeamTalkBase.HotKey_GetKeyString
bool HotKey_GetKeyString(int nVKCode, ref string szKeyName)
Get a string description of the virtual-key code.
Definition: TeamTalk.cs:8202
BearWare.TeamTalkBase.HotKey_IsActive
int HotKey_IsActive(int nHotKeyID)
Check whether hotkey is active.
Definition: TeamTalk.cs:8160
BearWare.TeamTalkBase.HotKey_Unregister
bool HotKey_Unregister(int nHotKeyID)
Unregister a registered hotkey.
Definition: TeamTalk.cs:8151
BearWare.TeamTalkBase.HotKey_RemoveTestHook
bool HotKey_RemoveTestHook()
Remove the test hook again so the OnHotKeyTest event will no longer be notified.
Definition: TeamTalk.cs:8192
BearWare.TeamTalkBase.HotKey_InstallTestHook
bool HotKey_InstallTestHook()
Install a test hook which calls the event OnHotKeyTest whenever a key or mouse button is pressed.
Definition: TeamTalk.cs:8173
BearWare.TeamTalkBase.GetMessage
bool GetMessage(ref TTMessage pMsg, int nWaitMs)
Poll for events in the client instance.
Definition: TeamTalk.cs:4425
BearWare.TeamTalkBase.TT_CHANNELID_MAX
const int TT_CHANNELID_MAX
The highest channel ID. Also used for BearWare.TeamTalkBase.TT_CLASSROOM_FREEFORALL.
Definition: TeamTalk.cs:4188
BearWare.TeamTalkBase.TT_LOCAL_USERID
const int TT_LOCAL_USERID
User ID passed to TeamTalkBase.EnableAudioBlockEvent() in order to receive BearWare....
Definition: TeamTalk.cs:4244
BearWare.TeamTalkBase.Dispose
void Dispose()
Definition: TeamTalk.cs:4392
BearWare.TeamTalkBase.GetFlags
BearWare.ClientFlag GetFlags()
Get a bitmask describing the client's current state.
Definition: TeamTalk.cs:4470
BearWare.TeamTalkBase.TT_MUXED_USERID
const int TT_MUXED_USERID
User ID used to identify muxed audio that has been mixed into a single stream.
Definition: TeamTalk.cs:4262
BearWare.TeamTalkBase.TeamTalkBase
TeamTalkBase(bool poll_based)
Create a new TeamTalk client instance.
Definition: TeamTalk.cs:4309
BearWare.ClientFlag
ClientFlag
Flags used to describe the the client instance current state.
Definition: TeamTalk.cs:4071
BearWare.TeamTalkBase.PumpMessage
bool PumpMessage(ClientEvent nClientEvent, int nIdentifier)
Cause client instance event thread to schedule an update event.
Definition: TeamTalk.cs:4456
BearWare.TeamTalkBase.TT_USERID_MAX
const int TT_USERID_MAX
The highest user ID.
Definition: TeamTalk.cs:4184
BearWare.TeamTalkBase.TT_LOCAL_TX_USERID
const int TT_LOCAL_TX_USERID
User ID passed to TeamTalkBase.EnableAudioBlockEvent() in order to receive BearWare....
Definition: TeamTalk.cs:4253
BearWare.TeamTalkBase.ProcessMsg
void ProcessMsg(TTMessage msg)
Event handler for BearWare.TTMessage.
Definition: TeamTalk.cs:4501
BearWare.TeamTalkBase.GetVersion
static string GetVersion()
Get the DLL's version number.
Definition: TeamTalk.cs:4297
BearWare.TeamTalkBase.Flags
ClientFlag Flags
Same as GetFlags().
Definition: TeamTalk.cs:4479
BearWare.TeamTalkBase.SetLicenseInformation
static bool SetLicenseInformation(string szRegName, string szRegKey)
Set license information to disable trial mode.
Definition: TeamTalk.cs:4492
BearWare.TeamTalkBase.TT_STRLEN
const int TT_STRLEN
The maximum length of all strings used in TeamTalkBase. This value includes the zero terminator,...
Definition: TeamTalk.cs:4181
BearWare.ClientFlag.CLIENT_CLOSED
@ CLIENT_CLOSED
The client instance is in closed state, i.e. no operations has been performed on it.
BearWare.ClientFlag.CLIENT_VIDEOCAPTURE_READY
@ CLIENT_VIDEOCAPTURE_READY
If set the client instance's video device has been initialized, i.e. TeamTalkBase....
BearWare.ClientFlag.CLIENT_CONNECTION
@ CLIENT_CONNECTION
Helper for BearWare.ClientFlag.CLIENT_CONNECTING and BearWare.ClientFlag.CLIENT_CONNECTED to see if T...
BearWare.ClientFlag.CLIENT_CONNECTED
@ CLIENT_CONNECTED
If set the client instance is connected to a server, i.e. BearWare.ClientEvent.CLIENTEVENT_CON_SUCCES...
BearWare.ClientFlag.CLIENT_SNDINOUTPUT_DUPLEX
@ CLIENT_SNDINOUTPUT_DUPLEX
If set the client instance is running in sound duplex mode where multiple audio output streams are mi...
BearWare.ClientFlag.CLIENT_SNDOUTPUT_READY
@ CLIENT_SNDOUTPUT_READY
If set the client instance's sound output device has been initialized, i.e. TeamTalkBase....
BearWare.ClientFlag.CLIENT_CONNECTING
@ CLIENT_CONNECTING
If set the client instance is currently try to connect to a server, i.e. TeamTalkBase....
BearWare.ClientFlag.CLIENT_STREAM_VIDEO
@ CLIENT_STREAM_VIDEO
If set the client is currently streaming the video of a media file. When streaming a video file the B...
BearWare.ClientFlag.CLIENT_MUX_AUDIOFILE
@ CLIENT_MUX_AUDIOFILE
If set the client instance is currently muxing audio streams into a single file. This is enabled by c...
BearWare.ClientFlag.CLIENT_SNDOUTPUT_AUTO3DPOSITION
@ CLIENT_SNDOUTPUT_AUTO3DPOSITION
If set the client instance will auto position users in a 180 degree circle using 3D-sound....
BearWare.ClientFlag.CLIENT_DESKTOP_ACTIVE
@ CLIENT_DESKTOP_ACTIVE
If set the client instance current have an active desktop session, i.e. TeamTalkBase....
BearWare.ClientFlag.CLIENT_SNDINPUT_READY
@ CLIENT_SNDINPUT_READY
If set the client instance's sound input device has been initialized, i.e. TeamTalkBase....
BearWare.ClientFlag.CLIENT_STREAM_AUDIO
@ CLIENT_STREAM_AUDIO
If set the client is currently streaming the audio of a media file. When streaming a video file the B...
BearWare.ClientFlag.CLIENT_SNDINPUT_VOICEACTIVATED
@ CLIENT_SNDINPUT_VOICEACTIVATED
If set the client instance will start transmitting audio if the sound level is above the voice activa...
BearWare.ClientFlag.CLIENT_TX_VOICE
@ CLIENT_TX_VOICE
If set the client instance is currently transmitting audio.
BearWare.ClientFlag.CLIENT_TX_VIDEOCAPTURE
@ CLIENT_TX_VIDEOCAPTURE
If set the client instance is currently transmitting video.
BearWare.ClientFlag.CLIENT_SNDINPUT_VOICEACTIVE
@ CLIENT_SNDINPUT_VOICEACTIVE
If set GetSoundInputLevel() is higher than the voice activation level. To enable voice transmission i...
BearWare.ClientFlag.CLIENT_TX_DESKTOP
@ CLIENT_TX_DESKTOP
If set the client instance is currently transmitting a desktop window. A desktop window update is iss...
BearWare.ClientFlag.CLIENT_AUTHORIZED
@ CLIENT_AUTHORIZED
If set the client instance is logged on to a server, i.e. got BearWare.ClientEvent....
BearWare.ClientFlag.CLIENT_SNDOUTPUT_MUTE
@ CLIENT_SNDOUTPUT_MUTE
If set the client instance has muted all users.
BearWare.TeamTalkBase.UpdateStreamingMediaFileToChannel
bool UpdateStreamingMediaFileToChannel(MediaFilePlayback lpMediaFilePlayback, VideoCodec lpVideoCodec)
Update active media file being streamed to channel.
Definition: TeamTalk.cs:5981
BearWare.TeamTalkBase.StartStreamingMediaFileToChannel
bool StartStreamingMediaFileToChannel(string szMediaFilePath, VideoCodec lpVideoCodec)
Stream media file to channel, e.g. avi-, wav- or MP3-file.
Definition: TeamTalk.cs:5920
BearWare.TeamTalkBase.AcquireUserMediaVideoFrame
VideoFrame AcquireUserMediaVideoFrame(int nUserID, out Bitmap bmp)
Extract a user's media video frame for display.
Definition: TeamTalk.cs:6090
BearWare.TeamTalkBase.InitLocalPlayback
int InitLocalPlayback(string szMediaFilePath, MediaFilePlayback lpMediaFilePlayback)
Play media file using settings from BearWare.TeamTalkBase instance.
Definition: TeamTalk.cs:6023
BearWare.TeamTalkBase.UpdateLocalPlayback
bool UpdateLocalPlayback(int nPlaybackSessionID, MediaFilePlayback lpMediaFilePlayback)
Definition: TeamTalk.cs:6039
BearWare.TeamTalkBase.StopLocalPlayback
bool StopLocalPlayback(int nPlaybackSessionID)
Definition: TeamTalk.cs:6053
BearWare.TeamTalkBase.StopStreamingMediaFileToChannel
bool StopStreamingMediaFileToChannel()
Stop streaming media file to channel.
Definition: TeamTalk.cs:5994
BearWare.TeamTalkBase.StartStreamingMediaFileToChannel
bool StartStreamingMediaFileToChannel(string szMediaFilePath, MediaFilePlayback lpMediaFilePlayback, VideoCodec lpVideoCodec)
Stream media file to channel, e.g. avi-, wav- or MP3-file.
Definition: TeamTalk.cs:5956
BearWare.MediaFileStatus
MediaFileStatus
Status of media file being written to disk.
Definition: TeamTalk.cs:522
BearWare.TeamTalkBase.GetMediaFileInfo
static bool GetMediaFileInfo(string szMediaFilePath, ref MediaFileInfo lpMediaFileInfo)
Get the properties of a media file.
Definition: TeamTalk.cs:6065
BearWare.TeamTalkBase.ReleaseUserMediaVideoFrame
bool ReleaseUserMediaVideoFrame(VideoFrame lpVideoFrame)
Delete a user's video frame, acquired through TeamTalkBase.AcquireUserMediaVideoFrame(),...
Definition: TeamTalk.cs:6112
BearWare.TeamTalkBase.TT_MEDIAPLAYBACK_OFFSET_IGNORE
const uint TT_MEDIAPLAYBACK_OFFSET_IGNORE
Definition: TeamTalk.cs:4293
BearWare.AudioFileFormat
AudioFileFormat
Media file formats supported for muxed audio recordings.
Definition: TeamTalk.cs:543
BearWare.MediaFileStatus.MFS_PLAYING
@ MFS_PLAYING
Playing media file with updated uElapsedMSec of BearWare.MediaFileInfo.
BearWare.MediaFileStatus.MFS_FINISHED
@ MFS_FINISHED
Finished processing media file.
BearWare.MediaFileStatus.MFS_STARTED
@ MFS_STARTED
Started processing media file.
BearWare.MediaFileStatus.MFS_PAUSED
@ MFS_PAUSED
Paused processing of media file.
BearWare.MediaFileStatus.MFS_CLOSED
@ MFS_CLOSED
BearWare.MediaFileStatus.MFS_ERROR
@ MFS_ERROR
Error while processing media file.
BearWare.MediaFileStatus.MFS_ABORTED
@ MFS_ABORTED
Aborted processing of media file.
BearWare.AudioFileFormat.AFF_MP3_128KBIT_FORMAT
@ AFF_MP3_128KBIT_FORMAT
BearWare.AudioFileFormat.AFF_MP3_256KBIT_FORMAT
@ AFF_MP3_256KBIT_FORMAT
BearWare.AudioFileFormat.AFF_MP3_16KBIT_FORMAT
@ AFF_MP3_16KBIT_FORMAT
Store in MP3-format.
BearWare.AudioFileFormat.AFF_WAVE_FORMAT
@ AFF_WAVE_FORMAT
Store in PCM 16-bit wave format.
BearWare.AudioFileFormat.AFF_MP3_64KBIT_FORMAT
@ AFF_MP3_64KBIT_FORMAT
BearWare.AudioFileFormat.AFF_CHANNELCODEC_FORMAT
@ AFF_CHANNELCODEC_FORMAT
Store audio in the same format as the BearWare.Channel's configured audio codec.
BearWare.AudioFileFormat.AFF_MP3_320KBIT_FORMAT
@ AFF_MP3_320KBIT_FORMAT
BearWare.AudioFileFormat.AFF_NONE
@ AFF_NONE
Used to denote nothing selected.
BearWare.AudioFileFormat.AFF_MP3_32KBIT_FORMAT
@ AFF_MP3_32KBIT_FORMAT
BearWare.MixerControl
MixerControl
The Windows mixer controls which can be queried by the BearWare.WindowsMixer class.
Definition: TeamTalk.cs:8805
BearWare.MixerControl.WAVEIN_MICROPHONE
@ WAVEIN_MICROPHONE
BearWare.MixerControl.WAVEOUT_MICROPHONE
@ WAVEOUT_MICROPHONE
BearWare.MixerControl.WAVEIN_LINEIN
@ WAVEIN_LINEIN
BearWare.MixerControl.WAVEOUT_MASTER
@ WAVEOUT_MASTER
BearWare.MixerControl.WAVEIN_WAVEOUT
@ WAVEIN_WAVEOUT
BearWare.MixerControl.WAVEOUT_WAVE
@ WAVEOUT_WAVE
BearWare.UserRight
UserRight
The rights users have once they have logged on to the server.
Definition: TeamTalk.cs:1692
BearWare.ServerLogEvent
ServerLogEvent
Events that are logged by the server, i.e. written to server's log file.
Definition: TeamTalk.cs:1786
BearWare.TeamTalkBase.GetServerUsers
bool GetServerUsers(out User[] lpUsers)
Get all the users on the server.
Definition: TeamTalk.cs:7511
BearWare.TeamTalkBase.GetServerProperties
bool GetServerProperties(ref ServerProperties lpServerProperties)
Get the server's properties.
Definition: TeamTalk.cs:7497
BearWare.BanType
BanType
Way to ban a user from either login or joining a channel.
Definition: TeamTalk.cs:2000
BearWare.UserRight.USERRIGHT_TRANSMIT_DESKTOP
@ USERRIGHT_TRANSMIT_DESKTOP
User is allowed to forward desktop packets through server.
BearWare.UserRight.USERRIGHT_MULTI_LOGIN
@ USERRIGHT_MULTI_LOGIN
Allow multiple users to log on to the server with the same BearWare.UserAccount.
BearWare.UserRight.USERRIGHT_TRANSMIT_VOICE
@ USERRIGHT_TRANSMIT_VOICE
Users are allowed to forward audio packets through server. TeamTalkBase.EnableVoiceTransmission()
BearWare.UserRight.USERRIGHT_CREATE_TEMPORARY_CHANNEL
@ USERRIGHT_CREATE_TEMPORARY_CHANNEL
User is allowed to create temporary channels which disappear when last user leaves the channel.
BearWare.UserRight.USERRIGHT_TRANSMIT_VIDEOCAPTURE
@ USERRIGHT_TRANSMIT_VIDEOCAPTURE
User is allowed to forward video packets through server. TeamTalkBase.StartVideoCaptureTransmission()
BearWare.UserRight.USERRIGHT_KICK_USERS
@ USERRIGHT_KICK_USERS
User can kick users off the server.
BearWare.UserRight.USERRIGHT_UPDATE_SERVERPROPERTIES
@ USERRIGHT_UPDATE_SERVERPROPERTIES
User can update server properties.
BearWare.UserRight.USERRIGHT_ALL
@ USERRIGHT_ALL
User with all rights.
BearWare.UserRight.USERRIGHT_LOCKED_NICKNAME
@ USERRIGHT_LOCKED_NICKNAME
User's nick name is locked. TeamTalkBase.DoChangeNickname() cannot be used and TeamTalkBase....
BearWare.UserRight.USERRIGHT_TEXTMESSAGE_USER
@ USERRIGHT_TEXTMESSAGE_USER
User can send private text messages, i.e. BearWare.TextMsgType.MSGTYPE_USER.
BearWare.UserRight.USERRIGHT_TRANSMIT_MEDIAFILE
@ USERRIGHT_TRANSMIT_MEDIAFILE
User is allowed to media files to channel.
BearWare.UserRight.USERRIGHT_BAN_USERS
@ USERRIGHT_BAN_USERS
User can add and remove banned users.
BearWare.UserRight.USERRIGHT_TRANSMIT_MEDIAFILE_VIDEO
@ USERRIGHT_TRANSMIT_MEDIAFILE_VIDEO
User is allowed to stream video files to channel.
BearWare.UserRight.USERRIGHT_TEXTMESSAGE_BROADCAST
@ USERRIGHT_TEXTMESSAGE_BROADCAST
User can broadcast text message of type BearWare.TextMsgType.MSGTYPE_BROADCAST to all users.
BearWare.UserRight.USERRIGHT_TRANSMIT_MEDIAFILE_AUDIO
@ USERRIGHT_TRANSMIT_MEDIAFILE_AUDIO
User is allowed to stream audio files to channel.
BearWare.UserRight.USERRIGHT_TEXTMESSAGE_CHANNEL
@ USERRIGHT_TEXTMESSAGE_CHANNEL
User can send private text messages, i.e. BearWare.TextMsgType.MSGTYPE_CHANNEL.
BearWare.UserRight.USERRIGHT_OPERATOR_ENABLE
@ USERRIGHT_OPERATOR_ENABLE
User can make other users channel operator.
BearWare.UserRight.USERRIGHT_TRANSMIT_DESKTOPINPUT
@ USERRIGHT_TRANSMIT_DESKTOPINPUT
User is allowed to forward desktop input packets through server.
BearWare.UserRight.USERRIGHT_MOVE_USERS
@ USERRIGHT_MOVE_USERS
User can move users from one channel to another.
BearWare.UserRight.USERRIGHT_LOCKED_STATUS
@ USERRIGHT_LOCKED_STATUS
User's status is locked. TeamTalkBase.DoChangeStatus() cannot be used.
BearWare.UserRight.USERRIGHT_VIEW_ALL_USERS
@ USERRIGHT_VIEW_ALL_USERS
User can see users in all other channels.
BearWare.UserRight.USERRIGHT_DOWNLOAD_FILES
@ USERRIGHT_DOWNLOAD_FILES
User can download files from channels.
BearWare.UserRight.USERRIGHT_UPLOAD_FILES
@ USERRIGHT_UPLOAD_FILES
User can upload files to channels.
BearWare.UserRight.USERRIGHT_VIEW_HIDDEN_CHANNELS
@ USERRIGHT_VIEW_HIDDEN_CHANNELS
User can see hidden channels, BearWare.ChannelType.CHANNEL_HIDDEN.
BearWare.UserRight.USERRIGHT_MODIFY_CHANNELS
@ USERRIGHT_MODIFY_CHANNELS
User is allowed to create permanent channels which are stored in the server's configuration file.
BearWare.UserRight.USERRIGHT_RECORD_VOICE
@ USERRIGHT_RECORD_VOICE
User can record voice in all channels. Even channels with BearWare.ChannelType.CHANNEL_NO_RECORDING.
BearWare.UserRight.USERRIGHT_NONE
@ USERRIGHT_NONE
Users who log onto the server has none of the rights below.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_MOVED
@ SERVERLOGEVENT_USER_MOVED
User was moved to another channel is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_LEFTCHANNEL
@ SERVERLOGEVENT_USER_LEFTCHANNEL
User left a channel is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_LOGGEDIN
@ SERVERLOGEVENT_USER_LOGGEDIN
User logged in is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_DISCONNECTED
@ SERVERLOGEVENT_USER_DISCONNECTED
User disconnected from server is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_SERVER_SAVECONFIG
@ SERVERLOGEVENT_SERVER_SAVECONFIG
User saved server's configuration is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_CHANNEL_REMOVED
@ SERVERLOGEVENT_CHANNEL_REMOVED
User removed a channel is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_FILE_DELETED
@ SERVERLOGEVENT_FILE_DELETED
User deleted a file is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_FILE_DOWNLOADED
@ SERVERLOGEVENT_FILE_DOWNLOADED
User downloaded a file is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_KICKED
@ SERVERLOGEVENT_USER_KICKED
User was kicked is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_JOINEDCHANNEL
@ SERVERLOGEVENT_USER_JOINEDCHANNEL
User joined a channel is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_TEXTMESSAGE_BROADCAST
@ SERVERLOGEVENT_USER_TEXTMESSAGE_BROADCAST
User's broadcast text messages are logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_TEXTMESSAGE_CHANNEL
@ SERVERLOGEVENT_USER_TEXTMESSAGE_CHANNEL
User's channel text messages are logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_SERVER_UPDATED
@ SERVERLOGEVENT_SERVER_UPDATED
User updated server's properties is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_CONNECTED
@ SERVERLOGEVENT_USER_CONNECTED
User's IP-address is logged to file by serer.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_TIMEDOUT
@ SERVERLOGEVENT_USER_TIMEDOUT
User disconnected due to connection timeout is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_LOGINFAILED
@ SERVERLOGEVENT_USER_LOGINFAILED
User failed to log in is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_LOGGEDOUT
@ SERVERLOGEVENT_USER_LOGGEDOUT
User logged out is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_NONE
@ SERVERLOGEVENT_NONE
Nothing is logged to file by server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_TEXTMESSAGE_PRIVATE
@ SERVERLOGEVENT_USER_TEXTMESSAGE_PRIVATE
User's private text messages are logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_CHANNEL_UPDATED
@ SERVERLOGEVENT_CHANNEL_UPDATED
User updated a channel is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_BANNED
@ SERVERLOGEVENT_USER_BANNED
User was banned is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_UPDATED
@ SERVERLOGEVENT_USER_UPDATED
User's status is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_UNBANNED
@ SERVERLOGEVENT_USER_UNBANNED
User was removed from ban list is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_CHANNEL_CREATED
@ SERVERLOGEVENT_CHANNEL_CREATED
User created new channel is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_FILE_UPLOADED
@ SERVERLOGEVENT_FILE_UPLOADED
User uploaded a file is logged to file by the server.
BearWare.ServerLogEvent.SERVERLOGEVENT_USER_TEXTMESSAGE_CUSTOM
@ SERVERLOGEVENT_USER_TEXTMESSAGE_CUSTOM
User's custom text messages are logged to file by the server.
BearWare.BanType.BANTYPE_NONE
@ BANTYPE_NONE
Ban type not set.
BearWare.BanType.BANTYPE_CHANNEL
@ BANTYPE_CHANNEL
The ban applies to the channel specified in the szChannel of BearWare.BannedUser. Otherwise the ban a...
BearWare.BanType.BANTYPE_USERNAME
@ BANTYPE_USERNAME
Ban szUsername specified in BearWare.BannedUser.
BearWare.BanType.BANTYPE_IPADDR
@ BANTYPE_IPADDR
Ban szIPAddress specified in BearWare.BannedUser.
BearWare.TeamTalkBase.StartSoundLoopbackTest
static IntPtr StartSoundLoopbackTest(int nInputDeviceID, int nOutputDeviceID, int nSampleRate, int nChannels, bool bDuplexMode, SpeexDSP lpSpeexDSP)
Perform a record and playback test of specified sound devices along with an audio configuration and a...
Definition: TeamTalk.cs:4753
BearWare.TeamTalkBase.SetUserMediaStorageDir
bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars, AudioFileFormat uAFF)
Store user's audio to disk.
Definition: TeamTalk.cs:7947
BearWare.TeamTalkBase.SetUserMediaStorageDir
bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars, AudioFileFormat uAFF, int nStopRecordingExtraDelayMSec)
Store user's audio to disk.
Definition: TeamTalk.cs:7977
BearWare.TeamTalkBase.Enable3DSoundPositioning
bool Enable3DSoundPositioning(bool bEnable)
Enable automatically position users using 3D-sound.
Definition: TeamTalk.cs:5235
BearWare.TeamTalkBase.ReleaseUserAudioBlock
bool ReleaseUserAudioBlock(AudioBlock lpAudioBlock)
Release the shared memory of an BearWare.AudioBlock.
Definition: TeamTalk.cs:8056
BearWare.TeamTalkBase.SetSoundInputPreprocess
bool SetSoundInputPreprocess(SpeexDSP lpSpeexDSP)
Enable sound preprocessor which should be used for processing audio recorded by the sound input devic...
Definition: TeamTalk.cs:5149
BearWare.TeamTalkBase.SetUserStereo
bool SetUserStereo(int nUserID, StreamType nStreamType, bool bLeftSpeaker, bool bRightSpeaker)
Set whether a user should speak in the left, right or both speakers. This function only works if Bear...
Definition: TeamTalk.cs:7908
BearWare.TeamTalkBase.EnableAudioBlockEvent
bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes, AudioFormat lpAudioFormat, bool bEnable)
Same as TeamTalkBase.EnableAudioBlockEvent() but option to specify audio output format.
Definition: TeamTalk.cs:5349
BearWare.TeamTalkBase.CloseSoundDuplexDevices
bool CloseSoundDuplexDevices()
Shut down sound devices running in duplex mode.
Definition: TeamTalk.cs:5033
BearWare.TeamTalkBase.AutoPositionUsers
bool AutoPositionUsers()
Automatically position users using 3D-sound.
Definition: TeamTalk.cs:5248
BearWare.TeamTalkBase.SetSoundOutputVolume
bool SetSoundOutputVolume(int nVolume)
Set master volume.
Definition: TeamTalk.cs:5200
BearWare.TeamTalkBase.GetSoundDeviceEffects
bool GetSoundDeviceEffects(ref SoundDeviceEffects lpSoundDeviceEffect)
Get the audio effects that are currently enabled.
Definition: TeamTalk.cs:5080
BearWare.TeamTalkBase.GetSoundInputLevel
int GetSoundInputLevel()
Get the volume level of the current recorded audio.
Definition: TeamTalk.cs:5100
BearWare.TeamTalkBase.SetUserPosition
bool SetUserPosition(int nUserID, StreamType nStreamType, float x, float y, float z)
Set the position of a user.
Definition: TeamTalk.cs:7892
BearWare.TeamTalkBase.SetUserStoppedPlaybackDelay
bool SetUserStoppedPlaybackDelay(int nUserID, StreamType nStreamType, int nDelayMSec)
Set the delay of when a user should no longer be considered as playing audio (either voice or audio f...
Definition: TeamTalk.cs:7822
BearWare.TeamTalkBase.TT_SAMPLERATES_MAX
const int TT_SAMPLERATES_MAX
Definition: TeamTalk.cs:4277
BearWare.TeamTalkBase.SetUserAudioStreamBufferSize
bool SetUserAudioStreamBufferSize(int nUserID, StreamType uStreamType, int nMSec)
Change the amount of media data which can be buffered in the user's playback queue.
Definition: TeamTalk.cs:8007
BearWare.TeamTalkBase.GetSoundDevices
static bool GetSoundDevices(out SoundDevice[] lpSoundDevices)
Retrieve list of sound devices for recording and playback.
Definition: TeamTalk.cs:4721
BearWare.TeamTalkBase.GetDefaultSoundDevicesEx
static bool GetDefaultSoundDevicesEx(SoundSystem nSndSystem, ref int lpnInputDeviceID, ref int lpnOutputDeviceID)
Get the default sound devices for the specified sound system.
Definition: TeamTalk.cs:4707
BearWare.TeamTalkBase.GetUserJitterControl
bool GetUserJitterControl(int nUserID, StreamType nStreamType, ref JitterConfig lpJitterConfig)
Get the de-jitter configuration for a user.
Definition: TeamTalk.cs:7870
BearWare.TeamTalkBase.GetSoundInputPreprocess
bool GetSoundInputPreprocess(ref SpeexDSP lpSpeexDSP)
Get the sound preprocessor settings which are currently in use for recorded sound input device (voice...
Definition: TeamTalk.cs:5162
BearWare.TeamTalkBase.AcquireUserAudioBlock
AudioBlock AcquireUserAudioBlock(StreamType uStreamTypes, int nUserID)
Extract the raw audio associated with the event TeamTalkBase.OnUserAudioBlock().
Definition: TeamTalk.cs:8031
BearWare.TeamTalkBase.SetSoundOutputMute
bool SetSoundOutputMute(bool bMuteAll)
Set all users mute.
Definition: TeamTalk.cs:5221
BearWare.TeamTalkBase.InitSoundOutputSharedDevice
bool InitSoundOutputSharedDevice(int nSampleRate, int nChannels, int nFrameSize)
Setup sample rate, channels and frame size of shared sound output device.
Definition: TeamTalk.cs:4941
BearWare.TeamTalkBase.InitSoundDuplexDevices
bool InitSoundDuplexDevices(int nInputDeviceID, int nOutputDeviceID)
Enable duplex mode where multiple audio streams are mixed into a single stream using software.
Definition: TeamTalk.cs:4978
BearWare.TeamTalkBase.CloseSoundOutputDevice
bool CloseSoundOutputDevice()
Shutdown the output sound device.
Definition: TeamTalk.cs:5023
BearWare.TeamTalkBase.InitSoundOutputDevice
bool InitSoundOutputDevice(int nOutputDeviceID)
Initialize the sound output device (for audio playback).
Definition: TeamTalk.cs:4907
BearWare.TeamTalkBase.GetSoundInputGainLevel
int GetSoundInputGainLevel()
Get voice gain level of outgoing audio.
Definition: TeamTalk.cs:5129
BearWare.TeamTalkBase.RestartSoundSystem
static bool RestartSoundSystem()
Reinitialize sound system (in order to detect new/removed devices).
Definition: TeamTalk.cs:4745
BearWare.SoundSystem
SoundSystem
The supported sound systems.
Definition: TeamTalk.cs:107
BearWare.TeamTalkBase.SetUserVolume
bool SetUserVolume(int nUserID, StreamType nStreamType, int nVolume)
Set the volume of a user.
Definition: TeamTalk.cs:7791
BearWare.SoundDeviceFeature
SoundDeviceFeature
Features available on a sound device. Checkout uSoundDeviceFeatures on BearWare.SoundDevice.
Definition: TeamTalk.cs:166
BearWare.TeamTalkBase.GetSoundOutputVolume
int GetSoundOutputVolume()
Get master volume.
Definition: TeamTalk.cs:5210
BearWare.TeamTalkBase.StartSoundLoopbackTest
static IntPtr StartSoundLoopbackTest(int nInputDeviceID, int nOutputDeviceID, int nSampleRate, int nChannels, bool bDuplexMode, AudioPreprocessor lpAudioPreprocessor, BearWare.SoundDeviceEffects lpSoundDeviceEffects)
Perform a record and playback test of specified sound devices along with an audio configuration and a...
Definition: TeamTalk.cs:4792
BearWare.TeamTalkBase.SetSoundInputPreprocess
bool SetSoundInputPreprocess(AudioPreprocessor lpAudioPreprocessor)
Enable sound preprocessor which should be used for processing audio recorded by the sound input devic...
Definition: TeamTalk.cs:5177
BearWare.TeamTalkBase.GetSoundInputPreprocess
bool GetSoundInputPreprocess(ref AudioPreprocessor lpAudioPreprocessor)
Get the sound preprocessor settings which are currently in use for recorded sound input device (voice...
Definition: TeamTalk.cs:5189
BearWare.TeamTalkBase.EnableAudioBlockEvent
bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes, bool bEnable)
Enable/disable access to raw audio from individual users, local microphone input or muxed stream of a...
Definition: TeamTalk.cs:5316
BearWare.TeamTalkBase.GetDefaultSoundDevices
static bool GetDefaultSoundDevices(ref int lpnInputDeviceID, ref int lpnOutputDeviceID)
Get the default sound devices.
Definition: TeamTalk.cs:4698
BearWare.TeamTalkBase.SetUserJitterControl
bool SetUserJitterControl(int nUserID, StreamType nStreamType, JitterConfig lpJitterConfig)
Set the configuration for de-jitter measures for a user.
Definition: TeamTalk.cs:7853
BearWare.TeamTalkBase.CloseSoundLoopbackTest
static bool CloseSoundLoopbackTest(IntPtr lpTTSoundLoop)
Stop recorder and playback test.
Definition: TeamTalk.cs:4807
BearWare.TeamTalkBase.SetUserMute
bool SetUserMute(int nUserID, StreamType nStreamType, bool bMute)
Mute a user.
Definition: TeamTalk.cs:7806
BearWare.TeamTalkBase.InitSoundInputDevice
bool InitSoundInputDevice(int nInputDeviceID)
Initialize the sound input device (for recording audio).
Definition: TeamTalk.cs:4839
BearWare.TeamTalkBase.SetSoundInputGainLevel
bool SetSoundInputGainLevel(int nLevel)
Set voice gaining of recorded audio.
Definition: TeamTalk.cs:5119
BearWare.TeamTalkBase.CloseSoundInputDevice
bool CloseSoundInputDevice()
Shutdown the input sound device.
Definition: TeamTalk.cs:5001
BearWare.TeamTalkBase.InitSoundInputSharedDevice
bool InitSoundInputSharedDevice(int nSampleRate, int nChannels, int nFrameSize)
Setup sample rate, channels and frame size of shared sound input device.
Definition: TeamTalk.cs:4874
BearWare.TeamTalkBase.SetSoundDeviceEffects
bool SetSoundDeviceEffects(SoundDeviceEffects lpSoundDeviceEffect)
Set up audio effects on a sound device.
Definition: TeamTalk.cs:5072
BearWare.SoundSystem.SOUNDSYSTEM_WINMM
@ SOUNDSYSTEM_WINMM
Windows legacy audio system. Should be used on Windows Mobile.
BearWare.SoundSystem.SOUNDSYSTEM_WASAPI
@ SOUNDSYSTEM_WASAPI
Windows Audio Session API (WASAPI). Should be used on Windows Vista/7/8/10.
BearWare.SoundSystem.SOUNDSYSTEM_DSOUND
@ SOUNDSYSTEM_DSOUND
DirectSound audio system. Should be used on Windows.
BearWare.SoundSystem.SOUNDSYSTEM_AUDIOUNIT
@ SOUNDSYSTEM_AUDIOUNIT
iOS sound API.
BearWare.SoundSystem.SOUNDSYSTEM_COREAUDIO
@ SOUNDSYSTEM_COREAUDIO
Core Audio. Should be used on MacOS.
BearWare.SoundSystem.SOUNDSYSTEM_AUDIOUNIT_IOS
@ SOUNDSYSTEM_AUDIOUNIT_IOS
Same as BearWare.SoundSystem.SOUNDSYSTEM_AUDIOUNIT.
BearWare.SoundSystem.SOUNDSYSTEM_PULSEAUDIO
@ SOUNDSYSTEM_PULSEAUDIO
PulseAudio API. PulseAudio is typically used on Ubuntu 22.
BearWare.SoundSystem.SOUNDSYSTEM_NONE
@ SOUNDSYSTEM_NONE
Sound system denoting invalid or not found.
BearWare.SoundSystem.SOUNDSYSTEM_ALSA
@ SOUNDSYSTEM_ALSA
Advanced Linux Sound Architecture (ALSA). Should be used on Linux.
BearWare.SoundSystem.SOUNDSYSTEM_OPENSLES_ANDROID
@ SOUNDSYSTEM_OPENSLES_ANDROID
Android sound API.
BearWare.SoundDeviceFeature.SOUNDDEVICEFEATURE_AEC
@ SOUNDDEVICEFEATURE_AEC
The BearWare.SoundDevice can enable Acoustic Echo Canceler (AEC). Enable AEC use property bEnableAEC ...
BearWare.SoundDeviceFeature.SOUNDDEVICEFEATURE_DEFAULTCOMDEVICE
@ SOUNDDEVICEFEATURE_DEFAULTCOMDEVICE
The BearWare.SoundDevice is the default communication device. This feature is only supported on BearW...
BearWare.SoundDeviceFeature.SOUNDDEVICEFEATURE_AGC
@ SOUNDDEVICEFEATURE_AGC
The BearWare.SoundDevice can enable Automatic Gain Control (AGC). Enable AGC use property bEnableAGC ...
BearWare.SoundDeviceFeature.SOUNDDEVICEFEATURE_DUPLEXMODE
@ SOUNDDEVICEFEATURE_DUPLEXMODE
The BearWare.SoundDevice can run in duplex mode.
BearWare.SoundDeviceFeature.SOUNDDEVICEFEATURE_NONE
@ SOUNDDEVICEFEATURE_NONE
BearWare.SoundDeviceFeature.SOUNDDEVICEFEATURE_DENOISE
@ SOUNDDEVICEFEATURE_DENOISE
The BearWare.SoundDevice can enable denoising. Enable denoising use property bEnableDenoising on Bear...
BearWare.SoundDeviceFeature.SOUNDDEVICEFEATURE_3DPOSITION
@ SOUNDDEVICEFEATURE_3DPOSITION
The BearWare.SoundDevice can position user in 3D.
BearWare.TeamTalkBase.StartRecordingMuxedAudioFile
bool StartRecordingMuxedAudioFile(AudioCodec lpAudioCodec, string szAudioFileName, AudioFileFormat uAFF)
Store all audio conversations with specific BearWare.AudioCodec settings to a single file.
Definition: TeamTalk.cs:5542
BearWare.TeamTalkBase.GetVoiceActivationLevel
int GetVoiceActivationLevel()
Get voice activation level.
Definition: TeamTalk.cs:5465
BearWare.TeamTalkBase.StopRecordingMuxedAudioFile
bool StopRecordingMuxedAudioFile(int nChannelID)
Stop recording conversations from a channel to a single file.
Definition: TeamTalk.cs:5643
BearWare.TeamTalkBase.StopVideoCaptureTransmission
bool StopVideoCaptureTransmission()
Stop transmitting from video capture device.
Definition: TeamTalk.cs:5679
BearWare.StreamType
StreamType
The types of streams which are available for transmission.
Definition: TeamTalk.cs:45
BearWare.TeamTalkBase.InsertAudioBlock
bool InsertAudioBlock(AudioBlock lpAudioBlock)
Transmit application provided raw audio in BearWare.AudioBlock-structs as BearWare....
Definition: TeamTalk.cs:5388
BearWare.TeamTalkBase.GetVoiceActivationStopDelay
int GetVoiceActivationStopDelay()
Get the delay of when voice active state should be disabled.
Definition: TeamTalk.cs:5495
BearWare.TeamTalkBase.StopRecordingMuxedAudioFile
bool StopRecordingMuxedAudioFile()
Stop an active muxed audio recording.
Definition: TeamTalk.cs:5632
BearWare.TeamTalkBase.StartVideoCaptureTransmission
bool StartVideoCaptureTransmission(VideoCodec lpVideoCodec)
Start transmitting from video capture device.
Definition: TeamTalk.cs:5670
BearWare.TeamTalkBase.EnableVoiceTransmission
bool EnableVoiceTransmission(bool bEnable)
Start/stop transmitting of voice data from sound input.
Definition: TeamTalk.cs:5410
BearWare.TeamTalkBase.EnableVoiceActivation
bool EnableVoiceActivation(bool bEnable)
Enable voice activation.
Definition: TeamTalk.cs:5440
BearWare.TeamTalkBase.StartRecordingMuxedAudioFile
bool StartRecordingMuxedAudioFile(int nChannelID, string szAudioFileName, AudioFileFormat uAFF)
Store audio conversations from a specific channel into a single file.
Definition: TeamTalk.cs:5571
BearWare.TeamTalkBase.SetVoiceActivationStopDelay
bool SetVoiceActivationStopDelay(int nDelayMSec)
Set the delay of when voice activation should be stopped.
Definition: TeamTalk.cs:5481
BearWare.TeamTalkBase.StartRecordingMuxedStreams
bool StartRecordingMuxedStreams(StreamType uStreamTypes, AudioCodec lpAudioCodec, string szAudioFileName, AudioFileFormat uAFF)
Mix multiple BearWare.StreamType into a single audio file.
Definition: TeamTalk.cs:5613
BearWare.TeamTalkBase.SetVoiceActivationLevel
bool SetVoiceActivationLevel(int nLevel)
Set voice activation level.
Definition: TeamTalk.cs:5455
BearWare.StreamType.STREAMTYPE_LOCALMEDIAPLAYBACK_AUDIO
@ STREAMTYPE_LOCALMEDIAPLAYBACK_AUDIO
Stream type for audio of local playback.
BearWare.StreamType.STREAMTYPE_NONE
@ STREAMTYPE_NONE
No stream.
BearWare.StreamType.STREAMTYPE_DESKTOP
@ STREAMTYPE_DESKTOP
Desktop window stream type which is a window (or bitmap) being transmitted.
BearWare.StreamType.STREAMTYPE_CLASSROOM_ALL
@ STREAMTYPE_CLASSROOM_ALL
Shortcut to allow voice, media files, desktop, webcamera and channel messages.
BearWare.StreamType.STREAMTYPE_DESKTOPINPUT
@ STREAMTYPE_DESKTOPINPUT
Desktop input stream type which is keyboard or mouse input being transmitted.
BearWare.StreamType.STREAMTYPE_VOICE
@ STREAMTYPE_VOICE
Voice stream type which is audio recorded from a sound input device.
BearWare.StreamType.STREAMTYPE_VIDEOCAPTURE
@ STREAMTYPE_VIDEOCAPTURE
Video capture stream type which is video recorded from a webcam.
BearWare.StreamType.STREAMTYPE_CHANNELMSG
@ STREAMTYPE_CHANNELMSG
Channel text messages as stream type.
BearWare.StreamType.STREAMTYPE_MEDIAFILE
@ STREAMTYPE_MEDIAFILE
Shortcut to allow both audio and video media files.
BearWare.StreamType.STREAMTYPE_MEDIAFILE_AUDIO
@ STREAMTYPE_MEDIAFILE_AUDIO
Audio stream type from a media file which is being streamed.
BearWare.StreamType.STREAMTYPE_MEDIAFILE_VIDEO
@ STREAMTYPE_MEDIAFILE_VIDEO
Video stream type from a media file which is being streamed.
BearWare.TeamTalkBase.TT_CHANNELS_OPERATOR_MAX
const int TT_CHANNELS_OPERATOR_MAX
Definition: TeamTalk.cs:4268
BearWare.TeamTalkBase.GetUserStatistics
bool GetUserStatistics(int nUserID, ref UserStatistics lpUserStatistics)
Get statistics for data and packet reception from a user.
Definition: TeamTalk.cs:7759
BearWare.TeamTalkBase.GetMyUserRights
BearWare.UserRight GetMyUserRights()
Convenience method for TeamTalkBase.GetMyUserAccount()
Definition: TeamTalk.cs:7720
BearWare.UserType
UserType
The types of users supported.
Definition: TeamTalk.cs:2047
BearWare.TeamTalkBase.GetMyUserID
int GetMyUserID()
Get the local client instance's user ID.
Definition: TeamTalk.cs:7669
BearWare.TeamTalkBase.GetMyUserAccount
bool GetMyUserAccount(ref UserAccount lpUserAccount)
Get the local client instance's BearWare.UserAccount.
Definition: TeamTalk.cs:7684
BearWare.TeamTalkBase.UserID
int UserID
Same as GetMyUserID().
Definition: TeamTalk.cs:7692
BearWare.TeamTalkBase.UserData
int UserData
Same as GetMyUserData().
Definition: TeamTalk.cs:7742
BearWare.TeamTalkBase.GetMyUserType
UserType GetMyUserType()
Get the client instance's user type.
Definition: TeamTalk.cs:7704
BearWare.TeamTalkBase.GetUser
bool GetUser(int nUserID, ref User lpUser)
Get the user with the specified ID.
Definition: TeamTalk.cs:7750
BearWare.TeamTalkBase.GetUserByUsername
bool GetUserByUsername(string szUsername, ref User lpUser)
Get the user with the specified username.
Definition: TeamTalk.cs:7771
BearWare.Subscription
Subscription
A user by default accepts audio, video and text messages from all users. Using subscribtions can,...
Definition: TeamTalk.cs:2166
BearWare.UserState
UserState
The possible states for a user. Used for BearWare.User's uUserState variable.
Definition: TeamTalk.cs:2232
BearWare.TeamTalkBase.UserRights
BearWare.UserRight UserRights
Same as GetMyUserRights().
Definition: TeamTalk.cs:7717
BearWare.TeamTalkBase.GetMyUserData
int GetMyUserData()
If an account was used in TeamTalkBase.DoLogin() then this value will return the nUserData from the B...
Definition: TeamTalk.cs:7734
BearWare.TextMsgType
TextMsgType
Text message types.
Definition: TeamTalk.cs:2459
BearWare.UserType.USERTYPE_NONE
@ USERTYPE_NONE
Used internally to denote an unauthenticated user.
BearWare.UserType.USERTYPE_DEFAULT
@ USERTYPE_DEFAULT
A default user who can join channels.
BearWare.UserType.USERTYPE_ADMIN
@ USERTYPE_ADMIN
A user with administrator privileges.
BearWare.Subscription.SUBSCRIBE_INTERCEPT_CUSTOM_MSG
@ SUBSCRIBE_INTERCEPT_CUSTOM_MSG
Intercept all custom text messages sent by user. Only user-type BearWare.UserType....
BearWare.Subscription.SUBSCRIBE_VOICE
@ SUBSCRIBE_VOICE
Subscribing to BearWare.StreamType.STREAMTYPE_VOICE.
BearWare.Subscription.SUBSCRIBE_DESKTOPINPUT
@ SUBSCRIBE_DESKTOPINPUT
Subscribing to BearWare.StreamType.STREAMTYPE_DESKTOPINPUT.
BearWare.Subscription.SUBSCRIBE_VIDEOCAPTURE
@ SUBSCRIBE_VIDEOCAPTURE
Subscribing to BearWare.StreamType.STREAMTYPE_VIDEOCAPTURE.
BearWare.Subscription.SUBSCRIBE_MEDIAFILE
@ SUBSCRIBE_MEDIAFILE
Subscribing to BearWare.StreamType.STREAMTYPE_MEDIAFILE_VIDEO and BearWare.StreamType....
BearWare.Subscription.SUBSCRIBE_INTERCEPT_MEDIAFILE
@ SUBSCRIBE_INTERCEPT_MEDIAFILE
Intercept all media file data sent by a user. Only user-type BearWare.UserType.USERTYPE_ADMIN can do ...
BearWare.Subscription.SUBSCRIBE_BROADCAST_MSG
@ SUBSCRIBE_BROADCAST_MSG
Subscribing to broadcast text messsages.
BearWare.Subscription.SUBSCRIBE_INTERCEPT_CHANNEL_MSG
@ SUBSCRIBE_INTERCEPT_CHANNEL_MSG
Intercept all channel messages sent by a user. Only user-type BearWare.UserType.USERTYPE_ADMIN can do...
BearWare.Subscription.SUBSCRIBE_DESKTOP
@ SUBSCRIBE_DESKTOP
Subscribing to BearWare.StreamType.STREAMTYPE_DESKTOP.
BearWare.Subscription.SUBSCRIBE_INTERCEPT_VIDEOCAPTURE
@ SUBSCRIBE_INTERCEPT_VIDEOCAPTURE
Intercept all video sent by a user. Only user-type BearWare.UserType.USERTYPE_ADMIN can do this....
BearWare.Subscription.SUBSCRIBE_INTERCEPT_USER_MSG
@ SUBSCRIBE_INTERCEPT_USER_MSG
Intercept all user text messages sent by a user. Only user-type BearWare.UserType....
BearWare.Subscription.SUBSCRIBE_CUSTOM_MSG
@ SUBSCRIBE_CUSTOM_MSG
Subscribing to custom user messages.
BearWare.Subscription.SUBSCRIBE_INTERCEPT_DESKTOP
@ SUBSCRIBE_INTERCEPT_DESKTOP
Intercept all desktop data sent by a user. Only user-type BearWare.UserType.USERTYPE_ADMIN can do thi...
BearWare.Subscription.SUBSCRIBE_CHANNEL_MSG
@ SUBSCRIBE_CHANNEL_MSG
Subscribing to channel texxt messages.
BearWare.Subscription.SUBSCRIBE_USER_MSG
@ SUBSCRIBE_USER_MSG
Subscribing to user text messages.
BearWare.Subscription.SUBSCRIBE_NONE
@ SUBSCRIBE_NONE
No subscriptions.
BearWare.Subscription.SUBSCRIBE_INTERCEPT_VOICE
@ SUBSCRIBE_INTERCEPT_VOICE
Intercept all voice sent by a user. Only user-type BearWare.UserType.USERTYPE_ADMIN can do this....
BearWare.UserState.USERSTATE_MUTE_MEDIAFILE
@ USERSTATE_MUTE_MEDIAFILE
If set the user's media file playback is muted.
BearWare.UserState.USERSTATE_MEDIAFILE_AUDIO
@ USERSTATE_MEDIAFILE_AUDIO
If set the user currently streams an audio file. If user is streaming a video file with audio then th...
BearWare.UserState.USERSTATE_VIDEOCAPTURE
@ USERSTATE_VIDEOCAPTURE
If set the user currently has an active video stream. If this flag changes the event BearWare....
BearWare.UserState.USERSTATE_MUTE_VOICE
@ USERSTATE_MUTE_VOICE
If set the user's voice is muted.
BearWare.UserState.USERSTATE_VOICE
@ USERSTATE_VOICE
If set the user is currently talking. If this flag changes the event BearWare.ClientEvent....
BearWare.UserState.USERSTATE_DESKTOP
@ USERSTATE_DESKTOP
If set the user currently has an active desktop session. If this flag changes the event BearWare....
BearWare.UserState.USERSTATE_MEDIAFILE
@ USERSTATE_MEDIAFILE
If set user is streaming a media file. If this flag changes the event BearWare.ClientEvent....
BearWare.UserState.USERSTATE_MEDIAFILE_VIDEO
@ USERSTATE_MEDIAFILE_VIDEO
If set the user currently streams a video file. If this flag changes the event BearWare....
BearWare.UserState.USERSTATE_NONE
@ USERSTATE_NONE
The user is in initial state.
BearWare.TextMsgType.MSGTYPE_CUSTOM
@ MSGTYPE_CUSTOM
A custom user to user text message. Works the same way as BearWare.TextMsgType BearWare....
BearWare.TextMsgType.MSGTYPE_USER
@ MSGTYPE_USER
A User to user text message. A message of this type can be sent across channels.
BearWare.TextMsgType.MSGTYPE_BROADCAST
@ MSGTYPE_BROADCAST
A broadcast message. Requires BearWare.UserRight.USERRIGHT_TEXTMESSAGE_BROADCAST.
BearWare.TextMsgType.MSGTYPE_CHANNEL
@ MSGTYPE_CHANNEL
A User to channel text message. Users of type BearWare.UserType.USERTYPE_DEFAULT can only send this t...
BearWare.TeamTalkBase.PaintVideoFrame
bool PaintVideoFrame(int nUserID, System.IntPtr hDC, int XDest, int YDest, int nDestWidth, int nDestHeight, ref VideoFrame lpVideoFrame)
Paint user's video frame using a Windows' DC (device context).
Definition: TeamTalk.cs:5750
BearWare.TeamTalkBase.InitVideoCaptureDevice
bool InitVideoCaptureDevice(string szDeviceID, VideoFormat lpVideoFormat)
Initialize a video capture device.
Definition: TeamTalk.cs:5723
BearWare.TeamTalkBase.ReleaseUserVideoCaptureFrame
bool ReleaseUserVideoCaptureFrame(VideoFrame lpVideoFrame)
Delete a user's video frame, acquired through TeamTalkBase.AcquireUserVideoCaptureFrame(),...
Definition: TeamTalk.cs:5852
BearWare.TeamTalkBase.PaintVideoFrameEx
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)
Paint user's video frame using a Windows' DC (device context).
Definition: TeamTalk.cs:5793
BearWare.TeamTalkBase.AcquireUserVideoCaptureFrame
VideoFrame AcquireUserVideoCaptureFrame(int nUserID, out Bitmap bmp)
Extract a user's video frame for display.
Definition: TeamTalk.cs:5828
BearWare.TeamTalkBase.GetVideoCaptureDevices
static bool GetVideoCaptureDevices(out VideoCaptureDevice[] lpVideoDevices)
Get the list of devices available for video capture.
Definition: TeamTalk.cs:5695
BearWare.TeamTalkBase.CloseVideoCaptureDevice
bool CloseVideoCaptureDevice()
Close a video capture device.
Definition: TeamTalk.cs:5732
BearWare.FourCC
FourCC
The picture format used by a capture device.
Definition: TeamTalk.cs:602
BearWare.TeamTalkBase.TT_VIDEOFORMATS_MAX
const int TT_VIDEOFORMATS_MAX
Definition: TeamTalk.cs:4193
BearWare.FourCC.FOURCC_YUY2
@ FOURCC_YUY2
Image format where a 640x480 pixel images takes up 614.400 bytes.
BearWare.FourCC.FOURCC_NONE
@ FOURCC_NONE
Internal use to denote no supported formats.
BearWare.FourCC.FOURCC_I420
@ FOURCC_I420
Prefered image format with the lowest bandwidth usage. A 640x480 pixel image takes up 460....
BearWare.FourCC.FOURCC_RGB32
@ FOURCC_RGB32
The image format with the highest bandwidth usage. A 640x480 pixel images takes up 1....
BearWare
Definition: modules-net.txt:2
BearWare.AbusePrevention
Properties to prevent server abuse.
Definition: TeamTalk.cs:2067
BearWare.AbusePrevention.nCommandsLimit
int nCommandsLimit
Limit number of commands a user can send to the server.
Definition: TeamTalk.cs:2077
BearWare.AbusePrevention.nCommandsIntervalMSec
int nCommandsIntervalMSec
Commands within given interval.
Definition: TeamTalk.cs:2079
BearWare.AudioBlock
An audio block containing the raw audio from a user who was talking.
Definition: TeamTalk.cs:475
BearWare.AudioBlock.nSamples
int nSamples
The number of samples in the raw audio array.
Definition: TeamTalk.cs:489
BearWare.AudioBlock.uStreamTypes
StreamType uStreamTypes
The stream types used to generate the AudioBlock's raw audio.
Definition: TeamTalk.cs:510
BearWare.AudioBlock.nSampleRate
int nSampleRate
The sample rate of the raw audio.
Definition: TeamTalk.cs:481
BearWare.AudioBlock.uSampleIndex
uint uSampleIndex
The index of the first sample in lpRawAudio. Its value will be a multiple of nSamples....
Definition: TeamTalk.cs:497
BearWare.AudioBlock.nStreamID
int nStreamID
The ID of the stream. The stream id changes every time the user enables a new transmission using Team...
Definition: TeamTalk.cs:479
BearWare.AudioBlock.nChannels
int nChannels
The number of channels used (1 for mono, 2 for stereo).
Definition: TeamTalk.cs:483
BearWare.AudioBlock.lpRawAudio
System.IntPtr lpRawAudio
The raw audio in 16-bit integer format array. The size of the array in bytes is sizeof(short) * nSamp...
Definition: TeamTalk.cs:487
BearWare.AudioCodec
Struct used for specifying which audio codec a channel uses.
Definition: TeamTalk.cs:1534
BearWare.AudioCodec.speex_vbr
SpeexVBRCodec speex_vbr
Speex codec settings if nCodec is BearWare.Codec.SPEEX_VBR_CODEC.
Definition: TeamTalk.cs:1546
BearWare.AudioCodec.speex
SpeexCodec speex
Speex codec settings if nCodec is BearWare.Codec.SPEEX_CODEC.
Definition: TeamTalk.cs:1542
BearWare.AudioCodec.nCodec
Codec nCodec
Specifies whether the member speex, speex_vbr or opus holds the codec settings.
Definition: TeamTalk.cs:1538
BearWare.AudioCodec.opus
OpusCodec opus
Opus codec settings if nCodec is OPUS_CODEC.
Definition: TeamTalk.cs:1550
BearWare.AudioConfigConstants
Definition: TeamTalk.cs:1592
BearWare.AudioConfigConstants.DEFAULT_AGC_INC_MAXDB
const int DEFAULT_AGC_INC_MAXDB
Definition: TeamTalk.cs:1594
BearWare.AudioConfigConstants.DEFAULT_AGC_GAINLEVEL
const int DEFAULT_AGC_GAINLEVEL
Definition: TeamTalk.cs:1593
BearWare.AudioConfig
Audio configuration for clients in a channel.
Definition: TeamTalk.cs:1568
BearWare.AudioConfig.AudioConfig
AudioConfig(bool set_defaults)
Definition: TeamTalk.cs:1576
BearWare.AudioConfig.nGainLevel
int nGainLevel
Reference gain level to be used by all users.
Definition: TeamTalk.cs:1574
BearWare.AudioConfig.bEnableAGC
bool bEnableAGC
Users should enable automatic gain control.
Definition: TeamTalk.cs:1571
BearWare.AudioFormat
Struct describing the audio format used by a media file.
Definition: TeamTalk.cs:582
BearWare.AudioFormat.nAudioFmt
AudioFileFormat nAudioFmt
The audio file format, e.g. wave or MP3.
Definition: TeamTalk.cs:584
BearWare.AudioFormat.nSampleRate
int nSampleRate
Sample rate of media file.
Definition: TeamTalk.cs:586
BearWare.AudioFormat.nChannels
int nChannels
Channels used by media file, mono = 1, stereo = 2.
Definition: TeamTalk.cs:588
BearWare.AudioInputProgress
The progress of the audio currently being processed as audio input.
Definition: TeamTalk.cs:1663
BearWare.AudioInputProgress.uElapsedMSec
uint uElapsedMSec
The duration of the audio that has been transmitted.
Definition: TeamTalk.cs:1671
BearWare.AudioInputProgress.nStreamID
int nStreamID
The stream ID provided in the BearWare.AudioBlock.
Definition: TeamTalk.cs:1665
BearWare.AudioInputProgress.uQueueMSec
uint uQueueMSec
The duration of the audio currently queued for transmission.
Definition: TeamTalk.cs:1668
BearWare.AudioPreprocessor
Configure the audio preprocessor specified by nPreprocessor.
Definition: TeamTalk.cs:1438
BearWare.AudioPreprocessor.webrtc
WebRTCAudioPreprocessor webrtc
Used when nPreprocessor is BearWare.AudioPreprocessorType.WEBRTC_AUDIOPREPROCESSOR.
Definition: TeamTalk.cs:1450
BearWare.AudioPreprocessor.speexdsp
SpeexDSP speexdsp
Used when nPreprocessor is BearWare.AudioPreprocessorType.SPEEXDSP_AUDIOPREPROCESSOR.
Definition: TeamTalk.cs:1444
BearWare.AudioPreprocessor.nPreprocessor
AudioPreprocessorType nPreprocessor
The audio preprocessor to use in the union of audio preprocessors.
Definition: TeamTalk.cs:1441
BearWare.AudioPreprocessor.ttpreprocessor
TTAudioPreprocessor ttpreprocessor
Used when nPreprocessor is BearWare.AudioPreprocessorType.TEAMTALK_AUDIOPREPROCESSOR.
Definition: TeamTalk.cs:1447
BearWare.BannedUser
A struct containing the properties of a banned user.
Definition: TeamTalk.cs:2019
BearWare.BannedUser.szIPAddress
string szIPAddress
IP-address of banned user.
Definition: TeamTalk.cs:2022
BearWare.BannedUser.szNickname
string szNickname
Nickname of banned user. Read-only property.
Definition: TeamTalk.cs:2031
BearWare.BannedUser.szChannelPath
string szChannelPath
Channel where user was located when banned.
Definition: TeamTalk.cs:2025
BearWare.BannedUser.szOwner
string szOwner
The username of the user who made the ban.
Definition: TeamTalk.cs:2039
BearWare.BannedUser.szUsername
string szUsername
Username of banned user.
Definition: TeamTalk.cs:2034
BearWare.BannedUser.uBanTypes
BanType uBanTypes
The type of ban that applies to this banned user.
Definition: TeamTalk.cs:2036
BearWare.BannedUser.szBanTime
string szBanTime
Date and time when user was banned. Read-only property.
Definition: TeamTalk.cs:2028
BearWare.Channel
A struct containing the properties of a channel.
Definition: TeamTalk.cs:2563
BearWare.Channel.nTransmitUsersQueueDelayMSec
int nTransmitUsersQueueDelayMSec
Delay for switching to next active voice user in transmitUsersQueue.
Definition: TeamTalk.cs:2674
BearWare.Channel.transmitUsersQueue
int[] transmitUsersQueue
The users currently queued for voice or media file transmission.
Definition: TeamTalk.cs:2665
BearWare.Channel.AddTransmitUser
void AddTransmitUser(int nUserID, StreamType uStreamType)
Helper function for adding a user and BearWare.StreamType to transmitUsers.
Definition: TeamTalk.cs:2688
BearWare.Channel.GetTransmitUserCount
int GetTransmitUserCount()
Get the number of users who can currently transmit to the BearWare.ChannelType.CHANNEL_CLASSROOM.
Definition: TeamTalk.cs:2715
BearWare.Channel.audiocfg
AudioConfig audiocfg
The audio configuration which users who join the channel should use.
Definition: TeamTalk.cs:2602
BearWare.Channel.RemoveTransmitUser
void RemoveTransmitUser(int nUserID, StreamType uStreamType)
Helper function for removing a BearWare.StreamType for a user in transmitUsers.
Definition: TeamTalk.cs:2726
BearWare.Channel.nTimeOutTimerMediaFileMSec
int nTimeOutTimerMediaFileMSec
Time out timer for media file stream. The maximum time in miliseconds a user can transmit a media fil...
Definition: TeamTalk.cs:2684
BearWare.Channel.bPassword
bool bPassword
Whether password is required to join channel. Read-only property.
Definition: TeamTalk.cs:2583
BearWare.Channel.szPassword
string szPassword
Password to join the channel. When extracted through TeamTalkBase.GetChannel() the password will only...
Definition: TeamTalk.cs:2580
BearWare.Channel.nDiskQuota
long nDiskQuota
Number of bytes available for file storage.
Definition: TeamTalk.cs:2591
BearWare.Channel.transmitUsers
int[] transmitUsers
List of users who can transmit in a channel.
Definition: TeamTalk.cs:2659
BearWare.Channel.GetTransmitStreamTypes
StreamType GetTransmitStreamTypes(int nUserID)
Helper function for getting the BearWare.StreamType a user can transmit by querying transmitUsers.
Definition: TeamTalk.cs:2704
BearWare.Channel.szTopic
string szTopic
Topic of the channel.
Definition: TeamTalk.cs:2575
BearWare.Channel.audiocodec
AudioCodec audiocodec
The audio codec used by users in the channel.
Definition: TeamTalk.cs:2599
BearWare.Channel.nUserData
int nUserData
User specific data which will be stored on persistent storage on the server if the channel type is Be...
Definition: TeamTalk.cs:2589
BearWare.Channel.nTimeOutTimerVoiceMSec
int nTimeOutTimerVoiceMSec
Time out timer for voice stream. The maximum time in miliseconds a user can transmit voice without ch...
Definition: TeamTalk.cs:2679
BearWare.Channel.szOpPassword
string szOpPassword
Password to become channel operator.
Definition: TeamTalk.cs:2595
BearWare.Channel.nParentID
int nParentID
Parent channel ID. 0 means no parent channel, i.e. it's the root channel.
Definition: TeamTalk.cs:2566
BearWare.Channel.nChannelID
int nChannelID
The channel's ID. A value from 1 - BearWare.TeamTalkBase.TT_CHANNELID_MAX.
Definition: TeamTalk.cs:2569
BearWare.Channel.uChannelType
ChannelType uChannelType
A bitmask of the type of channel based on BearWare.ChannelType.
Definition: TeamTalk.cs:2585
BearWare.Channel.nMaxUsers
int nMaxUsers
Max number of users in channel.
Definition: TeamTalk.cs:2597
BearWare.Channel.szName
string szName
Name of the channel.
Definition: TeamTalk.cs:2572
BearWare.ClientErrorMsg
Definition: TeamTalk.cs:3326
BearWare.ClientErrorMsg.szErrorMsg
string szErrorMsg
Text message describing the error.
Definition: TeamTalk.cs:3331
BearWare.ClientErrorMsg.nErrorNo
int nErrorNo
Error number based on BearWare.ClientError.
Definition: TeamTalk.cs:3328
BearWare.ClientKeepAlive
Control timers for sending keep alive information to the server.
Definition: TeamTalk.cs:2884
BearWare.ClientKeepAlive.nUdpConnectTimeoutMSec
int nUdpConnectTimeoutMSec
The duration before the client instance should give up trying to connect to the server on UDP....
Definition: TeamTalk.cs:2926
BearWare.ClientKeepAlive.nUdpKeepAliveRTXMSec
int nUdpKeepAliveRTXMSec
Client instance's interval for retransmitting UDP keep alive packets. If server hasn't responded to U...
Definition: TeamTalk.cs:2911
BearWare.ClientKeepAlive.nUdpConnectRTXMSec
int nUdpConnectRTXMSec
Client instance's interval for retransmitting UDP connect packets. UDP connect packets are only sent ...
Definition: TeamTalk.cs:2918
BearWare.ClientKeepAlive.nTcpKeepAliveIntervalMSec
int nTcpKeepAliveIntervalMSec
Client instance's interval between TeamTalkBase.DoPing() command. Read-only value....
Definition: TeamTalk.cs:2899
BearWare.ClientKeepAlive.nUdpKeepAliveIntervalMSec
int nUdpKeepAliveIntervalMSec
Client instance's interval between sending UDP keep alive packets. The UDP keep alive packets are use...
Definition: TeamTalk.cs:2905
BearWare.ClientKeepAlive.nConnectionLostMSec
int nConnectionLostMSec
The duration before the TeamTalk instance should consider the client/server connection lost.
Definition: TeamTalk.cs:2895
BearWare.ClientStatistics
Statistics of bandwidth usage and ping times in the local client instance.
Definition: TeamTalk.cs:2935
BearWare.ClientStatistics.nVoiceBytesRecv
long nVoiceBytesRecv
Voice data received (on UDP).
Definition: TeamTalk.cs:2943
BearWare.ClientStatistics.nSoundInputDeviceDelayMSec
int nSoundInputDeviceDelayMSec
Delay of sound input device until the first audio frame is delivered (in msec).
Definition: TeamTalk.cs:2985
BearWare.ClientStatistics.nVideoCaptureBytesRecv
long nVideoCaptureBytesRecv
Video data received (on UDP).
Definition: TeamTalk.cs:2947
BearWare.ClientStatistics.nTcpPingTimeMs
int nTcpPingTimeMs
Response time to server on TCP (based on ping/pong sent at a specified interval. Set to -1 if not cur...
Definition: TeamTalk.cs:2967
BearWare.ClientStatistics.nUdpServerSilenceSec
int nUdpServerSilenceSec
The number of seconds nothing has been received by the client on UDP.
Definition: TeamTalk.cs:2973
BearWare.ClientStatistics.nMediaFileVideoBytesSent
long nMediaFileVideoBytesSent
Video from media file data sent (on UDP).
Definition: TeamTalk.cs:2953
BearWare.ClientStatistics.nMediaFileVideoBytesRecv
long nMediaFileVideoBytesRecv
Video from media file data received (on UDP).
Definition: TeamTalk.cs:2955
BearWare.ClientStatistics.nMediaFileAudioBytesSent
long nMediaFileAudioBytesSent
Audio from media file data sent (on UDP).
Definition: TeamTalk.cs:2949
BearWare.ClientStatistics.nVoiceBytesSent
long nVoiceBytesSent
Voice data sent (on UDP).
Definition: TeamTalk.cs:2941
BearWare.ClientStatistics.nUdpBytesSent
long nUdpBytesSent
Bytes sent on UDP.
Definition: TeamTalk.cs:2937
BearWare.ClientStatistics.nMediaFileAudioBytesRecv
long nMediaFileAudioBytesRecv
Audio from media file data received (on UDP).
Definition: TeamTalk.cs:2951
BearWare.ClientStatistics.nVideoCaptureBytesSent
long nVideoCaptureBytesSent
Video data sent (on UDP).
Definition: TeamTalk.cs:2945
BearWare.ClientStatistics.nTcpServerSilenceSec
int nTcpServerSilenceSec
The number of seconds nothing has been received by the client on TCP.
Definition: TeamTalk.cs:2970
BearWare.ClientStatistics.nUdpBytesRecv
long nUdpBytesRecv
Bytes received on UDP.
Definition: TeamTalk.cs:2939
BearWare.ClientStatistics.nDesktopBytesSent
long nDesktopBytesSent
Desktop data sent (on UDP).
Definition: TeamTalk.cs:2957
BearWare.ClientStatistics.nDesktopBytesRecv
long nDesktopBytesRecv
Desktop data received (on UDP).
Definition: TeamTalk.cs:2959
BearWare.ClientStatistics.nUdpPingTimeMs
int nUdpPingTimeMs
Response time to server on UDP (based on ping/pong sent at a specified interval. Set to -1 if not cur...
Definition: TeamTalk.cs:2963
BearWare.DesktopInputConstants
Constants for BearWare.DesktopInput.
Definition: TeamTalk.cs:852
BearWare.DesktopInput
A struct containing a mouse or keyboard event.
Definition: TeamTalk.cs:814
BearWare.DesktopInput.uMousePosX
ushort uMousePosX
The X coordinate of the mouse. If used with WindowsHelper.Execute() and the mouse position should be ...
Definition: TeamTalk.cs:818
BearWare.DesktopInput.uKeyCode
uint uKeyCode
The key-code (or mouse button) pressed. If used with TeamTalkBase.DesktopInput_Execute() and no key (...
Definition: TeamTalk.cs:828
BearWare.DesktopInput.DesktopInput
DesktopInput(bool set_defaults)
When true initializes the desktop input to ignore mouse and key values.
Definition: TeamTalk.cs:833
BearWare.DesktopInput.uMousePosY
ushort uMousePosY
The Y coordinate of the mouse. If used with TeamTalkBase.DesktopInput_Execute() and the mouse positio...
Definition: TeamTalk.cs:822
BearWare.DesktopInput.uKeyState
DesktopKeyState uKeyState
The state of the key (or mouse button) pressed, i.e. if it's up or down.
Definition: TeamTalk.cs:831
BearWare.DesktopWindow
A struct containing the properties of a shared desktop window.
Definition: TeamTalk.cs:766
BearWare.DesktopWindow.nSessionID
int nSessionID
The ID of the session which the bitmap belongs to. If the session ID changes it means the user has st...
Definition: TeamTalk.cs:782
BearWare.DesktopWindow.nWidth
int nWidth
The width in pixels of the bitmap.
Definition: TeamTalk.cs:768
BearWare.DesktopWindow.nProtocol
DesktopProtocol nProtocol
The desktop protocol used for transmitting the desktop window.
Definition: TeamTalk.cs:784
BearWare.DesktopWindow.nBytesPerLine
int nBytesPerLine
The number of bytes for each scan-line in the bitmap. Zero means 4-byte aligned.
Definition: TeamTalk.cs:775
BearWare.DesktopWindow.frameBuffer
IntPtr frameBuffer
A buffer pointing to the bitmap data (often refered to as Scan0).
Definition: TeamTalk.cs:786
BearWare.DesktopWindow.nFrameBufferSize
int nFrameBufferSize
The size in bytes of the buffer allocate in frameBuffer. Typically nBytesPerLine * nHeight.
Definition: TeamTalk.cs:789
BearWare.DesktopWindow.bmpFormat
BitmapFormat bmpFormat
The format of the bitmap.
Definition: TeamTalk.cs:772
BearWare.DesktopWindow.nHeight
int nHeight
The height in pixels of the bitmap.
Definition: TeamTalk.cs:770
BearWare.EncryptionContext
Configure peer verification for encrypted connection.
Definition: TeamTalk.cs:2826
BearWare.EncryptionContext.szCAFile
string szCAFile
Path to Certificate Authority (CA) Certificate in PEM format.
Definition: TeamTalk.cs:2842
BearWare.EncryptionContext.bVerifyClientOnce
bool bVerifyClientOnce
Whether to only verify client's certificate once during initial connection.
Definition: TeamTalk.cs:2864
BearWare.EncryptionContext.nVerifyDepth
int nVerifyDepth
Set limit to depth in the certificate chain during the verification procedure.
Definition: TeamTalk.cs:2872
BearWare.EncryptionContext.szCertificateFile
string szCertificateFile
Path to SSL certificate in PEM format.
Definition: TeamTalk.cs:2833
BearWare.EncryptionContext.szPrivateKeyFile
string szPrivateKeyFile
Path to certificate's private key.
Definition: TeamTalk.cs:2836
BearWare.EncryptionContext.bVerifyPeer
bool bVerifyPeer
Verify that peer (client or server) uses a certificate that has been generated by the Certificate Aut...
Definition: TeamTalk.cs:2853
BearWare.EncryptionContext.szCADir
string szCADir
Path to directory containing Certificate Authority (CA) Certificates in PEM format.
Definition: TeamTalk.cs:2846
BearWare.FileTransfer
A struct containing the properties of a file transfer.
Definition: TeamTalk.cs:2770
BearWare.FileTransfer.bInbound
bool bInbound
TRUE if download and FALSE if upload.
Definition: TeamTalk.cs:2788
BearWare.FileTransfer.nStatus
FileTransferStatus nStatus
Status of file transfer.
Definition: TeamTalk.cs:2772
BearWare.FileTransfer.szRemoteFileName
string szRemoteFileName
The filename in the channel.
Definition: TeamTalk.cs:2782
BearWare.FileTransfer.szLocalFilePath
string szLocalFilePath
The file path on local disk.
Definition: TeamTalk.cs:2779
BearWare.FileTransfer.nTransferred
long nTransferred
The number of bytes transferred so far.
Definition: TeamTalk.cs:2786
BearWare.FileTransfer.nFileSize
long nFileSize
The size of the file being transferred.
Definition: TeamTalk.cs:2784
BearWare.FileTransfer.nTransferID
int nTransferID
The ID identifying the file transfer.
Definition: TeamTalk.cs:2774
BearWare.FileTransfer.nChannelID
int nChannelID
The channel where the file is/will be located.
Definition: TeamTalk.cs:2776
BearWare.JitterConfig
Configuration parameters for the Jitter Buffer.
Definition: TeamTalk.cs:2995
BearWare.JitterConfig.nMaxAdaptiveDelayMSec
int nMaxAdaptiveDelayMSec
A hard maximum delay on the adaptive delay. Only valid when higher than zero. Default = 0.
Definition: TeamTalk.cs:3002
BearWare.JitterConfig.nActiveAdaptiveDelayMSec
int nActiveAdaptiveDelayMSec
The current adaptive delay. When used with TeamTalkBase.SetUserJitterControl(), this value is used as...
Definition: TeamTalk.cs:3009
BearWare.JitterConfig.bUseAdativeDejitter
bool bUseAdativeDejitter
Turns adaptive jitter buffering ON/OFF. Default is OFF.
Definition: TeamTalk.cs:2999
BearWare.JitterConfig.nFixedDelayMSec
int nFixedDelayMSec
The fixed delay in milliseconds. Default = 0.
Definition: TeamTalk.cs:2997
BearWare.MediaFileInfo
Struct describing the audio and video format used by a media file.
Definition: TeamTalk.cs:1621
BearWare.MediaFileInfo.uElapsedMSec
uint uElapsedMSec
The elapsed time of the media file in miliseconds.
Definition: TeamTalk.cs:1635
BearWare.MediaFileInfo.audioFmt
AudioFormat audioFmt
The audio properties of the media file.
Definition: TeamTalk.cs:1629
BearWare.MediaFileInfo.videoFmt
VideoFormat videoFmt
The video properties of the media file.
Definition: TeamTalk.cs:1631
BearWare.MediaFileInfo.szFileName
string szFileName
Name of file.
Definition: TeamTalk.cs:1627
BearWare.MediaFileInfo.uDurationMSec
uint uDurationMSec
The duration of the media file in miliseconds.
Definition: TeamTalk.cs:1633
BearWare.MediaFileInfo.nStatus
MediaFileStatus nStatus
Status of media file if it's being saved to disk.
Definition: TeamTalk.cs:1624
BearWare.MediaFilePlayback
Properties for initializing or updating a file for media streaming.
Definition: TeamTalk.cs:1647
BearWare.MediaFilePlayback.uOffsetMSec
uint uOffsetMSec
Offset in milliseconds in the media file where to start playback. Pass BearWare.TeamTalkBase....
Definition: TeamTalk.cs:1652
BearWare.MediaFilePlayback.audioPreprocessor
AudioPreprocessor audioPreprocessor
Option to activate audio preprocessor on local media file playback.
Definition: TeamTalk.cs:1656
BearWare.MediaFilePlayback.bPaused
bool bPaused
Start or pause media file playback.
Definition: TeamTalk.cs:1654
BearWare.OpusCodec
OPUS audio codec settings. For detailed information about the OPUS codec check out http://www....
Definition: TeamTalk.cs:1043
BearWare.OpusCodec.nFrameSizeMSec
int nFrameSizeMSec
OPUS supports 2.5, 5, 10, 20, 40, 60, 80, 100 and 120 msec. If nFrameSizeMSec is 0 then nFrameSizeMSe...
Definition: TeamTalk.cs:1081
BearWare.OpusCodec.bFEC
bool bFEC
Forward error correction. Corrects errors if there's packetloss.
Definition: TeamTalk.cs:1058
BearWare.OpusCodec.bVBR
bool bVBR
Enable variable bitrate.
Definition: TeamTalk.cs:1067
BearWare.OpusCodec.nComplexity
int nComplexity
Complexity of encoding (affects CPU usage). Value from 0-10.
Definition: TeamTalk.cs:1055
BearWare.OpusCodec.bDTX
bool bDTX
Discontinuous transmission. Enables "null" packets during silence.
Definition: TeamTalk.cs:1061
BearWare.OpusCodec.nSampleRate
int nSampleRate
The sample rate to use. Sample rate must be 8000, 12000, 16000, 24000 or 48000 Hz.
Definition: TeamTalk.cs:1046
BearWare.OpusCodec.nApplication
int nApplication
Application of encoded audio, VoIP or music.
Definition: TeamTalk.cs:1052
BearWare.OpusCodec.bVBRConstraint
bool bVBRConstraint
Enable constrained VBR. bVBR must be enabled to enable this.
Definition: TeamTalk.cs:1070
BearWare.OpusCodec.nTxIntervalMSec
int nTxIntervalMSec
Duration of audio before each transmission. Minimum is 2 msec. Recommended is 40 msec....
Definition: TeamTalk.cs:1077
BearWare.OpusCodec.nBitRate
int nBitRate
Bitrate for encoded audio. Should be between BearWare.OpusConstants.OPUS_MIN_BITRATE and BearWare....
Definition: TeamTalk.cs:1065
BearWare.OpusCodec.nChannels
int nChannels
Mono = 1 or stereo = 2.
Definition: TeamTalk.cs:1048
BearWare.OpusConstants
OPUS constants for BearWare.OpusCodec.
Definition: TeamTalk.cs:1086
BearWare.OpusConstants.DEFAULT_OPUS_FEC
const bool DEFAULT_OPUS_FEC
Definition: TeamTalk.cs:1115
BearWare.OpusConstants.DEFAULT_OPUS_COMPLEXITY
const int DEFAULT_OPUS_COMPLEXITY
Definition: TeamTalk.cs:1114
BearWare.OpusConstants.DEFAULT_OPUS_VBR
const bool DEFAULT_OPUS_VBR
Definition: TeamTalk.cs:1117
BearWare.OpusConstants.DEFAULT_OPUS_VBRCONSTRAINT
const bool DEFAULT_OPUS_VBRCONSTRAINT
Definition: TeamTalk.cs:1118
BearWare.OpusConstants.DEFAULT_OPUS_APPLICATION
const int DEFAULT_OPUS_APPLICATION
Definition: TeamTalk.cs:1111
BearWare.OpusConstants.OPUS_MIN_FRAMESIZE
const int OPUS_MIN_FRAMESIZE
The minimum frame size for OPUS codec. Checkout nFrameSizeMSec of BearWare.OpusCodec.
Definition: TeamTalk.cs:1102
BearWare.OpusConstants.DEFAULT_OPUS_CHANNELS
const int DEFAULT_OPUS_CHANNELS
Definition: TeamTalk.cs:1113
BearWare.OpusConstants.DEFAULT_OPUS_DTX
const bool DEFAULT_OPUS_DTX
Definition: TeamTalk.cs:1116
BearWare.OpusConstants.OPUS_MAX_BITRATE
const int OPUS_MAX_BITRATE
The maximum bitrate for OPUS codec. Checkout nBitRate of BearWare.OpusCodec.
Definition: TeamTalk.cs:1098
BearWare.OpusConstants.DEFAULT_OPUS_DELAY
const int DEFAULT_OPUS_DELAY
Definition: TeamTalk.cs:1120
BearWare.OpusConstants.OPUS_REALMAX_FRAMESIZE
const int OPUS_REALMAX_FRAMESIZE
The real maximum frame size for OPUS codec. Checkout nFrameSizeMSec of BearWare.OpusCodec....
Definition: TeamTalk.cs:1109
BearWare.OpusConstants.OPUS_MAX_FRAMESIZE
const int OPUS_MAX_FRAMESIZE
The maximum frame size for OPUS codec. Checkout nFrameSizeMSec of BearWare.OpusCodec.
Definition: TeamTalk.cs:1105
BearWare.OpusConstants.DEFAULT_OPUS_SAMPLERATE
const int DEFAULT_OPUS_SAMPLERATE
Definition: TeamTalk.cs:1112
BearWare.OpusConstants.OPUS_APPLICATION_AUDIO
const int OPUS_APPLICATION_AUDIO
Audio encoding is for music. This value should be set as nApplicaton in BearWare.OpusCodec.
Definition: TeamTalk.cs:1092
BearWare.OpusConstants.OPUS_MIN_BITRATE
const int OPUS_MIN_BITRATE
The minimum bitrate for OPUS codec. Checkout nBitRate of BearWare.OpusCodec.
Definition: TeamTalk.cs:1095
BearWare.OpusConstants.DEFAULT_OPUS_BITRATE
const int DEFAULT_OPUS_BITRATE
Definition: TeamTalk.cs:1119
BearWare.OpusConstants.OPUS_APPLICATION_VOIP
const int OPUS_APPLICATION_VOIP
Audio encoding is for VoIP. This value should be set as nApplicaton in BearWare.OpusCodec.
Definition: TeamTalk.cs:1089
BearWare.RemoteFile
A struct containing the properties of a file in a BearWare.Channel.
Definition: TeamTalk.cs:2796
BearWare.RemoteFile.nChannelID
int nChannelID
The ID of the channel where the file is located.
Definition: TeamTalk.cs:2798
BearWare.RemoteFile.nFileSize
long nFileSize
The size of the file.
Definition: TeamTalk.cs:2805
BearWare.RemoteFile.szUploadTime
string szUploadTime
Time when file was uploaded. Date/time is converted local time.
Definition: TeamTalk.cs:2812
BearWare.RemoteFile.szFileName
string szFileName
The name of the file.
Definition: TeamTalk.cs:2803
BearWare.RemoteFile.nFileID
int nFileID
The ID identifying the file.
Definition: TeamTalk.cs:2800
BearWare.RemoteFile.szUsername
string szUsername
Username of the person who uploaded the files.
Definition: TeamTalk.cs:2808
BearWare.ServerProperties
A struct containing the properties of the server's settings.
Definition: TeamTalk.cs:1854
BearWare.ServerProperties.nMaxMediaFileTxPerSecond
int nMaxMediaFileTxPerSecond
The maximum number of bytes per second which the server will allow for media file packets....
Definition: TeamTalk.cs:1893
BearWare.ServerProperties.nUserTimeout
int nUserTimeout
The number of seconds before a user who hasn't responded to keepalives will be kicked off the server.
Definition: TeamTalk.cs:1910
BearWare.ServerProperties.bAutoSave
bool bAutoSave
Whether the server automatically saves changes.
Definition: TeamTalk.cs:1903
BearWare.ServerProperties.szServerProtocolVersion
string szServerProtocolVersion
The version of the server's protocol.
Definition: TeamTalk.cs:1916
BearWare.ServerProperties.nMaxLoginsPerIPAddress
int nMaxLoginsPerIPAddress
The maximum number of users allowed to log in with the same IP-address. 0 means disabled.
Definition: TeamTalk.cs:1880
BearWare.ServerProperties.uServerLogEvents
ServerLogEvent uServerLogEvents
The events that are logged on the server.
Definition: TeamTalk.cs:1936
BearWare.ServerProperties.szAccessToken
string szAccessToken
A randomly generated 256 bit access token created by the server to identify the login session....
Definition: TeamTalk.cs:1930
BearWare.ServerProperties.nMaxDesktopTxPerSecond
int nMaxDesktopTxPerSecond
The maximum number of bytes per second which the server will allow for desktop packets....
Definition: TeamTalk.cs:1897
BearWare.ServerProperties.nUdpPort
int nUdpPort
The server's UDP port.
Definition: TeamTalk.cs:1907
BearWare.ServerProperties.nLoginDelayMSec
int nLoginDelayMSec
Number of msec before an IP-address can make another login attempt. If less than this amount then Tea...
Definition: TeamTalk.cs:1925
BearWare.ServerProperties.nMaxTotalTxPerSecond
int nMaxTotalTxPerSecond
The amount of bytes per second which the server will allow for packet forwarding. If this value is ex...
Definition: TeamTalk.cs:1901
BearWare.ServerProperties.szServerName
string szServerName
The server's name.
Definition: TeamTalk.cs:1857
BearWare.ServerProperties.nMaxLoginAttempts
int nMaxLoginAttempts
The maximum number of logins with wrong password before banning user's IP-address.
Definition: TeamTalk.cs:1877
BearWare.ServerProperties.szMOTD
string szMOTD
The message of the day. Read-only property. Use szMOTDRaw to update this property.
Definition: TeamTalk.cs:1861
BearWare.ServerProperties.szMOTDRaw
string szMOTDRaw
The message of the day including variables. The result of the szMOTDRaw string will be displayed in s...
Definition: TeamTalk.cs:1871
BearWare.ServerProperties.nMaxUsers
int nMaxUsers
The maximum number of users allowed on the server. A user with admin account can ignore this.
Definition: TeamTalk.cs:1874
BearWare.ServerProperties.nTcpPort
int nTcpPort
The server's TCP port.
Definition: TeamTalk.cs:1905
BearWare.ServerProperties.szServerVersion
string szServerVersion
The server version.
Definition: TeamTalk.cs:1913
BearWare.ServerProperties.nMaxVoiceTxPerSecond
int nMaxVoiceTxPerSecond
The maximum number of bytes per second which the server will allow for voice packets....
Definition: TeamTalk.cs:1884
BearWare.ServerProperties.nMaxVideoCaptureTxPerSecond
int nMaxVideoCaptureTxPerSecond
The maximum number of bytes per second which the server will allow for video input packets....
Definition: TeamTalk.cs:1889
BearWare.ServerStatistics
A struct containing the server's statistics, i.e. bandwidth usage and user activity.
Definition: TeamTalk.cs:1948
BearWare.ServerStatistics.nMediaFileBytesTX
long nMediaFileBytesTX
The number of bytes in media file packets sent from the server to clients.
Definition: TeamTalk.cs:1969
BearWare.ServerStatistics.nVideoCaptureBytesTX
long nVideoCaptureBytesTX
The number of bytes in video packets sent from the server to clients.
Definition: TeamTalk.cs:1963
BearWare.ServerStatistics.nFilesRx
long nFilesRx
The number of bytes for file transmission received by the server.
Definition: TeamTalk.cs:1988
BearWare.ServerStatistics.nDesktopBytesTX
long nDesktopBytesTX
The number of bytes in desktop packets sent from the server to clients.
Definition: TeamTalk.cs:1975
BearWare.ServerStatistics.nFilesTx
long nFilesTx
The number of bytes for file transmission transmitted from the server.
Definition: TeamTalk.cs:1985
BearWare.ServerStatistics.nUptimeMSec
long nUptimeMSec
The server's uptime in msec.
Definition: TeamTalk.cs:1990
BearWare.ServerStatistics.nVoiceBytesRX
long nVoiceBytesRX
The number of bytes in audio packets received by the server from clients.
Definition: TeamTalk.cs:1960
BearWare.ServerStatistics.nUsersServed
int nUsersServed
The number of users who have logged on to the server.
Definition: TeamTalk.cs:1980
BearWare.ServerStatistics.nTotalBytesRX
long nTotalBytesRX
The number of bytes received by the server from clients.
Definition: TeamTalk.cs:1954
BearWare.ServerStatistics.nTotalBytesTX
long nTotalBytesTX
The number of bytes sent from the server to clients.
Definition: TeamTalk.cs:1951
BearWare.ServerStatistics.nVideoCaptureBytesRX
long nVideoCaptureBytesRX
The number of bytes in video packets received by the server from clients.
Definition: TeamTalk.cs:1966
BearWare.ServerStatistics.nDesktopBytesRX
long nDesktopBytesRX
The number of bytes in desktop packets received by the server from clients.
Definition: TeamTalk.cs:1978
BearWare.ServerStatistics.nVoiceBytesTX
long nVoiceBytesTX
The number of bytes in audio packets sent from the server to clients.
Definition: TeamTalk.cs:1957
BearWare.ServerStatistics.nMediaFileBytesRX
long nMediaFileBytesRX
The number of bytes in media file packets received by the server from clients.
Definition: TeamTalk.cs:1972
BearWare.ServerStatistics.nUsersPeak
int nUsersPeak
The highest numbers of users online.
Definition: TeamTalk.cs:1982
BearWare.ShareWindow
A struct which describes the properties of a window which can be shared.
Definition: TeamTalk.cs:9156
BearWare.ShareWindow.hWnd
IntPtr hWnd
The Windows handle of the window.
Definition: TeamTalk.cs:9158
BearWare.ShareWindow.szWindowTitle
string szWindowTitle
The title of the window.
Definition: TeamTalk.cs:9169
BearWare.ShareWindow.nWndX
int nWndX
X coordinate of the window relative to the Windows desktop.
Definition: TeamTalk.cs:9160
BearWare.ShareWindow.nHeight
int nHeight
The height in pixels of the window.
Definition: TeamTalk.cs:9166
BearWare.ShareWindow.nWndY
int nWndY
Y coordinate of the window relative to the Windows desktop.
Definition: TeamTalk.cs:9162
BearWare.ShareWindow.nWidth
int nWidth
The width in pixels of the window.
Definition: TeamTalk.cs:9164
BearWare.SoundDeviceConstants
IDs for sound devices.
Definition: TeamTalk.cs:337
BearWare.SoundDeviceConstants.TT_SOUNDDEVICE_ID_OPENSLES_VOICECOM
const int TT_SOUNDDEVICE_ID_OPENSLES_VOICECOM
Sound device ID for Android OpenSL ES voice communication mode. This device uses the OpenSL ES' Andro...
Definition: TeamTalk.cs:356
BearWare.SoundDeviceConstants.TT_SOUNDDEVICE_ID_OPENSLES_DEFAULT
const int TT_SOUNDDEVICE_ID_OPENSLES_DEFAULT
Sound device ID for Android OpenSL ES default audio device. Note that this sound device may also exis...
Definition: TeamTalk.cs:351
BearWare.SoundDeviceConstants.TT_SOUNDDEVICE_ID_TEAMTALK_VIRTUAL
const int TT_SOUNDDEVICE_ID_TEAMTALK_VIRTUAL
Sound device ID for virtual TeamTalk sound device.
Definition: TeamTalk.cs:365
BearWare.SoundDeviceConstants.TT_SOUNDDEVICE_ID_MASK
const uint TT_SOUNDDEVICE_ID_MASK
Extract sound device ID of nDeviceID in BearWare.SoundDevice by and'ing this value.
Definition: TeamTalk.cs:387
BearWare.SoundDeviceConstants.TT_SOUNDDEVICE_ID_VOICEPREPROCESSINGIO
const int TT_SOUNDDEVICE_ID_VOICEPREPROCESSINGIO
Sound device ID for iOS AudioUnit subtype Voice-Processing I/O Unit. This sound device ID include the...
Definition: TeamTalk.cs:346
BearWare.SoundDeviceConstants.TT_SOUNDDEVICE_ID_SHARED_FLAG
const uint TT_SOUNDDEVICE_ID_SHARED_FLAG
Flag/bit in nDeviceID telling if the BearWare.SoundDevice is a shared version of an existing sound de...
Definition: TeamTalk.cs:381
BearWare.SoundDeviceConstants.TT_SOUNDDEVICE_ID_REMOTEIO
const int TT_SOUNDDEVICE_ID_REMOTEIO
Sound device ID for iOS AudioUnit subtype Remote I/O Unit.
Definition: TeamTalk.cs:340
BearWare.SoundDeviceEffects
Set up audio effects supported by the sound device.
Definition: TeamTalk.cs:282
BearWare.SoundDeviceEffects.bEnableEchoCancellation
bool bEnableEchoCancellation
Enable echo cancellation.
Definition: TeamTalk.cs:331
BearWare.SoundDeviceEffects.bEnableAGC
bool bEnableAGC
Enable Automatic Gain Control.
Definition: TeamTalk.cs:298
BearWare.SoundDeviceEffects.bEnableDenoise
bool bEnableDenoise
Enable noise suppression.
Definition: TeamTalk.cs:315
BearWare.SoundDevice
A struct containing the properties of a sound device for either playback or recording.
Definition: TeamTalk.cs:210
BearWare.SoundDevice.nWaveDeviceID
int nWaveDeviceID
A Windows specific ID to the sound device.
Definition: TeamTalk.cs:244
BearWare.SoundDevice.szDeviceID
string szDeviceID
An identifier uniquely identifying the sound device even when new sound devices are being added and r...
Definition: TeamTalk.cs:227
BearWare.SoundDevice.bSupports3D
bool bSupports3D
Whether the sound device supports 3D-sound effects.
Definition: TeamTalk.cs:247
BearWare.SoundDevice.uSoundDeviceFeatures
SoundDeviceFeature uSoundDeviceFeatures
Additional features available for this sound device. The sound device features can be used to enable ...
Definition: TeamTalk.cs:269
BearWare.SoundDevice.inputSampleRates
int[] inputSampleRates
Supported sample rates by device for recording. A zero value terminates the list of supported sample ...
Definition: TeamTalk.cs:256
BearWare.SoundDevice.nDefaultSampleRate
int nDefaultSampleRate
The default sample rate for the sound device.
Definition: TeamTalk.cs:263
BearWare.SoundDevice.nMaxInputChannels
int nMaxInputChannels
The maximum number of input channels.
Definition: TeamTalk.cs:249
BearWare.SoundDevice.nSoundSystem
SoundSystem nSoundSystem
The sound system used by the sound device.
Definition: TeamTalk.cs:218
BearWare.SoundDevice.nDeviceID
int nDeviceID
The ID of the sound device. Used for passing to TeamTalkBase.InitSoundInputDevice() and TeamTalkBase....
Definition: TeamTalk.cs:216
BearWare.SoundDevice.szDeviceName
string szDeviceName
The name of the sound device.
Definition: TeamTalk.cs:221
BearWare.SoundDevice.outputSampleRates
int[] outputSampleRates
Supported sample rates by device for playback. A zero value terminates the list of supported sample r...
Definition: TeamTalk.cs:261
BearWare.SoundDevice.nMaxOutputChannels
int nMaxOutputChannels
The maximum number of output channels.
Definition: TeamTalk.cs:251
BearWare.SoundLevel
An enum encapsulation the minimum, maximum and default sound levels for input and output sound device...
Definition: TeamTalk.cs:394
BearWare.SoundLevel.SOUND_VU_MAX
const int SOUND_VU_MAX
The maximum value of recorded audio.
Definition: TeamTalk.cs:400
BearWare.SoundLevel.SOUND_VOLUME_MAX
const int SOUND_VOLUME_MAX
The maximum volume.
Definition: TeamTalk.cs:414
BearWare.SoundLevel.SOUND_GAIN_MIN
const int SOUND_GAIN_MIN
The minimum gain level (since it's zero it means silence).
Definition: TeamTalk.cs:456
BearWare.SoundLevel.SOUND_VOLUME_MIN
const int SOUND_VOLUME_MIN
The minimum volume.
Definition: TeamTalk.cs:428
BearWare.SoundLevel.SOUND_VU_MIN
const int SOUND_VU_MIN
The minimum value of recorded audio.
Definition: TeamTalk.cs:406
BearWare.SoundLevel.SOUND_GAIN_DEFAULT
const int SOUND_GAIN_DEFAULT
The default gain level.
Definition: TeamTalk.cs:447
BearWare.SoundLevel.SOUND_GAIN_MAX
const int SOUND_GAIN_MAX
The maximum gain level.
Definition: TeamTalk.cs:437
BearWare.SoundLevel.SOUND_VOLUME_DEFAULT
const int SOUND_VOLUME_DEFAULT
The default volume. Use this whenever possible since it requires the least amount of CPU usage.
Definition: TeamTalk.cs:422
BearWare.SpeexCodec
Speex audio codec settings for Constant Bitrate mode (CBR).
Definition: TeamTalk.cs:910
BearWare.SpeexCodec.nQuality
int nQuality
A value from 1-10. As of DLL version 4.2 also 0 is supported.
Definition: TeamTalk.cs:918
BearWare.SpeexCodec.nTxIntervalMSec
int nTxIntervalMSec
Milliseconds of audio data before each transmission.
Definition: TeamTalk.cs:929
BearWare.SpeexCodec.nBandmode
int nBandmode
Set to 0 for 8 KHz (narrow band), set to 1 for 16 KHz (wide band), set to 2 for 32 KHz (ultra-wide ba...
Definition: TeamTalk.cs:914
BearWare.SpeexCodec.bStereoPlayback
bool bStereoPlayback
Playback should be done in stereo. Doing so will disable 3d-positioning.
Definition: TeamTalk.cs:936
BearWare.SpeexConstants
Speex constants for BearWare.SpeexCodec and BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:987
BearWare.SpeexConstants.SPEEX_BANDMODE_UWIDE
const int SPEEX_BANDMODE_UWIDE
Use BearWare.SpeexCodec or BearWare.SpeexVBRCodec as 32 KHz.
Definition: TeamTalk.cs:993
BearWare.SpeexConstants.DEFAULT_SPEEX_DTX
const bool DEFAULT_SPEEX_DTX
Default Speex DTX for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1036
BearWare.SpeexConstants.SPEEX_NB_MAX_BITRATE
const int SPEEX_NB_MAX_BITRATE
The maximum bitrate for Speex codec in 8 KHz mode, i.e. quality set to 10.
Definition: TeamTalk.cs:1003
BearWare.SpeexConstants.SPEEX_QUALITY_MAX
const int SPEEX_QUALITY_MAX
The maximum quality for Speex codec.
Definition: TeamTalk.cs:997
BearWare.SpeexConstants.SPEEX_QUALITY_MIN
const int SPEEX_QUALITY_MIN
The minimum quality for Speex codec.
Definition: TeamTalk.cs:995
BearWare.SpeexConstants.SPEEX_WB_MAX_BITRATE
const int SPEEX_WB_MAX_BITRATE
The maximum bitrate for Speex codec in 16 KHz mode, i.e. quality set to 10.
Definition: TeamTalk.cs:1009
BearWare.SpeexConstants.SPEEX_WB_MIN_BITRATE
const int SPEEX_WB_MIN_BITRATE
The minimum bitrate for Speex codec in 16 KHz mode, i.e. quality set to 0.
Definition: TeamTalk.cs:1006
BearWare.SpeexConstants.DEFAULT_SPEEX_DELAY
const int DEFAULT_SPEEX_DELAY
Default Speex delay for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1024
BearWare.SpeexConstants.SPEEX_BANDMODE_NARROW
const int SPEEX_BANDMODE_NARROW
Use BearWare.SpeexCodec or BearWare.SpeexVBRCodec as 8 KHz.
Definition: TeamTalk.cs:989
BearWare.SpeexConstants.SPEEX_UWB_MIN_BITRATE
const int SPEEX_UWB_MIN_BITRATE
The minimum bitrate for Speex codec in 32 KHz mode, i.e. quality set to 0.
Definition: TeamTalk.cs:1012
BearWare.SpeexConstants.DEFAULT_SPEEX_BITRATE
const int DEFAULT_SPEEX_BITRATE
Default Speex bitrate for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1030
BearWare.SpeexConstants.SPEEX_BANDMODE_WIDE
const int SPEEX_BANDMODE_WIDE
Use BearWare.SpeexCodec or BearWare.SpeexVBRCodec as 16 KHz.
Definition: TeamTalk.cs:991
BearWare.SpeexConstants.SPEEX_UWB_MAX_BITRATE
const int SPEEX_UWB_MAX_BITRATE
The maximum bitrate for Speex codec in 32 KHz mode, i.e. quality set to 10.
Definition: TeamTalk.cs:1015
BearWare.SpeexConstants.DEFAULT_SPEEX_MAXBITRATE
const int DEFAULT_SPEEX_MAXBITRATE
Default Speex max bitrate for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1033
BearWare.SpeexConstants.DEFAULT_SPEEX_BANDMODE
const int DEFAULT_SPEEX_BANDMODE
Default Speex bandmode for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1018
BearWare.SpeexConstants.DEFAULT_SPEEX_SIMSTEREO
const bool DEFAULT_SPEEX_SIMSTEREO
Default Speex stereo playback for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1027
BearWare.SpeexConstants.DEFAULT_SPEEX_QUALITY
const int DEFAULT_SPEEX_QUALITY
Default Speex quality for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1021
BearWare.SpeexConstants.SPEEX_NB_MIN_BITRATE
const int SPEEX_NB_MIN_BITRATE
The minimum bitrate for Speex codec in 8 KHz mode, i.e. quality set to 0.
Definition: TeamTalk.cs:1000
BearWare.SpeexDSPConstants
Default values for BearWare.SpeexDSP.
Definition: TeamTalk.cs:1455
BearWare.SpeexDSPConstants.DEFAULT_DENOISE_SUPPRESS
const int DEFAULT_DENOISE_SUPPRESS
Definition: TeamTalk.cs:1462
BearWare.SpeexDSPConstants.DEFAULT_ECHO_SUPPRESS_ACTIVE
const int DEFAULT_ECHO_SUPPRESS_ACTIVE
Definition: TeamTalk.cs:1465
BearWare.SpeexDSPConstants.DEFAULT_AGC_ENABLE
const bool DEFAULT_AGC_ENABLE
Definition: TeamTalk.cs:1456
BearWare.SpeexDSPConstants.DEFAULT_ECHO_SUPPRESS
const int DEFAULT_ECHO_SUPPRESS
Definition: TeamTalk.cs:1464
BearWare.SpeexDSPConstants.DEFAULT_AGC_DEC_MAXDB
const int DEFAULT_AGC_DEC_MAXDB
Definition: TeamTalk.cs:1459
BearWare.SpeexDSPConstants.DEFAULT_ECHO_ENABLE
const bool DEFAULT_ECHO_ENABLE
Definition: TeamTalk.cs:1463
BearWare.SpeexDSPConstants.DEFAULT_DENOISE_ENABLE
const bool DEFAULT_DENOISE_ENABLE
Definition: TeamTalk.cs:1461
BearWare.SpeexDSPConstants.DEFAULT_AGC_INC_MAXDB
const int DEFAULT_AGC_INC_MAXDB
Definition: TeamTalk.cs:1458
BearWare.SpeexDSPConstants.DEFAULT_AGC_GAINMAXDB
const int DEFAULT_AGC_GAINMAXDB
Definition: TeamTalk.cs:1460
BearWare.SpeexDSPConstants.DEFAULT_AGC_GAINLEVEL
const int DEFAULT_AGC_GAINLEVEL
Definition: TeamTalk.cs:1457
BearWare.SpeexDSP
Audio configuration specifying how recorded audio from sound input device should be preprocessed befo...
Definition: TeamTalk.cs:1142
BearWare.SpeexDSP.SpeexDSP
SpeexDSP(bool set_defaults)
Definition: TeamTalk.cs:1212
BearWare.SpeexDSP.nMaxDecDBSec
int nMaxDecDBSec
Used so volume should not be attenuated too quickly (maximal gain decrease in dB/second)....
Definition: TeamTalk.cs:1166
BearWare.SpeexDSP.bEnableDenoise
bool bEnableDenoise
Whether clients who join the channel should automatically enable denoising.
Definition: TeamTalk.cs:1175
BearWare.SpeexDSP.bEnableAGC
bool bEnableAGC
Whether clients who join a BearWare.Channel should enable AGC with the settings specified nGainLevel,...
Definition: TeamTalk.cs:1151
BearWare.SpeexDSP.nMaxIncDBSec
int nMaxIncDBSec
Used so volume should not be amplified too quickly (maximal gain increase in dB/second)....
Definition: TeamTalk.cs:1160
BearWare.SpeexDSP.nGainLevel
int nGainLevel
A value from 0 to 32768. Default is 8000. Value is ignored if bEnableAGC is FALSE.
Definition: TeamTalk.cs:1155
BearWare.SpeexDSP.nEchoSuppressActive
int nEchoSuppressActive
Set maximum attenuation of the residual echo in dB when near end is active (negative number)....
Definition: TeamTalk.cs:1210
BearWare.SpeexDSP.nEchoSuppress
int nEchoSuppress
Set maximum attenuation of the residual echo in dB (negative number). Default is -40....
Definition: TeamTalk.cs:1205
BearWare.SpeexDSP.nMaxGainDB
int nMaxGainDB
Ensure volume doesn't become too loud (maximal gain in dB). Default is 30. Value is ignored if bEnabl...
Definition: TeamTalk.cs:1171
BearWare.SpeexDSP.bEnableEchoCancellation
bool bEnableEchoCancellation
Speex DSP is used for specifying how recorded audio from a sound input device should be preprocessed ...
Definition: TeamTalk.cs:1200
BearWare.SpeexDSP.nMaxNoiseSuppressDB
int nMaxNoiseSuppressDB
Maximum attenuation of the noise in dB. Negative value! Default value is -30. Value is ignored if bEn...
Definition: TeamTalk.cs:1180
BearWare.SpeexVBRCodec
Speex audio codec settings for Variable Bitrate mode (VBR).
Definition: TeamTalk.cs:946
BearWare.SpeexVBRCodec.nTxIntervalMSec
int nTxIntervalMSec
Milliseconds of audio data before each transmission.
Definition: TeamTalk.cs:976
BearWare.SpeexVBRCodec.nMaxBitRate
int nMaxBitRate
The maximum bitrate at which the audio codec is allowed to output audio. Set to zero if it should be ...
Definition: TeamTalk.cs:963
BearWare.SpeexVBRCodec.bDTX
bool bDTX
Enable/disable discontinuous transmission. When enabled Speex will ignore silence,...
Definition: TeamTalk.cs:967
BearWare.SpeexVBRCodec.nQuality
int nQuality
A value from 0-10. If nBitRate is non-zero it will override this value.
Definition: TeamTalk.cs:952
BearWare.SpeexVBRCodec.nBandmode
int nBandmode
Set to 0 for 8 KHz (narrow band), set to 1 for 16 KHz (wide band), set to 2 for 32 KHz (ultra-wide ba...
Definition: TeamTalk.cs:949
BearWare.SpeexVBRCodec.nBitRate
int nBitRate
The bitrate at which the audio codec should output encoded audio data. Dividing it by 8 gives roughly...
Definition: TeamTalk.cs:959
BearWare.SpeexVBRCodec.bStereoPlayback
bool bStereoPlayback
Playback should be done in stereo. Doing so will disable 3d-positioning.
Definition: TeamTalk.cs:982
BearWare.TTAudioPreprocessor
Use TeamTalk's internal audio preprocessor for gain audio. Same as used for TeamTalkBase....
Definition: TeamTalk.cs:1251
BearWare.TTAudioPreprocessor.bMuteLeftSpeaker
bool bMuteLeftSpeaker
Whether to mute left speaker in stereo playback.
Definition: TeamTalk.cs:1257
BearWare.TTAudioPreprocessor.bMuteRightSpeaker
bool bMuteRightSpeaker
Whether to mute right speaker in stereo playback.
Definition: TeamTalk.cs:1259
BearWare.TTAudioPreprocessor.nGainLevel
int nGainLevel
Gain level between BearWare.SoundLevel.SOUND_GAIN_MIN and BearWare.SoundLevel.SOUND_GAIN_MAX....
Definition: TeamTalk.cs:1255
BearWare.TTMessage
A struct containing the properties of an event.
Definition: TeamTalk.cs:3964
BearWare.TTMessage.uReserved
uint uReserved
Reserved. To preserve alignment.
Definition: TeamTalk.cs:3972
BearWare.TTMessage.nSource
int nSource
The source of the event depends on wmMsg.
Definition: TeamTalk.cs:3968
BearWare.TTMessage.nClientEvent
ClientEvent nClientEvent
The event's message number.
Definition: TeamTalk.cs:3966
BearWare.TTMessage.ttType
TTType ttType
Specifies which member to access in the union.
Definition: TeamTalk.cs:3970
BearWare.TTMessage.DataToObject
object DataToObject()
Definition: TeamTalk.cs:3977
BearWare.TTMessage.data
byte[] data
Definition: TeamTalk.cs:3974
BearWare.TextMessage
A struct containing the properties of a text message sent by a user.
Definition: TeamTalk.cs:2485
BearWare.TextMessage.bMore
bool bMore
Whether this text message is to be merged with next text message.
Definition: TeamTalk.cs:2504
BearWare.TextMessage.nChannelID
int nChannelID
Set to zero if nMsgType is BearWare.TextMsgType BearWare.TextMsgType.MSGTYPE_USER or BearWare....
Definition: TeamTalk.cs:2497
BearWare.TextMessage.nToUserID
int nToUserID
Set to zero if channel message.
Definition: TeamTalk.cs:2494
BearWare.TextMessage.szMessage
string szMessage
The actual text message. The message can be multi-line (include EOL)
Definition: TeamTalk.cs:2501
BearWare.TextMessage.nFromUserID
int nFromUserID
Will be set automatically on outgoing message.
Definition: TeamTalk.cs:2489
BearWare.TextMessage.szFromUsername
string szFromUsername
The originators username.
Definition: TeamTalk.cs:2492
BearWare.TextMessage.nMsgType
TextMsgType nMsgType
The type of text message.
Definition: TeamTalk.cs:2487
BearWare.UnionData
Definition: TeamTalk.cs:4021
BearWare.UnionData.filetransfer
FileTransfer filetransfer
Definition: TeamTalk.cs:4029
BearWare.UnionData.user
User user
Definition: TeamTalk.cs:4039
BearWare.UnionData.clienterrormsg
ClientErrorMsg clienterrormsg
Definition: TeamTalk.cs:4023
BearWare.UnionData.desktopinput
DesktopInput desktopinput
Definition: TeamTalk.cs:4027
BearWare.UnionData.textmessage
TextMessage textmessage
Definition: TeamTalk.cs:4037
BearWare.UnionData.bActive
bool bActive
Definition: TeamTalk.cs:4043
BearWare.UnionData.nBytesRemain
int nBytesRemain
Definition: TeamTalk.cs:4045
BearWare.UnionData.serverproperties
ServerProperties serverproperties
Definition: TeamTalk.cs:4035
BearWare.UnionData.nPayloadSize
int nPayloadSize
Definition: TeamTalk.cs:4049
BearWare.UnionData.channel
Channel channel
Definition: TeamTalk.cs:4025
BearWare.UnionData.nStreamID
int nStreamID
Definition: TeamTalk.cs:4047
BearWare.UnionData.useraccount
UserAccount useraccount
Definition: TeamTalk.cs:4041
BearWare.UnionData.mediafileinfo
MediaFileInfo mediafileinfo
Definition: TeamTalk.cs:4031
BearWare.UnionData.remotefile
RemoteFile remotefile
Definition: TeamTalk.cs:4033
BearWare.UserAccount
A struct containing the properties of a user account.
Definition: TeamTalk.cs:2092
BearWare.UserAccount.szNote
string szNote
Additional notes about this user.
Definition: TeamTalk.cs:2111
BearWare.UserAccount.nUserData
int nUserData
A user data field which can be used for additional information. The nUserData field of the BearWare....
Definition: TeamTalk.cs:2108
BearWare.UserAccount.szInitChannel
string szInitChannel
User should (manually) join this channel after login. If an initial channel is specified in the user'...
Definition: TeamTalk.cs:2117
BearWare.UserAccount.uUserType
UserType uUserType
A bitmask of the type of user based on BearWare.UserType.
Definition: TeamTalk.cs:2100
BearWare.UserAccount.szPassword
string szPassword
The account's password.
Definition: TeamTalk.cs:2098
BearWare.UserAccount.uUserRights
UserRight uUserRights
A bitmask based on BearWare.UserRight which specifies the rights the user have who logs onto the serv...
Definition: TeamTalk.cs:2104
BearWare.UserAccount.szLastModified
string szLastModified
Timestamp of last modification of user account. Date/time is converted local time.
Definition: TeamTalk.cs:2135
BearWare.UserAccount.autoOperatorChannels
int[] autoOperatorChannels
Channels where this user will automatically become channel operator when joining. The channels must b...
Definition: TeamTalk.cs:2122
BearWare.UserAccount.abusePrevent
AbusePrevention abusePrevent
Properties which can be set to prevent abuse of a server, e.g. limit number of commands issued.
Definition: TeamTalk.cs:2131
BearWare.UserAccount.szLastLoginTime
string szLastLoginTime
Timestamp of user account's last successful login. Read-only property. Date/time is converted local t...
Definition: TeamTalk.cs:2139
BearWare.UserAccount.szUsername
string szUsername
The account's username.
Definition: TeamTalk.cs:2095
BearWare.UserAccount.nAudioCodecBpsLimit
int nAudioCodecBpsLimit
Bandwidth restriction for audio codecs created by this user. This value will hold the highest bitrate...
Definition: TeamTalk.cs:2126
BearWare.User
A struct containing the properties of a user.
Definition: TeamTalk.cs:2277
BearWare.User.nVolumeVoice
int nVolumeVoice
The user's voice volume level. Note that it's a virtual volume which is being set since the master vo...
Definition: TeamTalk.cs:2353
BearWare.User.nStoppedDelayMediaFile
int nStoppedDelayMediaFile
The delay of when a user should no longer be considered playing audio of a media file.
Definition: TeamTalk.cs:2367
BearWare.User.nChannelID
int nChannelID
The channel which the user is currently participating in. 0 if none. This value can change as a resul...
Definition: TeamTalk.cs:2311
BearWare.User.szStatusMsg
string szStatusMsg
The user's current status message. Invoke TeamTalkBase.DoChangeStatus() to change this value....
Definition: TeamTalk.cs:2340
BearWare.User.nActiveAdaptiveDelayMSec
int nActiveAdaptiveDelayMSec
The currently active adaptive jitter delay for received voice streams for this user.
Definition: TeamTalk.cs:2403
BearWare.User.szUsername
string szUsername
The szUsername of the user's BearWare.UserAccount. A user account is created by calling TeamTalkBase....
Definition: TeamTalk.cs:2287
BearWare.User.nStoppedDelayVoice
int nStoppedDelayVoice
The delay of when a user should no longer be considered as talking.
Definition: TeamTalk.cs:2363
BearWare.User.nVolumeMediaFile
int nVolumeMediaFile
The user's voice volume level. Note that it's a virtual volume which is being set since the master vo...
Definition: TeamTalk.cs:2359
BearWare.User.stereoPlaybackMediaFile
bool[] stereoPlaybackMediaFile
Check what speaker a user is outputting to. If index 0 is TRUE then left speaker is playing....
Definition: TeamTalk.cs:2391
BearWare.User.uPeerSubscriptions
Subscription uPeerSubscriptions
A bitmask of what this user subscribes to from local client instance. Invoking TeamTalkBase....
Definition: TeamTalk.cs:2323
BearWare.User.szIPAddress
string szIPAddress
The user's IP-address. This value is set by the server.
Definition: TeamTalk.cs:2299
BearWare.User.nUserID
int nUserID
The user's ID. A value from 1 - BearWare.TeamTalkBase.TT_USERID_MAX. This property is set by the serv...
Definition: TeamTalk.cs:2281
BearWare.User.szMediaStorageDir
string szMediaStorageDir
Store audio received from this user to this folder.
Definition: TeamTalk.cs:2347
BearWare.User.uVersion
uint uVersion
The user's client version. This property is set by the server and will not change after login....
Definition: TeamTalk.cs:2305
BearWare.User.szClientName
string szClientName
The name of the client application which the user is using. This is the value passed as szClientName ...
Definition: TeamTalk.cs:2408
BearWare.User.nBufferMSecVoice
int nBufferMSecVoice
The size of the buffer (in msec) to hold voice content.
Definition: TeamTalk.cs:2395
BearWare.User.soundPositionVoice
float[] soundPositionVoice
User's position when using 3D-sound (DirectSound option). Index 0 is x-axis, index 1 is y-axis and in...
Definition: TeamTalk.cs:2373
BearWare.User.uUserState
UserState uUserState
A bitmask of the user's current state, e.g. talking, muted, etc.
Definition: TeamTalk.cs:2343
BearWare.User.uUserType
UserType uUserType
The uUserType of the user's BearWare.UserAccount. This property is set by the server and will not cha...
Definition: TeamTalk.cs:2296
BearWare.User.nStatusMode
int nStatusMode
The user's current status mode. Invoke TeamTalkBase.DoChangeStatus() to change this value....
Definition: TeamTalk.cs:2334
BearWare.User.szNickname
string szNickname
The user's nickname. Invoking TeamTalkBase.DoChangeNickname() changes this value. Event BearWare....
Definition: TeamTalk.cs:2329
BearWare.User.soundPositionMediaFile
float[] soundPositionMediaFile
User's position when using 3D-sound (DirectSound option). Index 0 is x-axis, index 1 is y-axis and in...
Definition: TeamTalk.cs:2379
BearWare.User.stereoPlaybackVoice
bool[] stereoPlaybackVoice
Check what speaker a user is outputting to. If index 0 is TRUE then left speaker is playing....
Definition: TeamTalk.cs:2385
BearWare.User.nUserData
int nUserData
The nUserData of the user's BearWare.UserAccount. This field can be use to denote e....
Definition: TeamTalk.cs:2292
BearWare.User.uLocalSubscriptions
Subscription uLocalSubscriptions
A bitmask of what the local user subscribes to from this user. Invoking TeamTalkBase....
Definition: TeamTalk.cs:2317
BearWare.User.nBufferMSecMediaFile
int nBufferMSecMediaFile
The size of the buffer (in msec) to hold media file content.
Definition: TeamTalk.cs:2399
BearWare.UserStatistics
Packet reception and data statistics for a user.
Definition: TeamTalk.cs:2417
BearWare.UserStatistics.nMediaFileVideoPacketsRecv
long nMediaFileVideoPacketsRecv
Number of media file video packets received from user. A video frame can consist of several video pac...
Definition: TeamTalk.cs:2439
BearWare.UserStatistics.nVoicePacketsLost
long nVoicePacketsLost
Number of voice packets lost from user.
Definition: TeamTalk.cs:2421
BearWare.UserStatistics.nMediaFileAudioPacketsLost
long nMediaFileAudioPacketsLost
Number of media file audio packets lost from user.
Definition: TeamTalk.cs:2436
BearWare.UserStatistics.nVideoCaptureFramesLost
long nVideoCaptureFramesLost
Video frames which couldn't be shown because packets were lost.
Definition: TeamTalk.cs:2429
BearWare.UserStatistics.nMediaFileVideoFramesLost
long nMediaFileVideoFramesLost
Media file video frames which couldn't be shown because packets were lost.
Definition: TeamTalk.cs:2444
BearWare.UserStatistics.nMediaFileVideoFramesDropped
long nMediaFileVideoFramesDropped
Number of media file video frames dropped because user application didn't retrieve video frames in ti...
Definition: TeamTalk.cs:2447
BearWare.UserStatistics.nVideoCaptureFramesDropped
long nVideoCaptureFramesDropped
Number of video frames dropped because user application didn't retrieve video frames in time.
Definition: TeamTalk.cs:2432
BearWare.UserStatistics.nVideoCaptureFramesRecv
long nVideoCaptureFramesRecv
Number of video frames received from user.
Definition: TeamTalk.cs:2426
BearWare.UserStatistics.nMediaFileVideoFramesRecv
long nMediaFileVideoFramesRecv
Number of media file video frames received from user.
Definition: TeamTalk.cs:2441
BearWare.UserStatistics.nVoicePacketsRecv
long nVoicePacketsRecv
Number of voice packets received from user.
Definition: TeamTalk.cs:2419
BearWare.UserStatistics.nMediaFileAudioPacketsRecv
long nMediaFileAudioPacketsRecv
Number of media file audio packets received from user.
Definition: TeamTalk.cs:2434
BearWare.UserStatistics.nVideoCapturePacketsRecv
long nVideoCapturePacketsRecv
Number of video packets received from user. A video frame can consist of several video packets.
Definition: TeamTalk.cs:2424
BearWare.VideoCaptureDevice
A struct containing the properties of a video capture device.
Definition: TeamTalk.cs:688
BearWare.VideoCaptureDevice.szCaptureAPI
string szCaptureAPI
The name of the API used to capture video.
Definition: TeamTalk.cs:708
BearWare.VideoCaptureDevice.nVideoFormatsCount
int nVideoFormatsCount
The number of capture formats available in captureFormats array.
Definition: TeamTalk.cs:714
BearWare.VideoCaptureDevice.videoFormats
VideoFormat[] videoFormats
The supported capture formats.
Definition: TeamTalk.cs:711
BearWare.VideoCaptureDevice.szDeviceID
string szDeviceID
A string identifying the device.
Definition: TeamTalk.cs:691
BearWare.VideoCaptureDevice.szDeviceName
string szDeviceName
The name of the capture device.
Definition: TeamTalk.cs:694
BearWare.VideoCodec
Struct used for specifying the video codec to use.
Definition: TeamTalk.cs:1600
BearWare.VideoCodec.nCodec
Codec nCodec
Specifies member holds the codec settings. So far there is only one video codec to choose from,...
Definition: TeamTalk.cs:1605
BearWare.VideoCodec.webm_vp8
WebMVP8Codec webm_vp8
Definition: TeamTalk.cs:1607
BearWare.VideoFormat
A struct containing the properties of a video capture format.
Definition: TeamTalk.cs:624
BearWare.VideoFormat.nFPS_Denominator
int nFPS_Denominator
The denominator of the video capture device's video format. Divinding nFPS_Numerator with nFPS_Denomi...
Definition: TeamTalk.cs:638
BearWare.VideoFormat.picFourCC
FourCC picFourCC
Picture format for capturing.
Definition: TeamTalk.cs:640
BearWare.VideoFormat.nHeight
int nHeight
The height in pixels of the video device supported video format.
Definition: TeamTalk.cs:630
BearWare.VideoFormat.nFPS_Numerator
int nFPS_Numerator
The numerator of the video capture device's video format. Divinding nFPS_Numerator with nFPS_Denomina...
Definition: TeamTalk.cs:634
BearWare.VideoFormat.nWidth
int nWidth
The width in pixels of the video device supported video format.
Definition: TeamTalk.cs:627
BearWare.VideoFrame
A RGB32 image where the pixels can be accessed directly in an allocated imageBuffer.
Definition: TeamTalk.cs:652
BearWare.VideoFrame.bKeyFrame
bool bKeyFrame
Whether the image acquired is a key-frame. If it is not a key-frame and there has been packet loss or...
Definition: TeamTalk.cs:669
BearWare.VideoFrame.nFrameBufferSize
int nFrameBufferSize
The size in bytes of the buffer allocate in frameBuffer.
Definition: TeamTalk.cs:674
BearWare.VideoFrame.nHeight
int nHeight
The height in pixels of the image contained in imageBuffer.
Definition: TeamTalk.cs:658
BearWare.VideoFrame.nStreamID
int nStreamID
A unique identifier for the frames which are part of the same video sequence. If the stream ID change...
Definition: TeamTalk.cs:664
BearWare.VideoFrame.frameBuffer
System.IntPtr frameBuffer
A buffer allocated internally by TeamTalkBase.
Definition: TeamTalk.cs:671
BearWare.VideoFrame.nWidth
int nWidth
The width in pixels of the image contained in frameBuffer.
Definition: TeamTalk.cs:655
BearWare.WebMVP8CodecConstants
Definition: TeamTalk.cs:1497
BearWare.WebMVP8CodecConstants.WEBM_VPX_DL_BEST_QUALITY
const int WEBM_VPX_DL_BEST_QUALITY
nEncodeDeadline value for best encoding.
Definition: TeamTalk.cs:1506
BearWare.WebMVP8CodecConstants.WEBM_VPX_DL_REALTIME
const int WEBM_VPX_DL_REALTIME
nEncodeDeadline value for fastest encoding.
Definition: TeamTalk.cs:1500
BearWare.WebMVP8CodecConstants.WEBM_VPX_DL_GOOD_QUALITY
const int WEBM_VPX_DL_GOOD_QUALITY
nEncodeDeadline value for good encoding.
Definition: TeamTalk.cs:1503
BearWare.WebMVP8Codec
WebM video codec settings.
Definition: TeamTalk.cs:1474
BearWare.WebMVP8Codec.nRcTargetBitrate
int nRcTargetBitrate
Same as rc_target_bitrate.
Definition: TeamTalk.cs:1477
BearWare.WebMVP8Codec.nEncodeDeadline
uint nEncodeDeadline
Time that should be spent on encoding a frame.
Definition: TeamTalk.cs:1493
BearWare.WebMVP8Codec.rc_target_bitrate
int rc_target_bitrate
Target bitrate in kbits/sec. This value must be greater than 0.
Definition: TeamTalk.cs:1484
BearWare.WebRTCAudioPreprocessor.EchoCanceller
Configuration of WebRTC's echo canceller. See also TT_SetSoundDeviceEffects()
Definition: TeamTalk.cs:1290
BearWare.WebRTCAudioPreprocessor.EchoCanceller.bEnable
bool bEnable
Enable WebRTC echo canceller. The WebRTC echo canceller requires sound input and output devices are i...
Definition: TeamTalk.cs:1296
BearWare.WebRTCAudioPreprocessor.GainController2.AdaptiveDigital
Configuration for fine tuning gain level.
Definition: TeamTalk.cs:1335
BearWare.WebRTCAudioPreprocessor.GainController2.AdaptiveDigital.fMaxOutputNoiseLevelDBFS
float fMaxOutputNoiseLevelDBFS
Definition: TeamTalk.cs:1348
BearWare.WebRTCAudioPreprocessor.GainController2.AdaptiveDigital.fInitialGainDB
float fInitialGainDB
Range: 0 <= x < infinite. Default: 15 dB.
Definition: TeamTalk.cs:1344
BearWare.WebRTCAudioPreprocessor.GainController2.AdaptiveDigital.fHeadRoomDB
float fHeadRoomDB
Range: 0 <= x < infinite. Default: 5 dB.
Definition: TeamTalk.cs:1340
BearWare.WebRTCAudioPreprocessor.GainController2.AdaptiveDigital.bEnable
bool bEnable
Definition: TeamTalk.cs:1338
BearWare.WebRTCAudioPreprocessor.GainController2.AdaptiveDigital.fMaxGainChangeDBPerSecond
float fMaxGainChangeDBPerSecond
Definition: TeamTalk.cs:1346
BearWare.WebRTCAudioPreprocessor.GainController2.AdaptiveDigital.fMaxGainDB
float fMaxGainDB
Range: 0 < x < infinite. Default: 50 dB.
Definition: TeamTalk.cs:1342
BearWare.WebRTCAudioPreprocessor.GainController2.FixedDigital
Gain level for AGC. Only active when bEnable is true.
Definition: TeamTalk.cs:1325
BearWare.WebRTCAudioPreprocessor.GainController2.FixedDigital.fGainDB
float fGainDB
Gain level in dB. Range: 0 <= x < 50. Default: 0.
Definition: TeamTalk.cs:1328
BearWare.WebRTCAudioPreprocessor.GainController2
Configuration of WebRTC's gain controller 2 for AGC.
Definition: TeamTalk.cs:1317
BearWare.WebRTCAudioPreprocessor.GainController2.adaptivedigital
AdaptiveDigital adaptivedigital
Definition: TeamTalk.cs:1350
BearWare.WebRTCAudioPreprocessor.GainController2.fixeddigital
FixedDigital fixeddigital
Definition: TeamTalk.cs:1330
BearWare.WebRTCAudioPreprocessor.GainController2.bEnable
bool bEnable
Enable WebRTC's fixed digital gain. WebRTC's automatic gain control (AGC)
Definition: TeamTalk.cs:1320
BearWare.WebRTCAudioPreprocessor.NoiseSuppression
Configuration of WebRTC's noise suppression. See also BearWare.SpeexDSP.
Definition: TeamTalk.cs:1304
BearWare.WebRTCAudioPreprocessor.NoiseSuppression.nLevel
int nLevel
Noise suppression level. 0 = Low, 1 = Moderate, 2 = High, 3 = VeryHigh. Default: 1.
Definition: TeamTalk.cs:1309
BearWare.WebRTCAudioPreprocessor.NoiseSuppression.bEnable
bool bEnable
Enable WebRTC noise suppression.
Definition: TeamTalk.cs:1306
BearWare.WebRTCAudioPreprocessor.Preamplifier
Configuration of WebRTC pre-amplifier.
Definition: TeamTalk.cs:1277
BearWare.WebRTCAudioPreprocessor.Preamplifier.bEnable
bool bEnable
Enable pre-amplifier. Replacement for TT_SetSoundInputGainLevel()
Definition: TeamTalk.cs:1280
BearWare.WebRTCAudioPreprocessor.Preamplifier.fFixedGainFactor
float fFixedGainFactor
Gain factor. Default: 1.
Definition: TeamTalk.cs:1282
BearWare.WebRTCAudioPreprocessor
WebRTC's audio preprocessor.
Definition: TeamTalk.cs:1273
BearWare.WebRTCAudioPreprocessor.gaincontroller2
GainController2 gaincontroller2
Definition: TeamTalk.cs:1352
BearWare.WebRTCAudioPreprocessor.echocanceller
EchoCanceller echocanceller
Definition: TeamTalk.cs:1298
BearWare.WebRTCAudioPreprocessor.preamplifier
Preamplifier preamplifier
Definition: TeamTalk.cs:1284
BearWare.WebRTCAudioPreprocessor.WebRTCAudioPreprocessor
WebRTCAudioPreprocessor(bool set_defaults)
Definition: TeamTalk.cs:1354
BearWare.WebRTCAudioPreprocessor.noisesuppression
NoiseSuppression noisesuppression
Definition: TeamTalk.cs:1311
BearWare.WebRTCConstants
Default values for BearWare.WebRTCAudioPreprocessor.
Definition: TeamTalk.cs:1401
BearWare.WebRTCConstants.DEFAULT_WEBRTC_MAXGAIN_DBSEC
const float DEFAULT_WEBRTC_MAXGAIN_DBSEC
Definition: TeamTalk.cs:1410
BearWare.WebRTCConstants.DEFAULT_WEBRTC_PREAMPLIFIER_GAINFACTOR
const float DEFAULT_WEBRTC_PREAMPLIFIER_GAINFACTOR
Definition: TeamTalk.cs:1403
BearWare.WebRTCConstants.DEFAULT_WEBRTC_NOISESUPPRESS_ENABLE
const bool DEFAULT_WEBRTC_NOISESUPPRESS_ENABLE
Definition: TeamTalk.cs:1412
BearWare.WebRTCConstants.DEFAULT_WEBRTC_MAXGAIN_DB
const float DEFAULT_WEBRTC_MAXGAIN_DB
Definition: TeamTalk.cs:1408
BearWare.WebRTCConstants.DEFAULT_WEBRTC_PREAMPLIFIER_ENABLE
const bool DEFAULT_WEBRTC_PREAMPLIFIER_ENABLE
Definition: TeamTalk.cs:1402
BearWare.WebRTCConstants.DEFAULT_WEBRTC_SAT_PROT_ENABLE
const bool DEFAULT_WEBRTC_SAT_PROT_ENABLE
Definition: TeamTalk.cs:1406
BearWare.WebRTCConstants.DEFAULT_WEBRTC_GAINCTL_ENABLE
const bool DEFAULT_WEBRTC_GAINCTL_ENABLE
Definition: TeamTalk.cs:1404
BearWare.WebRTCConstants.WEBRTC_GAINCONTROLLER2_FIXEDGAIN_MAX
const float WEBRTC_GAINCONTROLLER2_FIXEDGAIN_MAX
Definition: TeamTalk.cs:1415
BearWare.WebRTCConstants.DEFAULT_WEBRTC_GAINDB
const float DEFAULT_WEBRTC_GAINDB
Definition: TeamTalk.cs:1405
BearWare.WebRTCConstants.DEFAULT_WEBRTC_INITIAL_GAIN_DB
const float DEFAULT_WEBRTC_INITIAL_GAIN_DB
Definition: TeamTalk.cs:1409
BearWare.WebRTCConstants.DEFAULT_WEBRTC_ECHO_CANCEL_ENABLE
const bool DEFAULT_WEBRTC_ECHO_CANCEL_ENABLE
Definition: TeamTalk.cs:1414
BearWare.WebRTCConstants.DEFAULT_WEBRTC_MAX_OUT_NOISE
const float DEFAULT_WEBRTC_MAX_OUT_NOISE
Definition: TeamTalk.cs:1411
BearWare.WebRTCConstants.DEFAULT_WEBRTC_HEADROOM_DB
const float DEFAULT_WEBRTC_HEADROOM_DB
Definition: TeamTalk.cs:1407
BearWare.WebRTCConstants.DEFAULT_WEBRTC_NOISESUPPRESS_LEVEL
const int DEFAULT_WEBRTC_NOISESUPPRESS_LEVEL
Definition: TeamTalk.cs:1413