TeamTalk 5 Java DLL Version 5.8B
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
24using System;
25using System.Collections.Generic;
26using System.Text;
27using System.Windows.Forms;
28using System.Drawing;
29using System.Drawing.Imaging;
30using System.Threading;
31using System.Diagnostics;
32using System.Reflection;
33using System.Runtime.InteropServices;
34using c_tt;
35
36namespace 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,
78 STREAMTYPE_CHANNELMSG = 0x00000040,
85
93 }
106 public enum SoundSystem : uint
107 {
155 }
156
161 [Flags]
162 public enum SoundDeviceFeature : uint
163 {
170 SOUNDDEVICEFEATURE_AEC = 0x0001,
176 SOUNDDEVICEFEATURE_AGC = 0x0002,
191 }
192
205 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
206 public struct SoundDevice
207 {
213 public int nDeviceID;
217 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
218 public string szDeviceName;
223 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
224 public string szDeviceID;
241 public int nWaveDeviceID;
244 public bool bSupports3D;
252 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_SAMPLERATES_MAX)]
253 public int[] inputSampleRates;
257 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_SAMPLERATES_MAX)]
258 public int[] outputSampleRates;
267 }
268
269
278 public struct SoundDeviceEffects
279 {
295 public bool bEnableAGC;
312 public bool bEnableDenoise;
329 }
330
334 {
337 public const int TT_SOUNDDEVICE_ID_REMOTEIO = 0;
362 public const int TT_SOUNDDEVICE_ID_TEAMTALK_VIRTUAL = 1978;
363
364
378 public const uint TT_SOUNDDEVICE_ID_SHARED_FLAG = 0x00000800;
379
384 public const uint TT_SOUNDDEVICE_ID_MASK = 0x000007FF;
385 }
386
390 public struct SoundLevel
391 {
397 public const int SOUND_VU_MAX = 100;
403 public const int SOUND_VU_MIN = 0;
411 public const int SOUND_VOLUME_MAX = 32000;
419 public const int SOUND_VOLUME_DEFAULT = 1000;
425 public const int SOUND_VOLUME_MIN = 0;
434 public const int SOUND_GAIN_MAX = 32000;
444 public const int SOUND_GAIN_DEFAULT = 1000;
453 public const int SOUND_GAIN_MIN = 0;
454 }
455
470 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
471 public struct AudioBlock
472 {
476 public int nStreamID;
478 public int nSampleRate;
480 public int nChannels;
484 public System.IntPtr lpRawAudio;
486 public int nSamples;
494 public uint uSampleIndex;
508 }
509
518 public enum MediaFileStatus : uint
519 {
520 MFS_CLOSED = 0,
522 MFS_ERROR = 1,
524 MFS_STARTED = 2,
526 MFS_FINISHED = 3,
528 MFS_ABORTED = 4,
530 MFS_PAUSED = 5,
533 MFS_PLAYING = 6
534 }
535
539 public enum AudioFileFormat : uint
540 {
542 AFF_NONE = 0,
555 AFF_WAVE_FORMAT = 2,
566 }
567
577 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
578 public struct AudioFormat
579 {
583 public int nSampleRate;
585 public int nChannels;
586 }
587
598 public enum FourCC : uint
599 {
601 FOURCC_NONE = 0,
604 FOURCC_I420 = 100,
607 FOURCC_YUY2 = 101,
610 FOURCC_RGB32 = 102
611 }
612
619 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
620 public struct VideoFormat
621 {
624 public int nWidth;
627 public int nHeight;
631 public int nFPS_Numerator;
638 }
639
647 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
648 public struct VideoFrame
649 {
652 public int nWidth;
655 public int nHeight;
661 public int nStreamID;
666 public bool bKeyFrame;
668 public System.IntPtr frameBuffer;
672 }
673
683 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
684 public struct VideoCaptureDevice
685 {
687 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
688 public string szDeviceID;
690 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
691 public string szDeviceName;
704 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
705 public string szCaptureAPI;
707 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_VIDEOFORMATS_MAX)]
712 }
713
721 public enum BitmapFormat : uint
722 {
724 BMP_NONE = 0,
733 BMP_RGB16_555 = 2,
737 BMP_RGB24 = 3,
741 BMP_RGB32 = 4
742 }
743
748 public enum DesktopProtocol : uint
749 {
753 }
754
761 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
762 public struct DesktopWindow
763 {
765 public int nWidth;
767 public int nHeight;
772 public int nBytesPerLine;
779 public int nSessionID;
783 public IntPtr frameBuffer;
787 }
788
792 public enum DesktopKeyState : uint
793 {
795 DESKTOPKEYSTATE_NONE = 0x00000000,
797 DESKTOPKEYSTATE_DOWN = 0x00000001,
799 DESKTOPKEYSTATE_UP = 0x00000002,
800 }
801
809 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
810 public struct DesktopInput
811 {
815 public ushort uMousePosX;
819 public ushort uMousePosY;
825 public uint uKeyCode;
830 public DesktopInput(bool set_defaults)
831 {
832 if (set_defaults)
833 {
836 uKeyState = DesktopKeyState.DESKTOPKEYSTATE_NONE;
837 }
838 else
839 {
841 uKeyCode = 0;
842 uKeyState = DesktopKeyState.DESKTOPKEYSTATE_NONE;
843 }
844 }
845 }
846
849 {
857 public const uint DESKTOPINPUT_KEYCODE_IGNORE = 0xFFFFFFFF;
858
866 public const ushort DESKTOPINPUT_MOUSEPOS_IGNORE = 0xFFFF;
867
874 public const uint DESKTOPINPUT_KEYCODE_LMOUSEBTN = 0x1000;
875
882 public const uint DESKTOPINPUT_KEYCODE_RMOUSEBTN = 0x1001;
883
890 public const uint DESKTOPINPUT_KEYCODE_MMOUSEBTN = 0x1002;
891 }
892
905 [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
906 public struct SpeexCodec
907 {
910 [FieldOffset(0)]
911 public int nBandmode;
914 [FieldOffset(4)]
915 public int nQuality;
925 [FieldOffset(8)]
926 public int nTxIntervalMSec;
932 [FieldOffset(12)]
933 public bool bStereoPlayback;
934 }
935
941 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
942 public struct SpeexVBRCodec
943 {
946 public int nBandmode;
949 public int nQuality;
956 public int nBitRate;
960 public int nMaxBitRate;
964 public bool bDTX;
973 public int nTxIntervalMSec;
979 public bool bStereoPlayback;
980 }
981
983 public struct SpeexConstants
984 {
986 public const int SPEEX_BANDMODE_NARROW = 0;
988 public const int SPEEX_BANDMODE_WIDE = 1;
990 public const int SPEEX_BANDMODE_UWIDE = 2;
992 public const int SPEEX_QUALITY_MIN = 0;
994 public const int SPEEX_QUALITY_MAX = 10;
997 public const int SPEEX_NB_MIN_BITRATE = 2150;
1000 public const int SPEEX_NB_MAX_BITRATE = 24600;
1003 public const int SPEEX_WB_MIN_BITRATE = 3950;
1006 public const int SPEEX_WB_MAX_BITRATE = 42200;
1009 public const int SPEEX_UWB_MIN_BITRATE = 4150;
1012 public const int SPEEX_UWB_MAX_BITRATE = 44000;
1015 public const int DEFAULT_SPEEX_BANDMODE = 1;
1018 public const int DEFAULT_SPEEX_QUALITY = 4;
1021 public const int DEFAULT_SPEEX_DELAY = 40;
1024 public const bool DEFAULT_SPEEX_SIMSTEREO = false;
1027 public const int DEFAULT_SPEEX_BITRATE = 0;
1030 public const int DEFAULT_SPEEX_MAXBITRATE = 0;
1033 public const bool DEFAULT_SPEEX_DTX = true;
1034 }
1035
1038 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1039 public struct OpusCodec
1040 {
1043 public int nSampleRate;
1045 public int nChannels;
1049 public int nApplication;
1052 public int nComplexity;
1055 public bool bFEC;
1058 public bool bDTX;
1062 public int nBitRate;
1064 public bool bVBR;
1067 public bool bVBRConstraint;
1078 public int nFrameSizeMSec;
1079 }
1080
1082 public struct OpusConstants
1083 {
1086 public const int OPUS_APPLICATION_VOIP = 2048;
1089 public const int OPUS_APPLICATION_AUDIO = 2049;
1092 public const int OPUS_MIN_BITRATE = 6000;
1095 public const int OPUS_MAX_BITRATE = 510000;
1096
1099 public const int OPUS_MIN_FRAMESIZE = 2; /* Actually it's 2.5 */
1102 public const int OPUS_MAX_FRAMESIZE = 60;
1106 public const int OPUS_REALMAX_FRAMESIZE = 120;
1107
1109 public const int DEFAULT_OPUS_SAMPLERATE = 48000;
1110 public const int DEFAULT_OPUS_CHANNELS = 1;
1111 public const int DEFAULT_OPUS_COMPLEXITY = 10;
1112 public const bool DEFAULT_OPUS_FEC = true;
1113 public const bool DEFAULT_OPUS_DTX = false;
1114 public const bool DEFAULT_OPUS_VBR = true;
1115 public const bool DEFAULT_OPUS_VBRCONSTRAINT = false;
1116 public const int DEFAULT_OPUS_BITRATE = 32000;
1117 public const int DEFAULT_OPUS_DELAY = 20;
1118 }
1119
1137 [StructLayout(LayoutKind.Explicit)]
1138 public struct SpeexDSP
1139 {
1147 [FieldOffset(0)]
1148 public bool bEnableAGC;
1151 [FieldOffset(4)]
1152 public int nGainLevel;
1156 [FieldOffset(8)]
1157 public int nMaxIncDBSec;
1162 [FieldOffset(12)]
1163 public int nMaxDecDBSec;
1167 [FieldOffset(16)]
1168 public int nMaxGainDB;
1171 [FieldOffset(20)]
1172 public bool bEnableDenoise;
1176 [FieldOffset(24)]
1196 [FieldOffset(28)]
1201 [FieldOffset(32)]
1202 public int nEchoSuppress;
1206 [FieldOffset(36)]
1208
1209 public SpeexDSP(bool set_defaults)
1210 {
1211 if (set_defaults)
1212 {
1218
1221
1225 }
1226 else
1227 {
1228 bEnableAGC = false;
1229 nGainLevel = 0;
1230 nMaxIncDBSec = 0;
1231 nMaxDecDBSec = 0;
1232 nMaxGainDB = 0;
1233
1234 bEnableDenoise = false;
1236
1238 nEchoSuppress = 0;
1240 }
1241 }
1242 }
1243
1246 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1248 {
1252 public int nGainLevel;
1254 public bool bMuteLeftSpeaker;
1257 }
1258
1268 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1270 {
1272 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1273 public struct Preamplifier
1274 {
1277 public bool bEnable;
1279 public float fFixedGainFactor;
1280 }
1282
1285 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1286 public struct EchoCanceller
1287 {
1293 public bool bEnable;
1294 }
1296
1299 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1300 public struct NoiseSuppression
1301 {
1303 public bool bEnable;
1306 public int nLevel;
1307 }
1309
1311 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1312 public struct VoiceDetection
1313 {
1323 public bool bEnable;
1324 }
1326
1329 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1330 public struct GainController2
1331 {
1334 public bool bEnable;
1337 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1338 public struct FixedDigital
1339 {
1342 public float fGainDB;
1343 }
1345
1347 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1348 public struct AdaptiveDigital
1349 {
1350 /* @brief Enable saturation protector where saturation
1351 * margin is 2 dB. */
1352 public bool bEnable;
1353 /* Range: 0 <= x <= 100. Default: 20 dB */
1355 /* Range: 0 <= x <= 100. Default: 2 dB */
1357 /* Range: 0 < x < infinite. Default: 3 dB/sec */
1359 /* Range: -infinite < x < 0. Default: -50 */
1361 }
1363 }
1365
1367 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1368 public struct LevelEstimation
1369 {
1375 public bool bEnable;
1376 }
1378
1379 public WebRTCAudioPreprocessor(bool set_defaults)
1380 {
1381 if (set_defaults)
1382 {
1385
1387
1390
1392
1395
1401
1403 }
1404 else
1405 {
1406 preamplifier.bEnable = false;
1408
1409 echocanceller.bEnable = false;
1410
1411 noisesuppression.bEnable = false;
1413
1414 voicedetection.bEnable = false;
1415
1416 gaincontroller2.bEnable = false;
1418
1424
1425 levelestimation.bEnable = false;
1426 }
1427 }
1428 }
1429
1431 public struct WebRTCConstants
1432 {
1433 public const bool DEFAULT_WEBRTC_PREAMPLIFIER_ENABLE = false;
1435 public const bool DEFAULT_WEBRTC_VAD_ENABLE = false;
1436 public const bool DEFAULT_WEBRTC_LEVELESTIMATION_ENABLE = false;
1437 public const bool DEFAULT_WEBRTC_GAINCTL_ENABLE = false;
1438 public const float DEFAULT_WEBRTC_GAINDB = 15;
1439 public const bool DEFAULT_WEBRTC_SAT_PROT_ENABLE = false;
1440 public const float DEFAULT_WEBRTC_INIT_SAT_MARGIN_DB = 20;
1442 public const float DEFAULT_WEBRTC_MAXGAIN_DBSEC = 3;
1443 public const float DEFAULT_WEBRTC_MAX_OUT_NOISE = -50;
1444 public const bool DEFAULT_WEBRTC_NOISESUPPRESS_ENABLE = false;
1446 public const bool DEFAULT_WEBRTC_ECHO_CANCEL_ENABLE = false;
1447 public const float WEBRTC_GAINCONTROLLER2_FIXEDGAIN_MAX = 49.9f;
1448 }
1449
1453 public enum AudioPreprocessorType : uint
1454 {
1465 };
1466
1468 [StructLayout(LayoutKind.Explicit)]
1469 public struct AudioPreprocessor
1470 {
1472 [FieldOffset(0)]
1475 [FieldOffset(4)]
1478 [FieldOffset(4)]
1481 [FieldOffset(4)]
1483 }
1484
1486 public struct SpeexDSPConstants
1487 {
1488 public const bool DEFAULT_AGC_ENABLE = true;
1489 public const int DEFAULT_AGC_GAINLEVEL = 8000;
1490 public const int DEFAULT_AGC_INC_MAXDB = 12;
1491 public const int DEFAULT_AGC_DEC_MAXDB = -40;
1492 public const int DEFAULT_AGC_GAINMAXDB = 30;
1493 public const bool DEFAULT_DENOISE_ENABLE = true;
1494 public const int DEFAULT_DENOISE_SUPPRESS = -30;
1495 public const bool DEFAULT_ECHO_ENABLE = true;
1496 public const int DEFAULT_ECHO_SUPPRESS = -40;
1497 public const int DEFAULT_ECHO_SUPPRESS_ACTIVE = -15;
1498 }
1499
1504 [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
1505 public struct WebMVP8Codec
1506 {
1508 [FieldOffset(0)]
1515 [FieldOffset(0)]
1524 [FieldOffset(4)]
1525 public uint nEncodeDeadline;
1526 }
1527
1529 {
1532 public const int WEBM_VPX_DL_REALTIME = 1;
1535 public const int WEBM_VPX_DL_GOOD_QUALITY = 1000000;
1538 public const int WEBM_VPX_DL_BEST_QUALITY = 0;
1539 }
1540
1545 public enum Codec : uint
1546 {
1548 NO_CODEC = 0,
1551 SPEEX_CODEC = 1,
1554 SPEEX_VBR_CODEC = 2,
1556 OPUS_CODEC = 3,
1558 WEBM_VP8_CODEC = 128
1559 }
1560
1564 [StructLayout(LayoutKind.Explicit)]
1565 public struct AudioCodec
1566 {
1569 [FieldOffset(0)]
1573 [FieldOffset(4)]
1577 [FieldOffset(4)]
1581 [FieldOffset(4)]
1583 }
1584
1598 [StructLayout(LayoutKind.Explicit)]
1599 public struct AudioConfig
1600 {
1602 [FieldOffset(0)]
1603 public bool bEnableAGC;
1605 [FieldOffset(4)]
1606 public int nGainLevel;
1607
1608 public AudioConfig(bool set_defaults)
1609 {
1610 if (set_defaults)
1611 {
1612 bEnableAGC = true;
1614 }
1615 else
1616 {
1617 bEnableAGC = false;
1618 nGainLevel = 0;
1619 }
1620 }
1621 }
1622
1624 {
1625 public const int DEFAULT_AGC_GAINLEVEL = 8000;
1626 public const int DEFAULT_AGC_INC_MAXDB = 12;
1627 }
1628
1630 [StructLayout(LayoutKind.Explicit)]
1631 public struct VideoCodec
1632 {
1636 [FieldOffset(0)]
1638 [FieldOffset(4)]
1640 }
1651 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1652 public struct MediaFileInfo
1653 {
1658 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1659 public string szFileName;
1665 public uint uDurationMSec;
1667 public uint uElapsedMSec;
1668 }
1677 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1678 public struct MediaFilePlayback
1679 {
1684 public uint uOffsetMSec;
1686 public bool bPaused;
1689 }
1690
1693 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1695 {
1697 public int nStreamID;
1700 public uint uQueueMSec;
1703 public uint uElapsedMSec;
1704 }
1705
1722 [Flags]
1723 public enum UserRight : uint
1724 {
1727 USERRIGHT_NONE = 0x00000000,
1730 USERRIGHT_MULTI_LOGIN = 0x00000001,
1732 USERRIGHT_VIEW_ALL_USERS = 0x00000002,
1740 USERRIGHT_MODIFY_CHANNELS = 0x00000008,
1745 USERRIGHT_KICK_USERS = 0x00000020,
1748 USERRIGHT_BAN_USERS = 0x00000040,
1751 USERRIGHT_MOVE_USERS = 0x00000080,
1754 USERRIGHT_OPERATOR_ENABLE = 0x00000100,
1756 USERRIGHT_UPLOAD_FILES = 0x00000200,
1759 USERRIGHT_DOWNLOAD_FILES = 0x00000400,
1765 USERRIGHT_TRANSMIT_VOICE = 0x00001000,
1771 USERRIGHT_TRANSMIT_DESKTOP = 0x00004000,
1790 USERRIGHT_LOCKED_NICKNAME = 0x00040000,
1793 USERRIGHT_LOCKED_STATUS = 0x00080000,
1796 USERRIGHT_RECORD_VOICE = 0x00100000,
1798 USERRIGHT_VIEW_HIDDEN_CHANNELS = 0x00200000,
1800 USERRIGHT_ALL = 0xFFFFFFFF & ~USERRIGHT_LOCKED_NICKNAME & ~USERRIGHT_LOCKED_STATUS
1801 }
1802
1814 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1815 public struct ServerProperties
1816 {
1818 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1819 public string szServerName;
1822 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1823 public string szMOTD;
1832 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1833 public string szMOTDRaw;
1836 public int nMaxUsers;
1865 public bool bAutoSave;
1867 public int nTcpPort;
1869 public int nUdpPort;
1872 public int nUserTimeout;
1874 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1875 public string szServerVersion;
1877 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1891 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1892 public string szAccessToken;
1893 }
1894
1902 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1903 public struct ServerStatistics
1904 {
1907 public long nTotalBytesTX;
1910 public long nTotalBytesRX;
1913 public long nVoiceBytesTX;
1916 public long nVoiceBytesRX;
1931 public long nDesktopBytesTX;
1934 public long nDesktopBytesRX;
1936 public int nUsersServed;
1938 public int nUsersPeak;
1941 public long nFilesTx;
1944 public long nFilesRx;
1946 public long nUptimeMSec;
1947 }
1948
1954 [Flags]
1955 public enum BanType : uint
1956 {
1958 BANTYPE_NONE = 0x00,
1962 BANTYPE_CHANNEL = 0x01,
1964 BANTYPE_IPADDR = 0x02,
1966 BANTYPE_USERNAME = 0x04
1967 };
1968
1973 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
1974 public struct BannedUser
1975 {
1977 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1978 public string szIPAddress;
1980 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1981 public string szChannelPath;
1983 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1984 public string szBanTime;
1986 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1987 public string szNickname;
1989 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
1990 public string szUsername;
1993 }
1994
1998 [Flags]
1999 public enum UserType : uint
2000 {
2003 USERTYPE_NONE = 0x0,
2005 USERTYPE_DEFAULT = 0x01,
2007 USERTYPE_ADMIN = 0x02
2008 }
2009
2018 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2019 public struct AbusePrevention
2020 {
2030 public int nCommandsLimit;
2033 }
2034
2043 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2044 public struct UserAccount
2045 {
2047 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2048 public string szUsername;
2050 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2051 public string szPassword;
2061 public int nUserData;
2063 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2064 public string szNote;
2069 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2070 public string szInitChannel;
2074 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_CHANNELS_OPERATOR_MAX)]
2087 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2088 public string szLastModified;
2089 }
2113 [Flags]
2114 public enum Subscription : uint
2115 {
2117 SUBSCRIBE_NONE = 0x00000000,
2120 SUBSCRIBE_USER_MSG = 0x00000001,
2123 SUBSCRIBE_CHANNEL_MSG = 0x00000002,
2126 SUBSCRIBE_BROADCAST_MSG = 0x00000004,
2129 SUBSCRIBE_CUSTOM_MSG = 0x00000008,
2131 SUBSCRIBE_VOICE = 0x00000010,
2133 SUBSCRIBE_VIDEOCAPTURE = 0x00000020,
2135 SUBSCRIBE_DESKTOP = 0x00000040,
2139 SUBSCRIBE_DESKTOPINPUT = 0x00000080,
2142 SUBSCRIBE_MEDIAFILE = 0x00000100,
2145 SUBSCRIBE_INTERCEPT_USER_MSG = 0x00010000,
2149 /* unused SUBSCRIBE_INTERCEPT_BROADCAST_MSG = 0x00040000 */
2152 SUBSCRIBE_INTERCEPT_CUSTOM_MSG = 0x00080000,
2157 SUBSCRIBE_INTERCEPT_VOICE = 0x00100000,
2167 SUBSCRIBE_INTERCEPT_DESKTOP = 0x00400000,
2168 /* unused SUBSCRIBE_INTERCEPT_DESKTOPINPUT = 0x00800000, */
2173 SUBSCRIBE_INTERCEPT_MEDIAFILE = 0x01000000,
2174 }
2175
2179 [Flags]
2180 public enum UserState : uint
2181 {
2183 USERSTATE_NONE = 0x0000000,
2187 USERSTATE_VOICE = 0x00000001,
2189 USERSTATE_MUTE_VOICE = 0x00000002,
2192 USERSTATE_MUTE_MEDIAFILE = 0x00000004,
2197 USERSTATE_DESKTOP = 0x00000008,
2202 USERSTATE_VIDEOCAPTURE = 0x00000010,
2208 USERSTATE_MEDIAFILE_AUDIO = 0x00000020,
2212 USERSTATE_MEDIAFILE_VIDEO = 0x00000040,
2218 }
2219
2224 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2225 public struct User
2226 {
2230 public int nUserID;
2235 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2236 public string szUsername;
2241 public int nUserData;
2247 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2248 public string szIPAddress;
2254 public uint uVersion;
2260 public int nChannelID;
2277 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2278 public string szNickname;
2283 public int nStatusMode;
2288 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2289 public string szStatusMsg;
2295 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2296 public string szMediaStorageDir;
2302 public int nVolumeVoice;
2321 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
2322 public float[] soundPositionVoice;
2327 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)]
2333 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
2334 public bool[] stereoPlaybackVoice;
2339 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2)]
2356 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2357 public string szClientName;
2358 }
2359
2364 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2365 public struct UserStatistics
2366 {
2397 }
2398
2407 public enum TextMsgType : uint
2408 {
2411 MSGTYPE_USER = 1,
2416 MSGTYPE_CHANNEL = 2,
2422 MSGTYPE_CUSTOM = 4
2423 }
2424
2432 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2433 public struct TextMessage
2434 {
2438 public int nFromUserID;
2440 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2441 public string szFromUsername;
2443 public int nToUserID;
2446 public int nChannelID;
2449 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2450 public string szMessage;
2451 }
2459 [Flags]
2460 public enum ChannelType : uint
2461 {
2464 CHANNEL_DEFAULT = 0x0000,
2467 CHANNEL_PERMANENT = 0x0001,
2469 CHANNEL_SOLO_TRANSMIT = 0x0002,
2480 CHANNEL_CLASSROOM = 0x0004,
2490 CHANNEL_NO_RECORDING = 0x0020,
2493 CHANNEL_HIDDEN = 0x0040,
2494 }
2495
2507 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2508 public struct Channel
2509 {
2512 public int nParentID;
2515 public int nChannelID;
2517 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2518 public string szName;
2520 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2521 public string szTopic;
2525 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2526 public string szPassword;
2529 public bool bPassword;
2535 public int nUserData;
2537 public long nDiskQuota;
2540 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2541 public string szOpPassword;
2543 public int nMaxUsers;
2604 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_TRANSMITUSERS_MAX * 2)]
2605 public int[] transmitUsers;
2610 [MarshalAs(UnmanagedType.ByValArray, SizeConst = TeamTalkBase.TT_TRANSMITQUEUE_MAX)]
2612
2615 public void AddTransmitUser(int nUserID, StreamType uStreamType)
2616 {
2617 int i;
2618 for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2619 {
2620 if (transmitUsers[i * 2] == 0 || transmitUsers[i * 2] == nUserID)
2621 break;
2622 }
2624 {
2625 transmitUsers[i * 2] = nUserID;
2626 transmitUsers[i * 2 + 1] |= (int)uStreamType;
2627 }
2628 }
2632 {
2633 int i;
2634 for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2635 {
2636 if (transmitUsers[i * 2] == nUserID)
2637 return (StreamType)transmitUsers[i * 2 + 1];
2638 }
2639 return StreamType.STREAMTYPE_NONE;
2640 }
2643 {
2644 int i;
2645 for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2646 {
2647 if (transmitUsers[i * 2] == 0)
2648 break;
2649 }
2650 return i;
2651 }
2653 public void RemoveTransmitUser(int nUserID, StreamType uStreamType)
2654 {
2655 int i;
2656 for (i = 0; i < TeamTalkBase.TT_TRANSMITUSERS_MAX; i++)
2657 {
2658 if (transmitUsers[i * 2] == nUserID)
2659 break;
2660 }
2662 {
2663 transmitUsers[i * 2] = nUserID;
2664 transmitUsers[i * 2 + 1] &= (int)~uStreamType;
2665
2666 if (transmitUsers[i * 2 + 1] == (int)StreamType.STREAMTYPE_NONE)
2667 {
2668 for (; i < TeamTalkBase.TT_TRANSMITUSERS_MAX - 1; i++)
2669 {
2670 transmitUsers[i * 2] = transmitUsers[(i + 1) * 2 + 1];
2671 transmitUsers[i * 2 + 1] = transmitUsers[(i + 1) * 2 + 1];
2672 }
2673 }
2674 }
2675 }
2676 }
2677
2680 public enum FileTransferStatus : uint
2681 {
2690 }
2691
2695 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2696 public struct FileTransfer
2697 {
2701 public int nTransferID;
2703 public int nChannelID;
2705 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2706 public string szLocalFilePath;
2708 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2709 public string szRemoteFileName;
2711 public long nFileSize;
2713 public long nTransferred;
2715 public bool bInbound;
2716 }
2717
2721 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2722 public struct RemoteFile
2723 {
2725 public int nChannelID;
2727 public int nFileID;
2729 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2730 public string szFileName;
2732 public long nFileSize;
2734 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2735 public string szUsername;
2738 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2739 public string szUploadTime;
2740 }
2751 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2752 public struct EncryptionContext
2753 {
2759 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2760 public string szCertificateFile;
2762 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2763 public string szPrivateKeyFile;
2768 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2769 public string szCAFile;
2772 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
2773 public string szCADir;
2780 public bool bVerifyPeer;
2799 public int nVerifyDepth;
2800 }
2801
2809 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2810 public struct ClientKeepAlive
2811 {
2854 }
2855
2860 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2861 public struct ClientStatistics
2862 {
2864 public long nUdpBytesSent;
2866 public long nUdpBytesRecv;
2868 public long nVoiceBytesSent;
2870 public long nVoiceBytesRecv;
2890 public int nUdpPingTimeMs;
2894 public int nTcpPingTimeMs;
2913 }
2914
2920 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
2921 public struct JitterConfig
2922 {
2937 }
2938
2939
2949 public enum ClientError : uint
2950 {
2952 CMDERR_SUCCESS = 0,
2953 SUCCESS = 0,
2954
2955 /* COMMAND ERRORS 1000-1999 ARE DUE TO INVALID OR UNSUPPORTED
2956 * COMMANDS */
2957
2959 CMDERR_SYNTAX_ERROR = 1000,
2979
2980 /* COMMAND ERRORS 2000-2999 ARE DUE TO INSUFFICIENT RIGHTS */
2981
3015 CMDERR_SERVER_BANNED = 2005,
3047 CMDERR_NOT_AUTHORIZED = 2006,
3055
3062
3069
3076
3080
3085 CMDERR_COMMAND_FLOOD = 2014,
3086
3092 CMDERR_CHANNEL_BANNED = 2015,
3093
3094 /* COMMAND ERRORS 3000-3999 ARE DUE TO INVALID STATE OF CLIENT INSTANCE */
3095
3101 CMDERR_NOT_LOGGEDIN = 3000,
3102
3110 CMDERR_NOT_IN_CHANNEL = 3002,
3148 CMDERR_USER_NOT_FOUND = 3006,
3153 CMDERR_BAN_NOT_FOUND = 3007,
3173 CMDERR_FILE_NOT_FOUND = 3011,
3184
3189
3194
3200
3201 /* ERRORS 10000-10999 ARE NOT COMMAND ERRORS BUT INSTEAD
3202 * ERRORS IN THE CLIENT INSTANCE. */
3203
3243 }
3244
3245 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
3246 public struct ClientErrorMsg
3247 {
3249 public int nErrorNo;
3251 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
3252 public string szErrorMsg;
3253 }
3254
3264 public enum ClientEvent : uint
3265 {
3266 CLIENTEVENT_NONE = 0,
3818 }
3819
3820
3821 /* List of structures used internally by TeamTalkBase. */
3822 public enum TTType : uint
3823 {
3824 __NONE = 0,
3825 __AUDIOCODEC = 1,
3826 __BANNEDUSER = 2,
3827 __VIDEOFORMAT = 3,
3828 __OPUSCODEC = 4,
3829 __CHANNEL = 5,
3831 __REMOTEFILE = 7,
3832 __FILETRANSFER = 8,
3834 __SERVERPROPERTIES = 10,
3835 __SERVERSTATISTICS = 11,
3836 __SOUNDDEVICE = 12,
3837 __SPEEXCODEC = 13,
3838 __TEXTMESSAGE = 14,
3839 __WEBMVP8CODEC = 15,
3840 __TTMESSAGE = 16,
3841 __USER = 17,
3842 __USERACCOUNT = 18,
3843 __USERSTATISTICS = 19,
3845 __VIDEOCODEC = 21,
3846 __AUDIOCONFIG = 22,
3847 __SPEEXVBRCODEC = 23,
3848 __VIDEOFRAME = 24,
3849 __AUDIOBLOCK = 25,
3850 __AUDIOFORMAT = 26,
3851 __MEDIAFILEINFO = 27,
3852 __CLIENTERRORMSG = 28,
3853 __TTBOOL = 29,
3854 __INT32 = 30,
3855 __DESKTOPINPUT = 31,
3856 __SPEEXDSP = 32,
3857 __STREAMTYPE = 33,
3862 __CLIENTKEEPALIVE = 38,
3863 __UINT32 = 39,
3865 __JITTERCONFIG = 41,
3868 }
3869
3880 [StructLayout(LayoutKind.Sequential)]
3881 public struct TTMessage
3882 {
3886 public int nSource;
3890 public uint uReserved;
3891 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6248)]
3892 public byte[] data;
3893 //UnionData data;
3894
3895 public object DataToObject()
3896 {
3897 switch (ttType)
3898 {
3899 case TTType.__CHANNEL:
3900 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(Channel));
3901 case TTType.__CLIENTERRORMSG:
3902 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ClientErrorMsg));
3903 case TTType.__DESKTOPINPUT:
3904 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(DesktopInput));
3905 case TTType.__FILETRANSFER:
3906 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(FileTransfer));
3907 case TTType.__MEDIAFILEINFO:
3908 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(MediaFileInfo));
3909 case TTType.__REMOTEFILE:
3910 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(RemoteFile));
3911 case TTType.__SERVERPROPERTIES:
3912 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ServerProperties));
3913 case TTType.__SERVERSTATISTICS:
3914 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(ServerStatistics));
3915 case TTType.__TEXTMESSAGE:
3916 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(TextMessage));
3917 case TTType.__USER:
3918 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(User));
3919 case TTType.__USERACCOUNT:
3920 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(UserAccount));
3921 case TTType.__BANNEDUSER :
3922 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(BannedUser));
3923 case TTType.__TTBOOL:
3924 return Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this)) != 0;
3925 case TTType.__INT32:
3926 return Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this));
3927 case TTType.__STREAMTYPE :
3928 return (StreamType)Marshal.ReadInt32(TTDLL.TT_DBG_GETDATAPTR(ref this));
3929 case TTType.__AUDIOINPUTPROGRESS :
3930 return Marshal.PtrToStructure(TTDLL.TT_DBG_GETDATAPTR(ref this), typeof(AudioInputProgress));
3931 default:
3932 return null;
3933 }
3934 }
3935 }
3936
3937 [StructLayout(LayoutKind.Explicit, Size = 5224)]
3939 {
3940 [FieldOffset(0)]
3942 [FieldOffset(0)]
3944 [FieldOffset(0)]
3946 [FieldOffset(0)]
3948 [FieldOffset(0)]
3950 [FieldOffset(0)]
3952 [FieldOffset(0)]
3954 [FieldOffset(0)]
3956 [FieldOffset(0)]
3957 public User user;
3958 [FieldOffset(0)]
3960 [FieldOffset(0)]
3961 public bool bActive;
3962 [FieldOffset(0)]
3963 public int nBytesRemain;
3964 [FieldOffset(0)]
3965 public int nStreamID;
3966 [FieldOffset(0)]
3967 public int nPayloadSize;
3968 }
3969
3987 [Flags]
3988 public enum ClientFlag : uint
3989 {
3992 CLIENT_CLOSED = 0x00000000,
3996 CLIENT_SNDINPUT_READY = 0x00000001,
4000 CLIENT_SNDOUTPUT_READY = 0x00000002,
4006 CLIENT_SNDINOUTPUT_DUPLEX = 0x00000004,
4013 CLIENT_SNDINPUT_VOICEACTIVATED = 0x00000008,
4020 CLIENT_SNDINPUT_VOICEACTIVE = 0x00000010,
4023 CLIENT_SNDOUTPUT_MUTE = 0x00000020,
4033 CLIENT_VIDEOCAPTURE_READY = 0x00000080,
4036 CLIENT_TX_VOICE = 0x00000100,
4039 CLIENT_TX_VIDEOCAPTURE = 0x00000200,
4045 CLIENT_TX_DESKTOP = 0x00000400,
4050 CLIENT_DESKTOP_ACTIVE = 0x00000800,
4054 CLIENT_MUX_AUDIOFILE = 0x00001000,
4057 CLIENT_CONNECTING = 0x00002000,
4062 CLIENT_CONNECTED = 0x00004000,
4069 CLIENT_AUTHORIZED = 0x00008000,
4074 CLIENT_STREAM_AUDIO = 0x00010000,
4079 CLIENT_STREAM_VIDEO = 0x00020000
4080 }
4081
4089 public abstract class TeamTalkBase : IDisposable
4090 {
4099 public const int TT_STRLEN = 512;
4100
4102 public const int TT_USERID_MAX = 0xFFF;
4103
4106 public const int TT_CHANNELID_MAX = 0xFFF;
4107
4111 public const int TT_VIDEOFORMATS_MAX = 1024;
4112
4118 public const int TT_TRANSMITUSERS_MAX = 128;
4119
4127 public const int TT_CLASSROOM_FREEFORALL = 0xFFF;
4128
4131 public const int TT_CLASSROOM_USERID_INDEX = 0;
4132
4135 public const int TT_CLASSROOM_STREAMTYPE_INDEX = 1;
4136
4139 public const int TT_TRANSMITUSERS_FREEFORALL = 0xFFF;
4140
4143 public const int TT_TRANSMITUSERS_USERID_INDEX = 0;
4144
4148
4162 public const int TT_LOCAL_USERID = 0;
4163
4171 public const int TT_LOCAL_TX_USERID = 0x1002;
4172
4180 public const int TT_MUXED_USERID = 0x1001; /* TT_USERID_MAX + 2 */
4181
4186 public const int TT_CHANNELS_OPERATOR_MAX = 16;
4187
4191 public const int TT_TRANSMITQUEUE_MAX = 16;
4192
4195 public const int TT_SAMPLERATES_MAX = 16;
4196
4201 public const int TT_DESKTOPINPUT_MAX = 16;
4202
4211 public const uint TT_MEDIAPLAYBACK_OFFSET_IGNORE = 0xFFFFFFFF;
4212
4213
4215 public static string GetVersion() { return Marshal.PtrToStringAuto(TTDLL.TT_GetVersion()); }
4216
4227 protected TeamTalkBase(bool poll_based)
4228 {
4229 Assembly assembly = Assembly.GetExecutingAssembly();
4230 AssemblyName name = assembly.GetName();
4231 Version dllversion = new Version(Marshal.PtrToStringUni((c_tt.TTDLL.TT_GetVersion())));
4232 if (!name.Version.Equals(dllversion))
4233 {
4234 string errmsg = String.Format("Invalid {2} version loaded. {2} is version {0} and {3} is version {1}",
4235 dllversion.ToString(), name.Version.ToString(), c_tt.TTDLL.dllname, c_tt.TTDLL.mgtdllname);
4236
4237 // throw new Exception(errmsg);
4238
4239 System.Diagnostics.Debug.WriteLine(errmsg);
4240 }
4241
4242 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOCODEC) == Marshal.SizeOf(new AudioCodec()));
4243 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__BANNEDUSER) == Marshal.SizeOf(new BannedUser()));
4244 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOFORMAT) == Marshal.SizeOf(new VideoFormat()));
4245 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__OPUSCODEC) == Marshal.SizeOf(new OpusCodec()));
4246 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CHANNEL) == Marshal.SizeOf(new Channel()));
4247 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTSTATISTICS) == Marshal.SizeOf(new ClientStatistics()));
4248 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__REMOTEFILE) == Marshal.SizeOf(new RemoteFile()));
4249 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__FILETRANSFER) == Marshal.SizeOf(new FileTransfer()));
4250 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILESTATUS) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(MediaFileStatus))));
4251 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SERVERPROPERTIES) == Marshal.SizeOf(new ServerProperties()));
4252 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SERVERSTATISTICS) == Marshal.SizeOf(new ServerStatistics()));
4253 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SOUNDDEVICE) == Marshal.SizeOf(new SoundDevice()));
4254 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXCODEC) == Marshal.SizeOf(new SpeexCodec()));
4255 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TEXTMESSAGE) == Marshal.SizeOf(new TextMessage()));
4256 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__WEBMVP8CODEC) == Marshal.SizeOf(new WebMVP8Codec()));
4257 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TTMESSAGE) == Marshal.SizeOf(new TTMessage()));
4258 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USER) == Marshal.SizeOf(new User()));
4259 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USERACCOUNT) == Marshal.SizeOf(new UserAccount()));
4260 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__USERSTATISTICS) == Marshal.SizeOf(new UserStatistics()));
4261 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOCAPTUREDEVICE) == Marshal.SizeOf(new VideoCaptureDevice()));
4262 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOCODEC) == Marshal.SizeOf(new VideoCodec()));
4263 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOCONFIG) == Marshal.SizeOf(new AudioConfig()));
4264 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXVBRCODEC) == Marshal.SizeOf(new SpeexVBRCodec()));
4265 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__VIDEOFRAME) == Marshal.SizeOf(new VideoFrame()));
4266 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOBLOCK) == Marshal.SizeOf(new AudioBlock()));
4267 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOFORMAT) == Marshal.SizeOf(new AudioFormat()));
4268 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILEINFO) == Marshal.SizeOf(new MediaFileInfo()));
4269 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTERRORMSG) == Marshal.SizeOf(new ClientErrorMsg()));
4270 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__DESKTOPINPUT) == Marshal.SizeOf(new DesktopInput()));
4271 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__SPEEXDSP) == Marshal.SizeOf(new SpeexDSP()));
4272 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__STREAMTYPE) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(StreamType))));
4273 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOPREPROCESSORTYPE) == Marshal.SizeOf(Enum.GetUnderlyingType(typeof(AudioPreprocessorType))));
4274 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__WEBRTCAUDIOPREPROCESSOR) == Marshal.SizeOf(new WebRTCAudioPreprocessor()));
4275 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__TTAUDIOPREPROCESSOR) == Marshal.SizeOf(new TTAudioPreprocessor()));
4276 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOPREPROCESSOR) == Marshal.SizeOf(new AudioPreprocessor()));
4277 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__MEDIAFILEPLAYBACK) == Marshal.SizeOf(new MediaFilePlayback()));
4278 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__CLIENTKEEPALIVE) == Marshal.SizeOf(new ClientKeepAlive()));
4279 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__AUDIOINPUTPROGRESS) == Marshal.SizeOf(new AudioInputProgress()));
4280 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__JITTERCONFIG) == Marshal.SizeOf(new JitterConfig()));
4281 Debug.Assert(TTDLL.TT_DBG_SIZEOF(TTType.__ENCRYPTIONCONTEXT) == Marshal.SizeOf(new EncryptionContext()));
4282
4283 if (poll_based)
4284 m_ttInst = TTDLL.TT_InitTeamTalkPoll();
4285 else
4286 {
4287 m_eventhandler = new MyEventHandler(this);
4288#if PocketPC
4289 IntPtr hWnd = m_eventhandler.Hwnd;
4290#else
4291 m_eventhandler.CreateControl();
4292 IntPtr hWnd = m_eventhandler.Handle;
4293#endif
4294 m_ttInst = TTDLL.TT_InitTeamTalk(hWnd, MyEventHandler.WM_TEAMTALK_CLIENTEVENT);
4295 }
4296 }
4297
4303 {
4304 DeleteMe();
4305 }
4306
4307
4308 #region IDisposable Members
4309
4310 public void Dispose()
4311 {
4312 DeleteMe();
4313 }
4314
4315 private void DeleteMe()
4316 {
4317 if (m_ttInst != IntPtr.Zero)
4318 {
4319 TTDLL.TT_CloseTeamTalk(m_ttInst);
4320 m_ttInst = IntPtr.Zero;
4321 }
4322 }
4323
4324 #endregion
4325
4343 public bool GetMessage(ref TTMessage pMsg, int nWaitMs)
4344 {
4345 return TTDLL.TT_GetMessage(m_ttInst, ref pMsg, ref nWaitMs);
4346 }
4347
4374 public bool PumpMessage(ClientEvent nClientEvent,
4375 int nIdentifier)
4376 {
4377 return TTDLL.TT_PumpMessage(m_ttInst, nClientEvent, nIdentifier);
4378 }
4379
4388 public BearWare.ClientFlag GetFlags()
4389 {
4390 return TTDLL.TT_GetFlags(m_ttInst);
4391 }
4392
4397 {
4398 get { return GetFlags(); }
4399 }
4400
4410 public static bool SetLicenseInformation(string szRegName, string szRegKey)
4411 {
4412 return TTDLL.TT_SetLicenseInformation(szRegName, szRegKey);
4413 }
4414
4419 public void ProcessMsg(TTMessage msg)
4420 {
4421 switch (msg.nClientEvent)
4422 {
4423 case ClientEvent.CLIENTEVENT_CON_SUCCESS:
4424 if(OnConnectionSuccess != null)
4426 break;
4427 case ClientEvent.CLIENTEVENT_CON_FAILED:
4428 if (OnConnectionFailed != null)
4430 break;
4431 case ClientEvent.CLIENTEVENT_CON_LOST:
4432 if (OnConnectionLost != null)
4434 break;
4435 case ClientEvent.CLIENTEVENT_CON_MAX_PAYLOAD_UPDATED :
4438 break;
4439 case ClientEvent.CLIENTEVENT_CMD_PROCESSING:
4440 if (OnCmdProcessing != null)
4441 OnCmdProcessing(msg.nSource, (bool)msg.DataToObject());
4442 break;
4443 case ClientEvent.CLIENTEVENT_CMD_ERROR:
4444 if (OnCmdError != null)
4446 break;
4447 case ClientEvent.CLIENTEVENT_CMD_SUCCESS :
4448 if (OnCmdSuccess != null)
4449 OnCmdSuccess((int)msg.nSource);
4450 break;
4451 case ClientEvent.CLIENTEVENT_CMD_MYSELF_LOGGEDIN:
4452 if (OnCmdMyselfLoggedIn != null)
4454 break;
4455 case ClientEvent.CLIENTEVENT_CMD_MYSELF_LOGGEDOUT:
4456 if (OnCmdMyselfLoggedOut != null)
4458 break;
4459 case ClientEvent.CLIENTEVENT_CMD_MYSELF_KICKED:
4460 if (msg.ttType == TTType.__USER)
4461 {
4462 if (OnCmdMyselfKicked != null)
4464 }
4465 else if (OnCmdMyselfKicked != null)
4466 OnCmdMyselfKicked(new User());
4467 break;
4468 case ClientEvent.CLIENTEVENT_CMD_USER_LOGGEDIN:
4469 if (OnCmdUserLoggedIn != null)
4471 break;
4472 case ClientEvent.CLIENTEVENT_CMD_USER_LOGGEDOUT:
4473 if (OnCmdUserLoggedOut != null)
4475 break;
4476 case ClientEvent.CLIENTEVENT_CMD_USER_UPDATE:
4477 if (OnCmdUserUpdate != null)
4479 break;
4480 case ClientEvent.CLIENTEVENT_CMD_USER_JOINED:
4481 if (OnCmdUserJoinedChannel != null)
4483 break;
4484 case ClientEvent.CLIENTEVENT_CMD_USER_LEFT:
4485 if (OnCmdUserLeftChannel != null)
4487 break;
4488 case ClientEvent.CLIENTEVENT_CMD_USER_TEXTMSG:
4489 if (OnCmdUserTextMessage != null)
4491 break;
4492 case ClientEvent.CLIENTEVENT_CMD_CHANNEL_NEW:
4493 if (OnCmdChannelNew != null)
4495 break;
4496 case ClientEvent.CLIENTEVENT_CMD_CHANNEL_UPDATE:
4497 if (OnCmdChannelUpdate != null)
4499 break;
4500 case ClientEvent.CLIENTEVENT_CMD_CHANNEL_REMOVE:
4501 if (OnCmdChannelRemove != null)
4503 break;
4504 case ClientEvent.CLIENTEVENT_CMD_SERVER_UPDATE:
4505 if (OnCmdServerUpdate != null)
4507 break;
4508 case ClientEvent.CLIENTEVENT_CMD_SERVERSTATISTICS :
4509 if (OnCmdServerStatistics != null)
4511 break;
4512 case ClientEvent.CLIENTEVENT_CMD_FILE_NEW:
4513 if (OnCmdFileNew != null)
4515 break;
4516 case ClientEvent.CLIENTEVENT_CMD_FILE_REMOVE:
4517 if (OnCmdFileRemove != null)
4519 break;
4520 case ClientEvent.CLIENTEVENT_CMD_USERACCOUNT :
4521 if (OnCmdUserAccount != null)
4523 break;
4524 case ClientEvent.CLIENTEVENT_CMD_BANNEDUSER :
4525 if (OnCmdBannedUser != null)
4527 break;
4528
4529 case ClientEvent.CLIENTEVENT_USER_STATECHANGE :
4530 if (OnUserStateChange != null)
4532 break;
4533 case ClientEvent.CLIENTEVENT_USER_VIDEOCAPTURE:
4534 if (OnUserVideoCapture != null)
4535 OnUserVideoCapture(msg.nSource, (int)msg.DataToObject());
4536 break;
4537 case ClientEvent.CLIENTEVENT_USER_MEDIAFILE_VIDEO:
4538 if (OnUserMediaFileVideo != null)
4539 OnUserMediaFileVideo((int)msg.nSource, (int)msg.DataToObject());
4540 break;
4541 case ClientEvent.CLIENTEVENT_USER_DESKTOPWINDOW:
4542 if (OnUserDesktopWindow != null)
4543 OnUserDesktopWindow((int)msg.nSource, (int)msg.DataToObject());
4544 break;
4545 case ClientEvent.CLIENTEVENT_USER_DESKTOPCURSOR:
4546 if (OnUserDesktopCursor != null)
4548 break;
4549 case ClientEvent.CLIENTEVENT_USER_DESKTOPINPUT :
4550 if (OnUserDesktopInput != null)
4552 break;
4553 case ClientEvent.CLIENTEVENT_USER_RECORD_MEDIAFILE :
4554 if(OnUserRecordMediaFile != null)
4556 break;
4557 case ClientEvent.CLIENTEVENT_USER_AUDIOBLOCK :
4558 if(OnUserAudioBlock != null)
4560 break;
4561 case ClientEvent.CLIENTEVENT_INTERNAL_ERROR :
4562 if(OnInternalError!= null)
4564 break;
4565 case ClientEvent.CLIENTEVENT_VOICE_ACTIVATION :
4566 if(OnVoiceActivation != null)
4567 OnVoiceActivation((bool)msg.DataToObject());
4568 break;
4569 case ClientEvent.CLIENTEVENT_HOTKEY :
4570 if(OnHotKeyToggle != null)
4571 OnHotKeyToggle(msg.nSource, (bool)msg.DataToObject());
4572 break;
4573 case ClientEvent.CLIENTEVENT_HOTKEY_TEST :
4574 if(OnHotKeyTest != null)
4575 OnHotKeyTest(msg.nSource, (bool)msg.DataToObject());
4576 break;
4577 case ClientEvent.CLIENTEVENT_FILETRANSFER :
4578 if(OnFileTransfer != null)
4580 break;
4581 case ClientEvent.CLIENTEVENT_DESKTOPWINDOW_TRANSFER :
4582 if(OnDesktopWindowTransfer != null)
4584 break;
4585 case ClientEvent.CLIENTEVENT_STREAM_MEDIAFILE :
4586 if(OnStreamMediaFile != null)
4588 break;
4589 case ClientEvent.CLIENTEVENT_LOCAL_MEDIAFILE:
4590 if (OnLocalMediaFile != null)
4592 break;
4593 case ClientEvent.CLIENTEVENT_AUDIOINPUT:
4594 if (OnAudioInput != null)
4596 break;
4597 case ClientEvent.CLIENTEVENT_USER_FIRSTVOICESTREAMPACKET:
4598 if (OnUserFirstVoiceStreamPacket != null)
4600 break;
4601 }
4602 }
4603
4616 public static bool GetDefaultSoundDevices(ref int lpnInputDeviceID,
4617 ref int lpnOutputDeviceID)
4618 {
4619 return TTDLL.TT_GetDefaultSoundDevices(ref lpnInputDeviceID, ref lpnOutputDeviceID);
4620 }
4625 public static bool GetDefaultSoundDevicesEx(SoundSystem nSndSystem,
4626 ref int lpnInputDeviceID,
4627 ref int lpnOutputDeviceID)
4628 {
4629 return TTDLL.TT_GetDefaultSoundDevicesEx(nSndSystem, ref lpnInputDeviceID, ref lpnOutputDeviceID);
4630 }
4639 public static bool GetSoundDevices(out SoundDevice[] lpSoundDevices)
4640 {
4641 int count = 0;
4642 bool b = TTDLL.TT_GetSoundDevices_NULL(IntPtr.Zero, ref count);
4643 SoundDevice[] devs = new SoundDevice[count];
4644 b = TTDLL.TT_GetSoundDevices(devs, ref count);
4645 lpSoundDevices = b ? devs : null;
4646 return b;
4647 }
4663 public static bool RestartSoundSystem()
4664 {
4665 return TTDLL.TT_RestartSoundSystem();
4666 }
4671 public static IntPtr StartSoundLoopbackTest(int nInputDeviceID, int nOutputDeviceID,
4672 int nSampleRate, int nChannels,
4673 bool bDuplexMode, SpeexDSP lpSpeexDSP)
4674 {
4675 return TTDLL.TT_StartSoundLoopbackTest(nInputDeviceID, nOutputDeviceID,
4676 nSampleRate, nChannels, bDuplexMode,
4677 ref lpSpeexDSP);
4678 }
4710 public static IntPtr StartSoundLoopbackTest(int nInputDeviceID, int nOutputDeviceID,
4711 int nSampleRate, int nChannels,
4712 bool bDuplexMode, AudioPreprocessor lpAudioPreprocessor,
4713 BearWare.SoundDeviceEffects lpSoundDeviceEffects)
4714 {
4715 return TTDLL.TT_StartSoundLoopbackTestEx(nInputDeviceID, nOutputDeviceID,
4716 nSampleRate, nChannels, bDuplexMode,
4717 ref lpAudioPreprocessor, ref lpSoundDeviceEffects);
4718 }
4725 public static bool CloseSoundLoopbackTest(IntPtr lpTTSoundLoop)
4726 {
4727 return TTDLL.TT_CloseSoundLoopbackTest(lpTTSoundLoop);
4728 }
4757 public bool InitSoundInputDevice(int nInputDeviceID)
4758 {
4759 return TTDLL.TT_InitSoundInputDevice(m_ttInst, nInputDeviceID);
4760 }
4761
4792 public bool InitSoundInputSharedDevice(int nSampleRate,int nChannels, int nFrameSize)
4793 {
4794 return TTDLL.TT_InitSoundInputSharedDevice(nSampleRate, nChannels, nFrameSize);
4795 }
4796
4825 public bool InitSoundOutputDevice(int nOutputDeviceID)
4826 {
4827 return TTDLL.TT_InitSoundOutputDevice(m_ttInst, nOutputDeviceID);
4828 }
4859 public bool InitSoundOutputSharedDevice(int nSampleRate, int nChannels,int nFrameSize)
4860 {
4861 return TTDLL.TT_InitSoundOutputSharedDevice(nSampleRate, nChannels, nFrameSize);
4862 }
4896 public bool InitSoundDuplexDevices(int nInputDeviceID, int nOutputDeviceID)
4897 {
4898 return TTDLL.TT_InitSoundDuplexDevices(m_ttInst, nInputDeviceID, nOutputDeviceID);
4899 }
4920 {
4921 return TTDLL.TT_CloseSoundInputDevice(m_ttInst);
4922 }
4942 {
4943 return TTDLL.TT_CloseSoundOutputDevice(m_ttInst);
4944 }
4952 {
4953 return TTDLL.TT_CloseSoundDuplexDevices(m_ttInst);
4954 }
4990 public bool SetSoundDeviceEffects(SoundDeviceEffects lpSoundDeviceEffect)
4991 {
4992 return TTDLL.TT_SetSoundDeviceEffects(m_ttInst, ref lpSoundDeviceEffect);
4993 }
4998 public bool GetSoundDeviceEffects(ref SoundDeviceEffects lpSoundDeviceEffect)
4999 {
5000 return TTDLL.TT_GetSoundDeviceEffects(m_ttInst, ref lpSoundDeviceEffect);
5001 }
5019 {
5020 return TTDLL.TT_GetSoundInputLevel(m_ttInst);
5021 }
5037 public bool SetSoundInputGainLevel(int nLevel)
5038 {
5039 return TTDLL.TT_SetSoundInputGainLevel(m_ttInst, nLevel);
5040 }
5048 {
5049 return TTDLL.TT_GetSoundInputGainLevel(m_ttInst);
5050 }
5051
5067 public bool SetSoundInputPreprocess(SpeexDSP lpSpeexDSP)
5068 {
5069 return TTDLL.TT_SetSoundInputPreprocess(m_ttInst, ref lpSpeexDSP);
5070 }
5071
5080 public bool GetSoundInputPreprocess(ref SpeexDSP lpSpeexDSP)
5081 {
5082 return TTDLL.TT_GetSoundInputPreprocess(m_ttInst, ref lpSpeexDSP);
5083 }
5095 public bool SetSoundInputPreprocess(AudioPreprocessor lpAudioPreprocessor)
5096 {
5097 return TTDLL.TT_SetSoundInputPreprocessEx(m_ttInst, ref lpAudioPreprocessor);
5098 }
5099
5107 public bool GetSoundInputPreprocess(ref AudioPreprocessor lpAudioPreprocessor)
5108 {
5109 return TTDLL.TT_GetSoundInputPreprocessEx(m_ttInst, ref lpAudioPreprocessor);
5110 }
5118 public bool SetSoundOutputVolume(int nVolume)
5119 {
5120 return TTDLL.TT_SetSoundOutputVolume(m_ttInst, nVolume);
5121 }
5129 {
5130 return TTDLL.TT_GetSoundOutputVolume(m_ttInst);
5131 }
5139 public bool SetSoundOutputMute(bool bMuteAll)
5140 {
5141 return TTDLL.TT_SetSoundOutputMute(m_ttInst, bMuteAll);
5142 }
5153 public bool Enable3DSoundPositioning(bool bEnable)
5154 {
5155 return TTDLL.TT_Enable3DSoundPositioning(m_ttInst, bEnable);
5156 }
5166 public bool AutoPositionUsers()
5167 {
5168 return TTDLL.TT_AutoPositionUsers(m_ttInst);
5169 }
5170
5234 public bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes,
5235 bool bEnable)
5236 {
5237 return TTDLL.TT_EnableAudioBlockEvent(m_ttInst, nUserID, uStreamTypes, bEnable);
5238 }
5267 public bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes,
5268 AudioFormat lpAudioFormat, bool bEnable)
5269 {
5270 return TTDLL.TT_EnableAudioBlockEventEx(m_ttInst, nUserID, uStreamTypes, ref lpAudioFormat, bEnable);
5271 }
5306 public bool InsertAudioBlock(AudioBlock lpAudioBlock)
5307 {
5308 return TTDLL.TT_InsertAudioBlock(m_ttInst, ref lpAudioBlock);
5309 }
5310
5328 public bool EnableVoiceTransmission(bool bEnable)
5329 {
5330 return TTDLL.TT_EnableVoiceTransmission(m_ttInst, bEnable);
5331 }
5332
5358 public bool EnableVoiceActivation(bool bEnable)
5359 {
5360 return TTDLL.TT_EnableVoiceActivation(m_ttInst, bEnable);
5361 }
5376 public bool SetVoiceActivationLevel(int nLevel)
5377 {
5378 return TTDLL.TT_SetVoiceActivationLevel(m_ttInst, nLevel);
5379 }
5387 {
5388 return TTDLL.TT_GetVoiceActivationLevel(m_ttInst);
5389 }
5402 public bool SetVoiceActivationStopDelay(int nDelayMSec)
5403 {
5404 return TTDLL.TT_SetVoiceActivationStopDelay(m_ttInst, nDelayMSec);
5405 }
5406
5417 {
5418 return TTDLL.TT_GetVoiceActivationStopDelay(m_ttInst);
5419 }
5420
5464 string szAudioFileName,
5465 AudioFileFormat uAFF)
5466 {
5467 return TTDLL.TT_StartRecordingMuxedAudioFile(m_ttInst,
5468 ref lpAudioCodec,
5469 szAudioFileName,
5470 uAFF);
5471 }
5472
5492 public bool StartRecordingMuxedAudioFile(int nChannelID,
5493 string szAudioFileName,
5494 AudioFileFormat uAFF)
5495 {
5496 return TTDLL.TT_StartRecordingMuxedAudioFileEx(m_ttInst,
5497 nChannelID,
5498 szAudioFileName,
5499 uAFF);
5500 }
5501
5502
5534 public bool StartRecordingMuxedStreams(StreamType uStreamTypes,
5535 AudioCodec lpAudioCodec,
5536 string szAudioFileName,
5537 AudioFileFormat uAFF)
5538 {
5539 return TTDLL.TT_StartRecordingMuxedStreams(m_ttInst, uStreamTypes, ref lpAudioCodec, szAudioFileName, uAFF);
5540 }
5541
5554 {
5555 return TTDLL.TT_StopRecordingMuxedAudioFile(m_ttInst);
5556 }
5557
5564 public bool StopRecordingMuxedAudioFile(int nChannelID)
5565 {
5566 return TTDLL.TT_StopRecordingMuxedAudioFileEx(m_ttInst, nChannelID);
5567 }
5568
5592 {
5593 return TTDLL.TT_StartVideoCaptureTransmission(m_ttInst, ref lpVideoCodec);
5594 }
5595
5601 {
5602 return TTDLL.TT_StopVideoCaptureTransmission(m_ttInst);
5603 }
5604
5616 public static bool GetVideoCaptureDevices(out VideoCaptureDevice[] lpVideoDevices)
5617 {
5618 //To speed up query we only query for a max of 25.
5619 //Hopefully no one has more than 25 capture devices.
5620 VideoCaptureDevice[] devs = new VideoCaptureDevice[25];
5621 int count = devs.Length;
5622 bool b = TTDLL.TT_GetVideoCaptureDevices(devs, ref count);
5623 if (b)
5624 {
5625 lpVideoDevices = new VideoCaptureDevice[count];
5626 for (int i = 0; i < count; i++)
5627 lpVideoDevices[i] = devs[i];
5628 }
5629 else lpVideoDevices = null;
5630
5631 return b;
5632 }
5644 public bool InitVideoCaptureDevice(string szDeviceID,
5645 VideoFormat lpVideoFormat)
5646 {
5647 return TTDLL.TT_InitVideoCaptureDevice(m_ttInst, szDeviceID, ref lpVideoFormat);
5648 }
5654 {
5655 return TTDLL.TT_CloseVideoCaptureDevice(m_ttInst);
5656 }
5671 public bool PaintVideoFrame(int nUserID,
5672 System.IntPtr hDC,
5673 int XDest,
5674 int YDest,
5675 int nDestWidth,
5676 int nDestHeight,
5677 ref VideoFrame lpVideoFrame)
5678 {
5679 return TTDLL.TT_PaintVideoFrame(nUserID, hDC, XDest, YDest, nDestWidth,
5680 nDestHeight, ref lpVideoFrame);
5681 }
5682
5714 public bool PaintVideoFrameEx(int nUserID,
5715 System.IntPtr hDC,
5716 int XDest,
5717 int YDest,
5718 int nDestWidth,
5719 int nDestHeight,
5720 int XSrc,
5721 int YSrc,
5722 int nSrcWidth,
5723 int nSrcHeight,
5724 ref VideoFrame lpVideoFrame)
5725 {
5726 return TTDLL.TT_PaintVideoFrameEx(nUserID, hDC, XDest, YDest, nDestWidth, nDestHeight,
5727 XSrc, YSrc, nSrcWidth, nSrcHeight,
5728 ref lpVideoFrame);
5729 }
5730
5749 public VideoFrame AcquireUserVideoCaptureFrame(int nUserID, out Bitmap bmp)
5750 {
5751 bmp = null;
5752 IntPtr ptr = TTDLL.TT_AcquireUserVideoCaptureFrame(m_ttInst, nUserID);
5753 if(ptr == IntPtr.Zero)
5754 return new VideoFrame();
5755
5756 VideoFrame frm = (VideoFrame)Marshal.PtrToStructure(ptr, typeof(VideoFrame));
5757 vidcapframes.Add(frm.frameBuffer, ptr);
5758
5759 PixelFormat pixelformat = PixelFormat.Format32bppRgb;
5760 bmp = new Bitmap(frm.nWidth, frm.nHeight, frm.nWidth*4, pixelformat, frm.frameBuffer);
5761 return frm;
5762 }
5763
5764 Dictionary<IntPtr, IntPtr> vidcapframes = new Dictionary<IntPtr, IntPtr>();
5765
5774 {
5775 IntPtr ptr;
5776 if (vidcapframes.TryGetValue(lpVideoFrame.frameBuffer, out ptr))
5777 {
5778 vidcapframes.Remove(lpVideoFrame.frameBuffer);
5779 return TTDLL.TT_ReleaseUserVideoCaptureFrame(m_ttInst, ptr);
5780 }
5781 return false;
5782 }
5783
5796 /*
5797 public bool GetUserVideoFrame(int nUserID,
5798 ref System.Drawing.Bitmap lpPicture)
5799 {
5800 CaptureFormat cap;
5801 if (!TTDLL.TT_GetUserVideoFrame(m_ttInst, nUserID, IntPtr.Zero, 0, out cap))
5802 return false;
5803
5804 PixelFormat pixelformat = PixelFormat.Format32bppRgb;
5805
5806 if (lpPicture == null ||
5807 lpPicture.Width != cap.nWidth ||
5808 lpPicture.Height != cap.nHeight
5809#if PocketPC
5810 )
5811#else
5812 || lpPicture.PixelFormat != pixelformat)
5813#endif
5814 {
5815 lpPicture = new Bitmap(cap.nWidth, cap.nHeight,
5816 pixelformat);
5817 }
5818
5819 // Lock the bitmap's bits.
5820 System.Drawing.Rectangle rect = new System.Drawing.Rectangle(0, 0, lpPicture.Width, lpPicture.Height);
5821 BitmapData bmpData = lpPicture.LockBits(rect, ImageLockMode.ReadWrite, pixelformat);
5822
5823 // Get the address of the first line.
5824 IntPtr ptr = bmpData.Scan0;
5825
5826 bool b = TTDLL.TT_GetUserVideoFrame(m_ttInst, nUserID, ptr,
5827 cap.nWidth * cap.nHeight * 4, out cap);
5828 // Unlock the bits.
5829 lpPicture.UnlockBits(bmpData);
5830 return b;
5831 }
5832 * */
5833
5841 public bool StartStreamingMediaFileToChannel(string szMediaFilePath,
5842 VideoCodec lpVideoCodec)
5843 {
5844 return TTDLL.TT_StartStreamingMediaFileToChannel(m_ttInst, szMediaFilePath,
5845 ref lpVideoCodec);
5846 }
5847
5877 public bool StartStreamingMediaFileToChannel(string szMediaFilePath,
5878 MediaFilePlayback lpMediaFilePlayback,
5879 VideoCodec lpVideoCodec)
5880 {
5881 return TTDLL.TT_StartStreamingMediaFileToChannelEx(m_ttInst, szMediaFilePath,
5882 ref lpMediaFilePlayback,
5883 ref lpVideoCodec);
5884 }
5885
5903 VideoCodec lpVideoCodec)
5904 {
5905 return TTDLL.TT_UpdateStreamingMediaFileToChannel(m_ttInst, ref lpMediaFilePlayback, ref lpVideoCodec);
5906 }
5907
5916 {
5917 return TTDLL.TT_StopStreamingMediaFileToChannel(m_ttInst);
5918 }
5919
5944 public int InitLocalPlayback(string szMediaFilePath, MediaFilePlayback lpMediaFilePlayback)
5945 {
5946 return TTDLL.TT_InitLocalPlayback(m_ttInst, szMediaFilePath, ref lpMediaFilePlayback);
5947 }
5948
5960 public bool UpdateLocalPlayback(int nPlaybackSessionID,
5961 MediaFilePlayback lpMediaFilePlayback)
5962 {
5963 return TTDLL.TT_UpdateLocalPlayback(m_ttInst, nPlaybackSessionID, ref lpMediaFilePlayback);
5964 }
5965
5974 public bool StopLocalPlayback(int nPlaybackSessionID)
5975 {
5976 return TTDLL.TT_StopLocalPlayback(m_ttInst, nPlaybackSessionID);
5977 }
5978
5986 public static bool GetMediaFileInfo(string szMediaFilePath,
5987 ref MediaFileInfo lpMediaFileInfo)
5988 {
5989 return TTDLL.TT_GetMediaFileInfo(szMediaFilePath, ref lpMediaFileInfo);
5990 }
5991
6011 public VideoFrame AcquireUserMediaVideoFrame(int nUserID, out Bitmap bmp)
6012 {
6013 bmp = null;
6014 IntPtr ptr = TTDLL.TT_AcquireUserMediaVideoFrame(m_ttInst, nUserID);
6015 if (ptr == IntPtr.Zero)
6016 return new VideoFrame();
6017
6018 VideoFrame frm = (VideoFrame)Marshal.PtrToStructure(ptr, typeof(VideoFrame));
6019 mediaframes.Add(frm.frameBuffer, ptr);
6020
6021 PixelFormat pixelformat = PixelFormat.Format32bppRgb;
6022 bmp = new Bitmap(frm.nWidth, frm.nHeight, frm.nWidth * 4, pixelformat, frm.frameBuffer);
6023 return frm;
6024 }
6025
6033 public bool ReleaseUserMediaVideoFrame(VideoFrame lpVideoFrame)
6034 {
6035 IntPtr ptr;
6036 if (mediaframes.TryGetValue(lpVideoFrame.frameBuffer, out ptr))
6037 {
6038 mediaframes.Remove(lpVideoFrame.frameBuffer);
6039 return TTDLL.TT_ReleaseUserMediaVideoFrame(m_ttInst, ptr);
6040 }
6041 return false;
6042 }
6043
6044 Dictionary<IntPtr, IntPtr> mediaframes = new Dictionary<IntPtr, IntPtr>();
6045
6088 public int SendDesktopWindow(DesktopWindow lpDesktopWindow,
6089 BitmapFormat nConvertBmpFormat)
6090 {
6091 return TTDLL.TT_SendDesktopWindow(m_ttInst, ref lpDesktopWindow, nConvertBmpFormat);
6092 }
6093
6102 {
6103 return TTDLL.TT_CloseDesktopWindow(m_ttInst);
6104 }
6105
6122 public static System.Drawing.Color Palette_GetColorTable(BitmapFormat nBmpPalette,
6123 int nIndex)
6124 {
6125 IntPtr ptr = TTDLL.TT_Palette_GetColorTable(nBmpPalette, nIndex);
6126 switch(nBmpPalette)
6127 {
6128 case BitmapFormat.BMP_RGB8_PALETTE:
6129 return Color.FromArgb(Marshal.ReadInt32(ptr));
6130 }
6131 return new Color();
6132 }
6133
6144 public int SendDesktopWindowFromHWND(System.IntPtr hWnd,
6145 BitmapFormat nBitmapFormat,
6146 DesktopProtocol nDesktopProtocol)
6147 {
6148 return TTDLL.TT_SendDesktopWindowFromHWND(m_ttInst, hWnd, nBitmapFormat, nDesktopProtocol);
6149 }
6150
6165 public bool PaintDesktopWindow(int nUserID,
6166 System.IntPtr hDC,
6167 int XDest,
6168 int YDest,
6169 int nDestWidth,
6170 int nDestHeight)
6171 {
6172 return TTDLL.TT_PaintDesktopWindow(m_ttInst, nUserID, hDC, XDest, YDest, nDestWidth, nDestHeight);
6173 }
6174
6207 public bool PaintDesktopWindowEx(int nUserID,
6208 System.IntPtr hDC,
6209 int XDest,
6210 int YDest,
6211 int nDestWidth,
6212 int nDestHeight,
6213 int XSrc,
6214 int YSrc,
6215 int nSrcWidth,
6216 int nSrcHeight)
6217 {
6218 return TTDLL.TT_PaintDesktopWindowEx(m_ttInst, nUserID, hDC, XDest,
6219 YDest, nDestWidth, nDestHeight,
6220 XSrc, YSrc, nSrcWidth, nSrcHeight);
6221 }
6222
6235 public bool SendDesktopCursorPosition(ushort nPosX,
6236 ushort nPosY)
6237 {
6238 return TTDLL.TT_SendDesktopCursorPosition(m_ttInst, nPosX, nPosY);
6239 }
6240
6264 public bool SendDesktopInput(int nUserID,
6265 DesktopInput[] lpDesktopInputs)
6266 {
6267 return TTDLL.TT_SendDesktopInput(m_ttInst, nUserID, lpDesktopInputs, lpDesktopInputs.Length);
6268 }
6269
6294 {
6295 IntPtr ptr = TTDLL.TT_AcquireUserDesktopWindow(m_ttInst, nUserID);
6296 if (ptr == IntPtr.Zero)
6297 return new DesktopWindow();
6298 DesktopWindow lpDesktopWindow = (DesktopWindow)Marshal.PtrToStructure(ptr, typeof(DesktopWindow));
6299 desktopwindows.Add(lpDesktopWindow.frameBuffer, ptr);
6300 return lpDesktopWindow;
6301 }
6302
6309 public DesktopWindow AcquireUserDesktopWindowEx(int nUserID, BitmapFormat nBitmapFormat)
6310 {
6311 IntPtr ptr = TTDLL.TT_AcquireUserDesktopWindowEx(m_ttInst, nUserID, nBitmapFormat);
6312 if (ptr == IntPtr.Zero)
6313 return new DesktopWindow();
6314 DesktopWindow lpDesktopWindow = (DesktopWindow)Marshal.PtrToStructure(ptr, typeof(DesktopWindow));
6315 desktopwindows.Add(lpDesktopWindow.frameBuffer, ptr);
6316 return lpDesktopWindow;
6317 }
6318
6319 Dictionary<IntPtr, IntPtr> desktopwindows = new Dictionary<IntPtr, IntPtr>();
6322 public bool ReleaseUserDesktopWindow(DesktopWindow lpDesktopWindow)
6323 {
6324 IntPtr ptr;
6325 if (desktopwindows.TryGetValue(lpDesktopWindow.frameBuffer, out ptr))
6326 {
6327 desktopwindows.Remove(lpDesktopWindow.frameBuffer);
6328 return TTDLL.TT_ReleaseUserDesktopWindow(m_ttInst, ptr);
6329 }
6330 return false;
6331 }
6332
6349 public bool SetEncryptionContext(EncryptionContext lpEncryptionContext)
6350 {
6351 return TTDLL.TT_SetEncryptionContext(m_ttInst, ref lpEncryptionContext);
6352 }
6353
6382 public bool Connect(string szHostAddress,
6383 int nTcpPort,
6384 int nUdpPort,
6385 int nLocalTcpPort,
6386 int nLocalUdpPort,
6387 bool bEncrypted)
6388 {
6389 return TTDLL.TT_Connect(m_ttInst, szHostAddress, nTcpPort, nUdpPort,
6390 nLocalTcpPort, nLocalUdpPort, bEncrypted);
6391 }
6392
6416 public bool ConnectSysID(string szHostAddress,
6417 int nTcpPort,
6418 int nUdpPort,
6419 int nLocalTcpPort,
6420 int nLocalUdpPort,
6421 bool bEncrypted,
6422 string szSystemID)
6423 {
6424 return TTDLL.TT_ConnectSysID(m_ttInst, szHostAddress,
6425 nTcpPort, nUdpPort, nLocalTcpPort,
6426 nLocalUdpPort, bEncrypted, szSystemID);
6427 }
6428
6449 public bool ConnectEx(string szHostAddress,
6450 int nTcpPort,
6451 int nUdpPort,
6452 string szBindIPAddr,
6453 int nLocalTcpPort,
6454 int nLocalUdpPort,
6455 bool bEncrypted)
6456 {
6457 return TTDLL.TT_ConnectEx(m_ttInst, szHostAddress, nTcpPort, nUdpPort,
6458 szBindIPAddr, nLocalTcpPort, nLocalUdpPort,
6459 bEncrypted);
6460 }
6461
6466 public bool Disconnect()
6467 {
6468 return TTDLL.TT_Disconnect(m_ttInst);
6469 }
6479 public bool QueryMaxPayload(int nUserID)
6480 {
6481 return TTDLL.TT_QueryMaxPayload(m_ttInst, nUserID);
6482 }
6488 public bool GetClientStatistics(ref ClientStatistics lpClientStatistics)
6489 {
6490 return TTDLL.TT_GetClientStatistics(m_ttInst, ref lpClientStatistics);
6491 }
6492
6507 public bool SetClientKeepAlive(ClientKeepAlive lpClientKeepAlive)
6508 {
6509 return TTDLL.TT_SetClientKeepAlive(m_ttInst, ref lpClientKeepAlive);
6510 }
6511
6518 public bool GetClientKeepAlive(ref ClientKeepAlive lpClientKeepAlive)
6519 {
6520 return TTDLL.TT_GetClientKeepAlive(m_ttInst, ref lpClientKeepAlive);
6521 }
6544 public int DoPing()
6545 {
6546 return TTDLL.TT_DoPing(m_ttInst);
6547 }
6548
6560 public int DoLogin(string szNickname, string szUsername, string szPassword)
6561 {
6562 return TTDLL.TT_DoLogin(m_ttInst, szNickname, szUsername, szPassword);
6563 }
6564
6594 public int DoLoginEx(string szNickname, string szUsername, string szPassword,
6595 string szClientName)
6596 {
6597 return TTDLL.TT_DoLoginEx(m_ttInst, szNickname, szUsername, szPassword, szClientName);
6598 }
6612 public int DoLogout()
6613 {
6614 return TTDLL.TT_DoLogout(m_ttInst);
6615 }
6655 public int DoJoinChannel(Channel lpChannel)
6656 {
6657 return TTDLL.TT_DoJoinChannel(m_ttInst, ref lpChannel);
6658 }
6682 public int DoJoinChannelByID(int nChannelID, string szPassword)
6683 {
6684 return TTDLL.TT_DoJoinChannelByID(m_ttInst, nChannelID, szPassword);
6685 }
6705 public int DoLeaveChannel()
6706 {
6707 return TTDLL.TT_DoLeaveChannel(m_ttInst);
6708 }
6726 public int DoChangeNickname(string szNewNick)
6727 {
6728 return TTDLL.TT_DoChangeNickname(m_ttInst, szNewNick);
6729 }
6749 public int DoChangeStatus(int nStatusMode, string szStatusMessage)
6750 {
6751 return TTDLL.TT_DoChangeStatus(m_ttInst, nStatusMode, szStatusMessage);
6752 }
6771 public int DoTextMessage(TextMessage lpTextMessage)
6772 {
6773 return TTDLL.TT_DoTextMessage(m_ttInst, ref lpTextMessage);
6774 }
6795 public int DoChannelOp(int nUserID, int nChannelID, bool bMakeOperator)
6796 {
6797 return TTDLL.TT_DoChannelOp(m_ttInst, nUserID, nChannelID, bMakeOperator);
6798 }
6818 public int DoChannelOpEx(int nUserID,
6819 int nChannelID,
6820 string szOpPassword,
6821 bool bMakeOperator)
6822 {
6823 return TTDLL.TT_DoChannelOpEx(m_ttInst, nUserID, nChannelID, szOpPassword, bMakeOperator);
6824 }
6847 public int DoKickUser(int nUserID, int nChannelID)
6848 {
6849 return TTDLL.TT_DoKickUser(m_ttInst, nUserID, nChannelID);
6850 }
6885 public int DoSendFile(int nChannelID, string szLocalFilePath)
6886 {
6887 return TTDLL.TT_DoSendFile(m_ttInst, nChannelID, szLocalFilePath);
6888 }
6918 public int DoRecvFile(int nChannelID, int nFileID, string szLocalFilePath)
6919 {
6920 return TTDLL.TT_DoRecvFile(m_ttInst, nChannelID, nFileID, szLocalFilePath);
6921 }
6944 public int DoDeleteFile(int nChannelID, int nFileID)
6945 {
6946 return TTDLL.TT_DoDeleteFile(m_ttInst, nChannelID, nFileID);
6947 }
6962 public int DoSubscribe(int nUserID, Subscription uSubscriptions)
6963 {
6964 return TTDLL.TT_DoSubscribe(m_ttInst, nUserID, uSubscriptions);
6965 }
6981 public int DoUnsubscribe(int nUserID, Subscription uSubscriptions)
6982 {
6983 return TTDLL.TT_DoUnsubscribe(m_ttInst, nUserID, uSubscriptions);
6984 }
7010 public int DoMakeChannel(Channel lpChannel)
7011 {
7012 return TTDLL.TT_DoMakeChannel(m_ttInst, ref lpChannel);
7013 }
7046 public int DoUpdateChannel(Channel lpChannel)
7047 {
7048 return TTDLL.TT_DoUpdateChannel(m_ttInst, ref lpChannel);
7049 }
7068 public int DoRemoveChannel(int nChannelID)
7069 {
7070 return TTDLL.TT_DoRemoveChannel(m_ttInst, nChannelID);
7071 }
7091 public int DoMoveUser(int nUserID, int nChannelID)
7092 {
7093 return TTDLL.TT_DoMoveUser(m_ttInst, nUserID, nChannelID);
7094 }
7111 public int DoUpdateServer(ServerProperties lpServerProperties)
7112 {
7113 return TTDLL.TT_DoUpdateServer(m_ttInst, ref lpServerProperties);
7114 }
7139 public int DoListUserAccounts(int nIndex, int nCount)
7140 {
7141 return TTDLL.TT_DoListUserAccounts(m_ttInst, nIndex, nCount);
7142 }
7165 public int DoNewUserAccount(UserAccount lpUserAccount)
7166 {
7167 return TTDLL.TT_DoNewUserAccount(m_ttInst, ref lpUserAccount);
7168 }
7187 public int DoDeleteUserAccount(string szUsername)
7188 {
7189 return TTDLL.TT_DoDeleteUserAccount(m_ttInst, szUsername);
7190 }
7218 public int DoBanUser(int nUserID, int nChannelID)
7219 {
7220 return TTDLL.TT_DoBanUser(m_ttInst, nUserID, nChannelID);
7221 }
7222
7234 public int DoBanUserEx(int nUserID, BanType uBanTypes)
7235 {
7236 return TTDLL.TT_DoBanUserEx(m_ttInst, nUserID, uBanTypes);
7237 }
7238
7257 public int DoBan(BannedUser lpBannedUser)
7258 {
7259 return TTDLL.TT_DoBan(m_ttInst, ref lpBannedUser);
7260 }
7261
7282 public int DoBanIPAddress(string szIPAddress, int nChannelID)
7283 {
7284 return TTDLL.TT_DoBanIPAddress(m_ttInst, szIPAddress, nChannelID);
7285 }
7286
7307 public int DoUnBanUser(string szIPAddress, int nChannelID)
7308 {
7309 return TTDLL.TT_DoUnBanUser(m_ttInst, szIPAddress, nChannelID);
7310 }
7311
7321 public int DoUnBanUserEx(BannedUser lpBannedUser)
7322 {
7323 return TTDLL.TT_DoUnBanUserEx(m_ttInst, ref lpBannedUser);
7324 }
7325
7346 public int DoListBans(int nChannelID, int nIndex, int nCount)
7347 {
7348 return TTDLL.TT_DoListBans(m_ttInst, nChannelID, nIndex, nCount);
7349 }
7367 public int DoSaveConfig()
7368 {
7369 return TTDLL.TT_DoSaveConfig(m_ttInst);
7370 }
7388 {
7389 return TTDLL.TT_DoQueryServerStats(m_ttInst);
7390 }
7403 public int DoQuit()
7404 {
7405 return TTDLL.TT_DoQuit(m_ttInst);
7406 }
7418 public bool GetServerProperties(ref ServerProperties lpServerProperties)
7419 {
7420 return TTDLL.TT_GetServerProperties(m_ttInst, ref lpServerProperties);
7421 }
7432 public bool GetServerUsers(out User[] lpUsers)
7433 {
7434 int count = 0;
7435 bool b = TTDLL.TT_GetServerUsers_NULL(m_ttInst, IntPtr.Zero, ref count);
7436 User[] users = new User[count];
7437 b = TTDLL.TT_GetServerUsers(m_ttInst, users, ref count);
7438 lpUsers = b ? users : null;
7439 return b;
7440 }
7453 public int GetRootChannelID()
7454 {
7455 return TTDLL.TT_GetRootChannelID(m_ttInst);
7456 }
7463 public int GetMyChannelID()
7464 {
7465 return TTDLL.TT_GetMyChannelID(m_ttInst);
7466 }
7470 public int ChannelID { get { return GetMyChannelID(); } }
7478 public bool GetChannel(int nChannelID, ref Channel lpChannel)
7479 {
7480 return TTDLL.TT_GetChannel(m_ttInst, nChannelID, ref lpChannel);
7481 }
7488 public bool GetChannelPath(int nChannelID, ref string szChannelPath)
7489 {
7490 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
7491 bool b = TTDLL.TT_GetChannelPath(m_ttInst, nChannelID, ptr);
7492 if(b)
7493 szChannelPath = Marshal.PtrToStringUni(ptr);
7494 Marshal.FreeHGlobal(ptr);
7495 return b;
7496 }
7503 public int GetChannelIDFromPath(string szChannelPath)
7504 {
7505 return TTDLL.TT_GetChannelIDFromPath(m_ttInst, szChannelPath);
7506 }
7515 public bool GetChannelUsers(int nChannelID, out User[] lpUsers)
7516 {
7517 int count = 0;
7518 bool b = TTDLL.TT_GetChannelUsers_NULL(m_ttInst, nChannelID, IntPtr.Zero, ref count);
7519 User[] users = new User[count];
7520 b = TTDLL.TT_GetChannelUsers(m_ttInst, nChannelID, users, ref count);
7521 lpUsers = b ? users : null;
7522 return b;
7523 }
7532 public bool GetChannelFiles(int nChannelID, out RemoteFile[] lpRemoteFiles)
7533 {
7534 int count = 0;
7535 bool b = TTDLL.TT_GetChannelFiles_NULL(m_ttInst, nChannelID, IntPtr.Zero, ref count);
7536 RemoteFile[] files = new RemoteFile[count];
7537 b = TTDLL.TT_GetChannelFiles(m_ttInst, nChannelID, files, ref count);
7538 lpRemoteFiles = b ? files : null;
7539 return b;
7540 }
7548 public bool GetChannelFile(int nChannelID, int nFileID, ref RemoteFile lpRemoteFile)
7549 {
7550 return TTDLL.TT_GetChannelFile(m_ttInst, nChannelID, nFileID, ref lpRemoteFile);
7551 }
7558 public bool IsChannelOperator(int nUserID, int nChannelID)
7559 {
7560 return TTDLL.TT_IsChannelOperator(m_ttInst, nUserID, nChannelID);
7561 }
7568 public bool GetServerChannels(out Channel[] lpChannels)
7569 {
7570 int count = 0;
7571 bool b = TTDLL.TT_GetServerChannels_NULL(m_ttInst, IntPtr.Zero, ref count);
7572 Channel[] channels = new Channel[count];
7573 b = TTDLL.TT_GetServerChannels(m_ttInst, channels, ref count);
7574 lpChannels = b ? channels : null;
7575 return b;
7576 }
7590 public int GetMyUserID()
7591 {
7592 return TTDLL.TT_GetMyUserID(m_ttInst);
7593 }
7594
7605 public bool GetMyUserAccount(ref UserAccount lpUserAccount)
7606 {
7607 return TTDLL.TT_GetMyUserAccount(m_ttInst, ref lpUserAccount);
7608 }
7609
7613 public int UserID { get { return GetMyUserID(); } }
7614
7626 {
7627 return TTDLL.TT_GetMyUserType(m_ttInst);
7628 }
7629
7633 public BearWare.UserType UserType { get { return GetMyUserType(); } }
7634
7638 public BearWare.UserRight UserRights { get { return GetMyUserRights(); } }
7639
7641 public BearWare.UserRight GetMyUserRights()
7642 {
7643 return TTDLL.TT_GetMyUserRights(m_ttInst);
7644 }
7645
7655 public int GetMyUserData()
7656 {
7657 return TTDLL.TT_GetMyUserData(m_ttInst);
7658 }
7659
7663 public int UserData { get { return GetMyUserData(); } }
7664
7671 public bool GetUser(int nUserID, ref User lpUser)
7672 {
7673 return TTDLL.TT_GetUser(m_ttInst, nUserID, ref lpUser);
7674 }
7680 public bool GetUserStatistics(int nUserID, ref UserStatistics lpUserStatistics)
7681 {
7682 return TTDLL.TT_GetUserStatistics(m_ttInst, nUserID, ref lpUserStatistics);
7683 }
7692 public bool GetUserByUsername(string szUsername, ref User lpUser)
7693 {
7694 return TTDLL.TT_GetUserByUsername(m_ttInst, szUsername, ref lpUser);
7695 }
7712 public bool SetUserVolume(int nUserID, StreamType nStreamType, int nVolume)
7713 {
7714 return TTDLL.TT_SetUserVolume(m_ttInst, nUserID, nStreamType, nVolume);
7715 }
7727 public bool SetUserMute(int nUserID, StreamType nStreamType, bool bMute)
7728 {
7729 return TTDLL.TT_SetUserMute(m_ttInst, nUserID, nStreamType, bMute);
7730 }
7743 public bool SetUserStoppedPlaybackDelay(int nUserID,
7744 StreamType nStreamType,
7745 int nDelayMSec)
7746 {
7747 return TTDLL.TT_SetUserStoppedPlaybackDelay(m_ttInst, nUserID, nStreamType, nDelayMSec);
7748 }
7749
7774 public bool SetUserJitterControl(int nUserID,
7775 StreamType nStreamType,
7776 JitterConfig lpJitterConfig)
7777 {
7778 return TTDLL.TT_SetUserJitterControl(m_ttInst, nUserID, nStreamType, ref lpJitterConfig);
7779 }
7780
7791 public bool GetUserJitterControl(int nUserID,
7792 StreamType nStreamType,
7793 ref JitterConfig lpJitterConfig)
7794 {
7795 return TTDLL.TT_GetUserJitterControl(m_ttInst, nUserID, nStreamType, ref lpJitterConfig);
7796 }
7797
7813 public bool SetUserPosition(int nUserID, StreamType nStreamType,
7814 float x, float y, float z)
7815 {
7816 return TTDLL.TT_SetUserPosition(m_ttInst, nUserID, nStreamType, x, y, z);
7817 }
7829 public bool SetUserStereo(int nUserID, StreamType nStreamType, bool bLeftSpeaker, bool bRightSpeaker)
7830 {
7831 return TTDLL.TT_SetUserStereo(m_ttInst, nUserID, nStreamType, bLeftSpeaker, bRightSpeaker);
7832 }
7868 public bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars,
7869 AudioFileFormat uAFF)
7870 {
7871 return TTDLL.TT_SetUserMediaStorageDir(m_ttInst, nUserID, szFolderPath, szFileNameVars, uAFF);
7872 }
7873
7898 public bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars,
7899 AudioFileFormat uAFF, int nStopRecordingExtraDelayMSec)
7900 {
7901 return TTDLL.TT_SetUserMediaStorageDirEx(m_ttInst, nUserID, szFolderPath, szFileNameVars, uAFF, nStopRecordingExtraDelayMSec);
7902 }
7903
7928 public bool SetUserAudioStreamBufferSize(int nUserID, StreamType uStreamType,
7929 int nMSec)
7930 {
7931 return TTDLL.TT_SetUserAudioStreamBufferSize(m_ttInst, nUserID, uStreamType, nMSec);
7932 }
7952 public AudioBlock AcquireUserAudioBlock(StreamType uStreamTypes, int nUserID)
7953 {
7954 IntPtr ptr = TTDLL.TT_AcquireUserAudioBlock(m_ttInst, uStreamTypes, nUserID);
7955 if (ptr == IntPtr.Zero)
7956 return new AudioBlock();
7957 AudioBlock lpAudioBlock = (AudioBlock)Marshal.PtrToStructure(ptr, typeof(AudioBlock));
7958 audioblocks.Add(lpAudioBlock.lpRawAudio, ptr);
7959 return lpAudioBlock;
7960 }
7961
7962 Dictionary<IntPtr, IntPtr> audioblocks = new Dictionary<IntPtr, IntPtr>();
7963
7977 public bool ReleaseUserAudioBlock(AudioBlock lpAudioBlock)
7978 {
7979 IntPtr ptr;
7980 if (audioblocks.TryGetValue(lpAudioBlock.lpRawAudio, out ptr))
7981 {
7982 audioblocks.Remove(lpAudioBlock.lpRawAudio);
7983 return TTDLL.TT_ReleaseUserAudioBlock(m_ttInst, ptr);
7984 }
7985 return false;
7986 }
8000 public bool GetFileTransferInfo(int nTransferID, ref FileTransfer lpFileTransfer)
8001 {
8002 return TTDLL.TT_GetFileTransferInfo(m_ttInst, nTransferID, ref lpFileTransfer);
8003 }
8004
8013 public bool CancelFileTranfer(int nTransferID)
8014 {
8015 return TTDLL.TT_CancelFileTransfer(m_ttInst, nTransferID);
8016 }
8017
8028 public static string GetErrorMessage(ClientError nError)
8029 {
8030 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8031 TTDLL.TT_GetErrorMessage((int)nError, ptr);
8032 string s = Marshal.PtrToStringUni(ptr);
8033 Marshal.FreeHGlobal(ptr);
8034 return s;
8035 }
8036
8063 public bool HotKey_Register(int nHotKeyID, int[] lpnVKCodes)
8064 {
8065 return TTDLL.TT_HotKey_Register(m_ttInst, nHotKeyID, lpnVKCodes, lpnVKCodes.Length);
8066 }
8072 public bool HotKey_Unregister(int nHotKeyID)
8073 {
8074 return TTDLL.TT_HotKey_Unregister(m_ttInst, nHotKeyID);
8075 }
8081 public int HotKey_IsActive(int nHotKeyID)
8082 {
8083 return TTDLL.TT_HotKey_IsActive(m_ttInst, nHotKeyID);
8084 }
8095 {
8096 if (m_eventhandler != null)
8097 {
8098#if PocketPC
8099 IntPtr hWnd = m_eventhandler.Hwnd;
8100#else
8101 IntPtr hWnd = m_eventhandler.Handle;
8102#endif
8103 return TTDLL.TT_HotKey_InstallTestHook(m_ttInst, hWnd,
8104 MyEventHandler.WM_TEAMTALK_CLIENTEVENT);
8105 }
8106 return false;
8107 }
8114 {
8115 return TTDLL.TT_HotKey_RemoveTestHook(m_ttInst);
8116 }
8123 public bool HotKey_GetKeyString(int nVKCode, ref string szKeyName)
8124 {
8125 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8126 bool b = TTDLL.TT_HotKey_GetKeyString(m_ttInst, nVKCode, ptr);
8127 if(b)
8128 szKeyName = Marshal.PtrToStringUni(ptr);
8129 Marshal.FreeHGlobal(ptr);
8130 return b;
8131 }
8134 public bool DBG_SetSoundInputTone(StreamType uStreamTypes, int nFrequency)
8135 {
8136 return TTDLL.TT_DBG_SetSoundInputTone(m_ttInst, uStreamTypes, nFrequency);
8137 }
8138
8139
8140 public bool DBG_WriteAudioFileTone(MediaFileInfo lpMediaFileInfo,
8141 int nFrequency)
8142 {
8143 return TTDLL.TT_DBG_WriteAudioFileTone(ref lpMediaFileInfo, nFrequency);
8144 }
8145
8152 public delegate void Connection();
8178
8184 public delegate void MaxPayloadUpdate(int nPayloadSize);
8185
8194
8202 public delegate void CommandProcessing(int nCmdID, bool bActive);
8203
8215
8220 public delegate void CommandError(int nCmdID, ClientErrorMsg clienterrormsg);
8221
8231
8235 public delegate void CommandSuccess(int nCmdID);
8236
8245
8251 public delegate void MyselfLoggedIn(int nMyUserID, UserAccount useraccount);
8252
8262
8264 public delegate void MyselfLoggedOut();
8273
8279 public delegate void MyselfKicked(User user);
8286
8291 public delegate void UserUpdate(User user);
8292
8296 public delegate void UserStreamUpdate(User user, int nStreamID);
8297
8306
8316
8322
8328
8334
8340 public delegate void UserTextMessage(TextMessage textmessage);
8341
8347
8348
8351 public delegate void ChannelUpdate(Channel channel);
8352
8360
8366
8371
8373 public delegate void ServerUpdate(ServerProperties serverproperties);
8374
8381
8383 public delegate void ServerStats(ServerStatistics serverstatistics);
8384
8390
8392 public delegate void FileUpdate(RemoteFile remotefile);
8393
8399
8405
8407 public delegate void ListUserAccount(UserAccount useraccount);
8408
8412
8414 public delegate void ListBannedUser(BannedUser banneduser);
8415
8419
8425
8430
8432 public delegate void UserVideoFrame(int nUserID, int nStreamID);
8433
8439
8445
8454 public delegate void NewDesktopWindow(int nUserID, int nStreamID);
8455
8465
8467 public delegate void UserDesktopInput(int nSrcUserID, DesktopInput desktopinput);
8468
8475
8482
8484 public delegate void UserRecordMediaFile(int nUserID, MediaFileInfo mediafileinfo);
8485
8491
8493 public delegate void NewAudioBlock(int nUserID, StreamType nStreamType);
8494
8505
8507 public delegate void ErrorOccured(ClientErrorMsg clienterrormsg);
8508
8514
8517 public delegate void VoiceActivation(bool bVoiceActive);
8518
8524
8530 public delegate void HotKeyToggle(int nHotKeyID, bool bActive);
8531
8541
8546 public delegate void HotKeyTest(int nVkCode, bool bActive);
8547
8565
8569 public delegate void FileTransferUpdate(FileTransfer filetransfer);
8570
8583
8593 public delegate void DesktopTransferUpdate(int nSessionID, int nBytesRemain);
8594
8605
8607 public delegate void StreamMediaFile(MediaFileInfo mediafileinfo);
8608
8614
8616 public delegate void LocalMediaFile(MediaFileInfo mediafileinfo);
8617
8623
8625 public delegate void AudioInput(AudioInputProgress aip);
8626
8632
8635 //TTDLL instance
8636 private IntPtr m_ttInst;
8637 //TTDLL event handler
8638 c_tt.MyEventHandler m_eventhandler;
8639 }
8640
8650 {
8651 public const int DEFAULT_TCPPORT = 10333;
8652 public const int DEFAULT_UDPPORT = 10333;
8653
8655 public TeamTalk5(bool poll_based)
8656 : base(poll_based)
8657 {
8658 }
8659 }
8660
8667 {
8668 public const int DEFAULT_TCPPORT = 10443;
8669 public const int DEFAULT_UDPPORT = 10443;
8670
8672 public TeamTalk5Pro(bool poll_based)
8673 : base(poll_based)
8674 {
8675 }
8676 }
8685 public enum TTKeyTranslate : uint
8686 {
8702 }
8703
8725 public enum MixerControl : uint
8726 {
8730
8734 }
8735
8739 public class WindowsMixer
8740 {
8747 public static int GetMixerCount()
8748 {
8749 return TTDLL.TT_Mixer_GetMixerCount();
8750 }
8757 public static bool GetMixerName(int nMixerIndex,
8758 ref string szMixerName)
8759 {
8760 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8761 bool b = TTDLL.TT_Mixer_GetMixerName(nMixerIndex, ptr);
8762 if(b)
8763 szMixerName = Marshal.PtrToStringUni(ptr);
8764
8765 Marshal.FreeHGlobal(ptr);
8766 return b;
8767 }
8775 public static bool GetWaveInName(int nWaveDeviceID,
8776 ref string szMixerName)
8777 {
8778 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8779 bool b = TTDLL.TT_Mixer_GetWaveInName(nWaveDeviceID, ptr);
8780 if(b)
8781 szMixerName = Marshal.PtrToStringUni(ptr);
8782 Marshal.FreeHGlobal(ptr);
8783 return b;
8784 }
8792 public static bool GetWaveOutName(int nWaveDeviceID,
8793 ref string szMixerName)
8794 {
8795 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8796 bool b = TTDLL.TT_Mixer_GetWaveOutName(nWaveDeviceID, ptr);
8797 if(b)
8798 szMixerName = Marshal.PtrToStringUni(ptr);
8799
8800 Marshal.FreeHGlobal(ptr);
8801 return b;
8802 }
8803
8814 public static bool SetWaveOutMute(int nWaveDeviceID, MixerControl nControl, bool bMute)
8815 {
8816 return TTDLL.TT_Mixer_SetWaveOutMute(nWaveDeviceID, nControl, bMute);
8817 }
8827 public static int GetWaveOutMute(int nWaveDeviceID, MixerControl nControl)
8828 {
8829 return TTDLL.TT_Mixer_GetWaveOutMute(nWaveDeviceID, nControl);
8830 }
8839 public static bool SetWaveOutVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
8840 {
8841 return TTDLL.TT_Mixer_SetWaveOutVolume(nWaveDeviceID, nControl, nVolume);
8842 }
8851 public static int GetWaveOutVolume(int nWaveDeviceID, MixerControl nControl)
8852 {
8853 return TTDLL.TT_Mixer_GetWaveOutVolume(nWaveDeviceID, nControl);
8854 }
8862 public static bool SetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
8863 {
8864 return TTDLL.TT_Mixer_SetWaveInSelected(nWaveDeviceID, nControl);
8865 }
8874 public static int GetWaveInSelected(int nWaveDeviceID, MixerControl nControl)
8875 {
8876 return TTDLL.TT_Mixer_GetWaveInSelected(nWaveDeviceID, nControl);
8877 }
8886 public static bool SetWaveInVolume(int nWaveDeviceID, MixerControl nControl, int nVolume)
8887 {
8888 return TTDLL.TT_Mixer_SetWaveInVolume(nWaveDeviceID, nControl, nVolume);
8889 }
8898 public static int GetWaveInVolume(int nWaveDeviceID, MixerControl nControl)
8899 {
8900 return TTDLL.TT_Mixer_GetWaveInVolume(nWaveDeviceID, nControl);
8901 }
8908 public static bool SetWaveInBoost(int nWaveDeviceID, bool bEnable)
8909 {
8910 return TTDLL.TT_Mixer_SetWaveInBoost(nWaveDeviceID, bEnable);
8911 }
8918 public static int GetWaveInBoost(int nWaveDeviceID)
8919 {
8920 return TTDLL.TT_Mixer_GetWaveInBoost(nWaveDeviceID);
8921 }
8928 public static bool SetWaveInMute(int nWaveDeviceID, bool bEnable)
8929 {
8930 return TTDLL.TT_Mixer_SetWaveInMute(nWaveDeviceID, bEnable);
8931 }
8938 public static int GetWaveInMute(int nWaveDeviceID)
8939 {
8940 return TTDLL.TT_Mixer_GetWaveInMute(nWaveDeviceID);
8941 }
8950 public static int GetWaveInControlCount(int nWaveDeviceID)
8951 {
8952 return TTDLL.TT_Mixer_GetWaveInControlCount(nWaveDeviceID);
8953 }
8964 public static bool GetWaveInControlName(int nWaveDeviceID, int nControlIndex,
8965 ref string szDeviceName)
8966 {
8967 IntPtr ptr = Marshal.AllocHGlobal(TeamTalkBase.TT_STRLEN * 2);
8968 bool b = TTDLL.TT_Mixer_GetWaveInControlName(nWaveDeviceID, nControlIndex, ptr);
8969 if(b)
8970 szDeviceName = Marshal.PtrToStringUni(ptr);
8971 Marshal.FreeHGlobal(ptr);
8972 return b;
8973 }
8983 public static bool SetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
8984 {
8985 return TTDLL.TT_Mixer_SetWaveInControlSelected(nWaveDeviceID, nControlIndex);
8986 }
8996 public static bool GetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
8997 {
8998 return TTDLL.TT_Mixer_GetWaveInControlSelected(nWaveDeviceID, nControlIndex);
8999 }
9000 }
9009 public class WindowsFirewall
9010 {
9016 public static bool IsEnabled()
9017 {
9018 return TTDLL.TT_Firewall_IsEnabled();
9019 }
9029 public static bool Enable(bool bEnable)
9030 {
9031 return TTDLL.TT_Firewall_Enable(bEnable);
9032 }
9039 public static bool AppExceptionExists(string szExecutable)
9040 {
9041 return TTDLL.TT_Firewall_AppExceptionExists(szExecutable);
9042 }
9052 public static bool AddAppException(string szName, string szExecutable)
9053 {
9054 return TTDLL.TT_Firewall_AddAppException(szName, szExecutable);
9055 }
9065 public static bool RemoveAppException(string szExecutable)
9066 {
9067 return TTDLL.TT_Firewall_RemoveAppException(szExecutable);
9068 }
9069 }
9075 [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
9076 public struct ShareWindow
9077 {
9079 public IntPtr hWnd;
9081 public int nWndX;
9083 public int nWndY;
9085 public int nWidth;
9087 public int nHeight;
9089 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = TeamTalkBase.TT_STRLEN)]
9090 public string szWindowTitle;
9091 }
9092
9096 public class WindowsHelper
9097 {
9100 public static System.IntPtr GetDesktopActiveHWND()
9101 {
9102 return TTDLL.TT_Windows_GetDesktopActiveHWND();
9103 }
9104
9106 public static System.IntPtr GetDesktopHWND()
9107 {
9108 return TTDLL.TT_Windows_GetDesktopHWND();
9109 }
9110
9112 public static bool GetDesktopWindowHWND(int nIndex,
9113 ref System.IntPtr lpHWnd)
9114 {
9115 return TTDLL.TT_Windows_GetDesktopWindowHWND(nIndex, ref lpHWnd);
9116 }
9117
9120 public static bool GetWindow(System.IntPtr hWnd,
9121 ref ShareWindow lpShareWindow)
9122 {
9123 return TTDLL.TT_Windows_GetWindow(hWnd, ref lpShareWindow);
9124 }
9125
9145 public static int DesktopInputKeyTranslate(TTKeyTranslate nTranslate,
9146 DesktopInput[] lpDesktopInputs,
9147 out DesktopInput[] lpTranslatedDesktopInputs)
9148 {
9149 lpTranslatedDesktopInputs = new DesktopInput[lpDesktopInputs.Length];
9150 return TTDLL.TT_DesktopInput_KeyTranslate(nTranslate, lpDesktopInputs,
9151 lpTranslatedDesktopInputs,
9152 lpDesktopInputs.Length);
9153 }
9154
9175 public static int DesktopInputExecute(DesktopInput[] lpDesktopInputs)
9176 {
9177 return TTDLL.TT_DesktopInput_Execute(lpDesktopInputs, lpDesktopInputs.Length);
9178 }
9179
9180 }
9181}
Class used to load TeamTalk5.dll and instantiate a TeamTalk client in TeamTalk 5 SDK Standard Edition...
Definition: TeamTalk.cs:8650
TeamTalk5(bool poll_based)
Simply calls TeamTalkBase.TeamTalkBase()
Definition: TeamTalk.cs:8655
const int DEFAULT_TCPPORT
Definition: TeamTalk.cs:8651
const int DEFAULT_UDPPORT
Definition: TeamTalk.cs:8652
Class used to load TeamTalk5Pro.dll and instantiate a TeamTalk client in TeamTalk 5 SDK Professional ...
Definition: TeamTalk.cs:8667
const int DEFAULT_UDPPORT
Definition: TeamTalk.cs:8669
const int DEFAULT_TCPPORT
Definition: TeamTalk.cs:8668
TeamTalk5Pro(bool poll_based)
Simply calls TeamTalkBase.TeamTalkBase()
Definition: TeamTalk.cs:8672
Abstract class which encapsulates the TeamTalk 5 client. Instantiate either BearWare....
Definition: TeamTalk.cs:4090
bool DBG_WriteAudioFileTone(MediaFileInfo lpMediaFileInfo, int nFrequency)
Definition: TeamTalk.cs:8140
bool DBG_SetSoundInputTone(StreamType uStreamTypes, int nFrequency)
Definition: TeamTalk.cs:8134
A wrapper for the Windows Firewall API.
Definition: TeamTalk.cs:9010
static bool Enable(bool bEnable)
Enable/disable the Windows Firewall.
Definition: TeamTalk.cs:9029
static bool RemoveAppException(string szExecutable)
Remove an application from the Windows Firewall exception list.
Definition: TeamTalk.cs:9065
static bool IsEnabled()
Check if the Windows Firewall is currently enabled.
Definition: TeamTalk.cs:9016
static bool AddAppException(string szName, string szExecutable)
Add an application to the Windows Firewall exception list.
Definition: TeamTalk.cs:9052
static bool AppExceptionExists(string szExecutable)
Check if an executable is already in the Windows Firewall exception list.
Definition: TeamTalk.cs:9039
Helper class for extracting Windows HWND handles and controlling mouse and keyboard.
Definition: TeamTalk.cs:9097
static bool GetWindow(System.IntPtr hWnd, ref ShareWindow lpShareWindow)
Get the properties of a window from its window handle (HWND).
Definition: TeamTalk.cs:9120
static bool GetDesktopWindowHWND(int nIndex, ref System.IntPtr lpHWnd)
Get the all the handles (HWND) of visible windows.
Definition: TeamTalk.cs:9112
static System.IntPtr GetDesktopActiveHWND()
Get the handle (HWND) of the window which is currently active (focused) on the Windows desktop.
Definition: TeamTalk.cs:9100
static int DesktopInputKeyTranslate(TTKeyTranslate nTranslate, DesktopInput[] lpDesktopInputs, out DesktopInput[] lpTranslatedDesktopInputs)
Translate platform key-code to and from TeamTalk's intermediate format.
Definition: TeamTalk.cs:9145
static int DesktopInputExecute(DesktopInput[] lpDesktopInputs)
Execute desktop (mouse or keyboard) input.
Definition: TeamTalk.cs:9175
static System.IntPtr GetDesktopHWND()
Get the handle (HWND) of the Windows desktop (full desktop).
Definition: TeamTalk.cs:9106
A wrapper for the Windows Mixer API.
Definition: TeamTalk.cs:8740
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:8839
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:8898
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:8814
static bool GetWaveOutName(int nWaveDeviceID, ref string szMixerName)
Get the name of the mixer associated with a wave-out device.
Definition: TeamTalk.cs:8792
static bool SetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
Set the selected state of a Wave-In device in the Windows Mixer.
Definition: TeamTalk.cs:8983
static bool SetWaveInBoost(int nWaveDeviceID, bool bEnable)
Enable and disable microphone boost.
Definition: TeamTalk.cs:8908
static bool GetWaveInControlSelected(int nWaveDeviceID, int nControlIndex)
Get the selected state of a Wave-In device in the Windows Mixer.
Definition: TeamTalk.cs:8996
static bool GetWaveInName(int nWaveDeviceID, ref string szMixerName)
Get the name of the mixer associated with a wave-in device.
Definition: TeamTalk.cs:8775
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:8862
static int GetWaveInBoost(int nWaveDeviceID)
See if microphone boost is enabled.
Definition: TeamTalk.cs:8918
static bool SetWaveInMute(int nWaveDeviceID, bool bEnable)
Mute/unmute microphone input.
Definition: TeamTalk.cs:8928
static int GetMixerCount()
Get the number of Windows Mixers available.
Definition: TeamTalk.cs:8747
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:8851
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:8886
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:8874
static int GetWaveInMute(int nWaveDeviceID)
See if microphone is muted.
Definition: TeamTalk.cs:8938
static int GetWaveInControlCount(int nWaveDeviceID)
Get the number of Windows Mixer Wave-In devices.
Definition: TeamTalk.cs:8950
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:8827
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:8964
static bool GetMixerName(int nMixerIndex, ref string szMixerName)
Get the name of a Windows Mixer based on its name.
Definition: TeamTalk.cs:8757
int GetRootChannelID()
Get the root channel's ID.
Definition: TeamTalk.cs:7453
const int TT_TRANSMITUSERS_STREAMTYPE_INDEX
Definition: TeamTalk.cs:4147
FileTransferStatus
Status of a file transfer.
Definition: TeamTalk.cs:2681
bool GetChannelFile(int nChannelID, int nFileID, ref RemoteFile lpRemoteFile)
Get information about a file which can be downloaded.
Definition: TeamTalk.cs:7548
const int TT_TRANSMITQUEUE_MAX
Definition: TeamTalk.cs:4191
int ChannelID
Same as GetMyChannelID().
Definition: TeamTalk.cs:7470
const int TT_CLASSROOM_STREAMTYPE_INDEX
Definition: TeamTalk.cs:4135
const int TT_CLASSROOM_FREEFORALL
Definition: TeamTalk.cs:4127
int GetChannelIDFromPath(string szChannelPath)
Get the channel ID of the supplied path. Channels are separated by '/'.
Definition: TeamTalk.cs:7503
const int TT_TRANSMITUSERS_USERID_INDEX
Definition: TeamTalk.cs:4143
ChannelType
The types of channels supported.
Definition: TeamTalk.cs:2461
bool IsChannelOperator(int nUserID, int nChannelID)
Check whether user is operator of a channel.
Definition: TeamTalk.cs:7558
int GetMyChannelID()
Get the channel which the local client instance is currently participating in.
Definition: TeamTalk.cs:7463
bool GetServerChannels(out Channel[] lpChannels)
Get all the channels on the server.
Definition: TeamTalk.cs:7568
bool GetChannelUsers(int nChannelID, out User[] lpUsers)
Get the IDs of all users in a channel.
Definition: TeamTalk.cs:7515
bool GetChannel(int nChannelID, ref Channel lpChannel)
Get the channel with a specific ID.
Definition: TeamTalk.cs:7478
const int TT_CLASSROOM_USERID_INDEX
Definition: TeamTalk.cs:4131
const int TT_TRANSMITUSERS_FREEFORALL
Definition: TeamTalk.cs:4139
bool GetChannelPath(int nChannelID, ref string szChannelPath)
Get the channel's path. Channels are separated by '/'.
Definition: TeamTalk.cs:7488
bool GetChannelFiles(int nChannelID, out RemoteFile[] lpRemoteFiles)
Get the list of the files in a channel which can be downloaded.
Definition: TeamTalk.cs:7532
const int TT_TRANSMITUSERS_MAX
The maximum number of users allowed to transmit when a BearWare.Channel is configured with ChannelTyp...
Definition: TeamTalk.cs:4118
bool CancelFileTranfer(int nTransferID)
Cancel an active file transfer.
Definition: TeamTalk.cs:8013
bool GetFileTransferInfo(int nTransferID, ref FileTransfer lpFileTransfer)
Get information about an active file transfer.
Definition: TeamTalk.cs:8000
@ FILETRANSFER_ACTIVE
File transfer active.
@ FILETRANSFER_FINISHED
File transfer finished.
@ FILETRANSFER_ERROR
Error during file transfer.
@ CHANNEL_NO_VOICEACTIVATION
Don't allow voice transmission if it's trigged by voice activation.
@ CHANNEL_PERMANENT
A channel which persists even when the last user leaves the channel.
@ CHANNEL_OPERATOR_RECVONLY
Only channel operators (and administrators) will receive audio/video/desktop transmissions....
@ CHANNEL_DEFAULT
A default channel is a channel which disappears after the last user leaves the channel.
@ CHANNEL_CLASSROOM
Voice and video transmission in the channel is controlled by a channel operator.
@ CHANNEL_NO_RECORDING
Don't allow recording to files in the channel.
@ CHANNEL_SOLO_TRANSMIT
Only one user can transmit at a time.
@ CHANNEL_HIDDEN
Hidden channel which can only be seen with UserRight.USERRIGHT_VIEW_HIDDEN_CHANNELS.
Codec
The codecs supported.
Definition: TeamTalk.cs:1546
AudioPreprocessorType
The types of supported audio preprocessors.
Definition: TeamTalk.cs:1454
@ WEBM_VP8_CODEC
WebM video codec.
@ SPEEX_VBR_CODEC
Speex audio codec in VBR mode, http://www.speex.org.
@ NO_CODEC
No codec specified.
@ SPEEX_CODEC
Speex audio codec, http://www.speex.org.
@ OPUS_CODEC
OPUS audio codec.
@ SPEEXDSP_AUDIOPREPROCESSOR
Use the BearWare.SpeexDSP audio preprocessor.
@ WEBRTC_AUDIOPREPROCESSOR
Use WebRTC's audio preprocessor from BearWare.WebRTCAudioPreprocessor. https://webrtc....
@ TEAMTALK_AUDIOPREPROCESSOR
Use TeamTalk's internal audio preprocessor BearWare.TTAudioPreprocessor.
@ NO_AUDIOPREPROCESSOR
Value for specifying that no audio preprocessing should occur.
int DoRecvFile(int nChannelID, int nFileID, string szLocalFilePath)
Download a file from the specified channel.
Definition: TeamTalk.cs:6918
int DoPing()
Ping server and wait for server to reply.
Definition: TeamTalk.cs:6544
int DoJoinChannel(Channel lpChannel)
Create a new channel and join it.
Definition: TeamTalk.cs:6655
int DoListBans(int nChannelID, int nIndex, int nCount)
Issue a command to list the banned users.
Definition: TeamTalk.cs:7346
int DoUnBanUser(string szIPAddress, int nChannelID)
Unban the user with the specified IP-address.
Definition: TeamTalk.cs:7307
int DoMoveUser(int nUserID, int nChannelID)
Issue command to move a user from one channel to another.
Definition: TeamTalk.cs:7091
int DoBanUser(int nUserID, int nChannelID)
Issue a ban command on a user in a specific channel.
Definition: TeamTalk.cs:7218
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:6818
int DoBanUserEx(int nUserID, BanType uBanTypes)
Ban the user with nUserID using the ban types specified.
Definition: TeamTalk.cs:7234
int DoChangeStatus(int nStatusMode, string szStatusMessage)
Change the client instance's currect status.
Definition: TeamTalk.cs:6749
int DoSendFile(int nChannelID, string szLocalFilePath)
Send a file to the specified channel.
Definition: TeamTalk.cs:6885
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:6560
int DoChannelOp(int nUserID, int nChannelID, bool bMakeOperator)
Make another user operator of a channel.
Definition: TeamTalk.cs:6795
int DoDeleteUserAccount(string szUsername)
Issue command to delete a user account on the server.
Definition: TeamTalk.cs:7187
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:6981
int DoQueryServerStats()
Get the server's current statistics.
Definition: TeamTalk.cs:7387
int DoMakeChannel(Channel lpChannel)
Make a new channel on the server.
Definition: TeamTalk.cs:7010
int DoKickUser(int nUserID, int nChannelID)
Kick user from either channel or server.
Definition: TeamTalk.cs:6847
int DoSaveConfig()
Save the server's current state to its settings file (typically the server's .xml file).
Definition: TeamTalk.cs:7367
int DoDeleteFile(int nChannelID, int nFileID)
Delete a file from a channel.
Definition: TeamTalk.cs:6944
int DoQuit()
Quit from server.
Definition: TeamTalk.cs:7403
int DoUpdateChannel(Channel lpChannel)
Update a channel's properties.
Definition: TeamTalk.cs:7046
int DoLeaveChannel()
Leave the current channel.
Definition: TeamTalk.cs:6705
int DoUnBanUserEx(BannedUser lpBannedUser)
Unban the properties specified in BearWare.BannedUser.
Definition: TeamTalk.cs:7321
int DoNewUserAccount(UserAccount lpUserAccount)
Issue command to create a new user account on the server.
Definition: TeamTalk.cs:7165
int DoSubscribe(int nUserID, Subscription uSubscriptions)
Subscribe to user events and/or data.
Definition: TeamTalk.cs:6962
int DoBanIPAddress(string szIPAddress, int nChannelID)
Issue a ban command on an IP-address user.
Definition: TeamTalk.cs:7282
int DoLoginEx(string szNickname, string szUsername, string szPassword, string szClientName)
Logon to a server.
Definition: TeamTalk.cs:6594
int DoBan(BannedUser lpBannedUser)
Ban the properties specified in lpBannedUser.
Definition: TeamTalk.cs:7257
int DoJoinChannelByID(int nChannelID, string szPassword)
Join an existing channel.
Definition: TeamTalk.cs:6682
int DoLogout()
Logout of the server.
Definition: TeamTalk.cs:6612
int DoChangeNickname(string szNewNick)
Change the client instance's nick name.
Definition: TeamTalk.cs:6726
int DoListUserAccounts(int nIndex, int nCount)
Issue command to list user accounts on the server.
Definition: TeamTalk.cs:7139
int DoUpdateServer(ServerProperties lpServerProperties)
Update server properties.
Definition: TeamTalk.cs:7111
int DoRemoveChannel(int nChannelID)
Remove a channel from a server.
Definition: TeamTalk.cs:7068
int DoTextMessage(TextMessage lpTextMessage)
Send a text message to either a user or a channel.
Definition: TeamTalk.cs:6771
bool Connect(string szHostAddress, int nTcpPort, int nUdpPort, int nLocalTcpPort, int nLocalUdpPort, bool bEncrypted)
Connect to a server.
Definition: TeamTalk.cs:6382
bool SetClientKeepAlive(ClientKeepAlive lpClientKeepAlive)
Update the client instance's default keep alive settings.
Definition: TeamTalk.cs:6507
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:6416
bool GetClientStatistics(ref ClientStatistics lpClientStatistics)
Retrieve client statistics of bandwidth usage and response times.
Definition: TeamTalk.cs:6488
bool QueryMaxPayload(int nUserID)
Query the maximum size of UDP data packets to the user or server.
Definition: TeamTalk.cs:6479
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:6449
bool SetEncryptionContext(EncryptionContext lpEncryptionContext)
Setup encryption properties prior to Connect().
Definition: TeamTalk.cs:6349
bool Disconnect()
Disconnect from the server.
Definition: TeamTalk.cs:6466
bool GetClientKeepAlive(ref ClientKeepAlive lpClientKeepAlive)
Get the client instance's current keep alive settings.
Definition: TeamTalk.cs:6518
const ushort DESKTOPINPUT_MOUSEPOS_IGNORE
Definition: TeamTalk.cs:866
DesktopWindow AcquireUserDesktopWindowEx(int nUserID, BitmapFormat nBitmapFormat)
Same as TeamTalkBase.AcquireUserDesktopWindow() except an extra option for converting bitmap to a dif...
Definition: TeamTalk.cs:6309
int SendDesktopWindow(DesktopWindow lpDesktopWindow, BitmapFormat nConvertBmpFormat)
Transmit a desktop window (bitmap) to users in the same channel.
Definition: TeamTalk.cs:6088
const uint DESKTOPINPUT_KEYCODE_IGNORE
Definition: TeamTalk.cs:857
TTKeyTranslate
Translate to and from TeamTalk's intermediate key-codes (TTKEYCODE).
Definition: TeamTalk.cs:8686
DesktopKeyState
The state of a key (or mouse button), i.e. if it's pressed or released.
Definition: TeamTalk.cs:793
DesktopWindow AcquireUserDesktopWindow(int nUserID)
Get a user's desktop window (bitmap image).
Definition: TeamTalk.cs:6293
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:6165
int SendDesktopWindowFromHWND(System.IntPtr hWnd, BitmapFormat nBitmapFormat, DesktopProtocol nDesktopProtocol)
Transmit the specified window in a desktop session.
Definition: TeamTalk.cs:6144
const uint DESKTOPINPUT_KEYCODE_LMOUSEBTN
Definition: TeamTalk.cs:874
DesktopProtocol
The protocols supported for transferring a BearWare.DesktopWindow.
Definition: TeamTalk.cs:749
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:6207
const uint DESKTOPINPUT_KEYCODE_RMOUSEBTN
Definition: TeamTalk.cs:882
bool CloseDesktopWindow()
Close the current desktop session.
Definition: TeamTalk.cs:6101
const int TT_DESKTOPINPUT_MAX
Definition: TeamTalk.cs:4201
bool SendDesktopInput(int nUserID, DesktopInput[] lpDesktopInputs)
Send a mouse or keyboard event to a shared desktop window.
Definition: TeamTalk.cs:6264
bool ReleaseUserDesktopWindow(DesktopWindow lpDesktopWindow)
Release memory allocated by the BearWare.DesktopWindow.
Definition: TeamTalk.cs:6322
BitmapFormat
The bitmap format used for a BearWare.DesktopWindow.
Definition: TeamTalk.cs:722
const uint DESKTOPINPUT_KEYCODE_MMOUSEBTN
Definition: TeamTalk.cs:890
bool SendDesktopCursorPosition(ushort nPosX, ushort nPosY)
Send the position of mouse cursor to users in the same channel.
Definition: TeamTalk.cs:6235
static System.Drawing.Color Palette_GetColorTable(BitmapFormat nBmpPalette, int nIndex)
Get RGB values of the palette for the bitmap format.
Definition: TeamTalk.cs:6122
@ 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...
@ TTKEY_TTKEYCODE_TO_WINKEYCODE
Translate from TTKEYCODE to Windows scan-code.
@ TTKEY_WINKEYCODE_TO_TTKEYCODE
Translate from Windows scan-code to TTKEYCODE. The Windows scan-code can be retrieved in Windows' WM_...
@ TTKEY_TTKEYCODE_TO_MACKEYCODE
Translate from TTKEYCODE to Mac OS X Carbon kVK_* key-code.
@ TTKEY_NO_TRANSLATE
Perform no translation.
@ DESKTOPKEYSTATE_DOWN
The key is pressed.
@ DESKTOPKEYSTATE_NONE
The key is ignored.
@ DESKTOPKEYSTATE_UP
The key is released.
@ DESKTOPPROTOCOL_ZLIB_1
Desktop protocol based on ZLIB for image compression and UDP for data transmission.
@ BMP_RGB8_PALETTE
The bitmap is a 256-colored bitmap requiring a palette. The default 256 colored palette is the Netsca...
@ 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...
@ 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...
@ BMP_NONE
Used to denote nothing selected.
@ BMP_RGB16_555
The bitmap is a 16-bit colored bitmap. The maximum pixels.
static string GetErrorMessage(ClientError nError)
Get textual discription of an error message.
Definition: TeamTalk.cs:8028
ClientError
Errors which can occur either as a result of client commands or as a result of internal errors.
Definition: TeamTalk.cs:2950
@ CMDERR_CHANNEL_ALREADY_EXISTS
Channel already exists.
@ CMDERR_MAX_DISKUSAGE_EXCEEDED
Cannot upload file because disk quota will be exceeded.
@ CMDERR_BAN_NOT_FOUND
Banned IP-address does not exist.
@ CMDERR_MISSING_PARAMETER
Command cannot be performed due to missing parameter. Only used internally.
@ INTERR_SNDEFFECT_FAILURE
BearWare.SoundDeviceEffects failed to initialize.
@ CMDERR_COMMAND_FLOOD
Command flooding prevented by server.
@ CMDERR_INCORRECT_OP_PASSWORD
Invalid password for becoming channel operator.
@ CMDERR_INCOMPATIBLE_PROTOCOLS
The server uses a protocol which is incompatible with the client instance.
@ CMDERR_CHANNEL_CANNOT_BE_HIDDEN
Cannot apply ChannelType.CHANNEL_HIDDEN to BearWare.Channel's channel type.
@ CMDERR_OPENFILE_FAILED
Server failed to open file.
@ CMDERR_CHANNEL_BANNED
Banned from joining a channel.
@ CMDERR_SUCCESS
Command indicating success.
@ CMDERR_ALREADY_LOGGEDIN
Already logged in.
@ INTERR_TTMESSAGE_QUEUE_OVERFLOW
BearWare.TTMessage event queue overflowed.
@ CMDERR_INCORRECT_CHANNEL_PASSWORD
Invalid channel password.
@ CMDERR_MAX_SERVER_USERS_EXCEEDED
Login failed due to maximum number of users on server.
@ INTERR_SNDOUTPUT_FAILURE
A sound output device failed.
@ INTERR_AUDIOPREPROCESSOR_INIT_FAILED
BearWare.AudioPreprocessor failed to initialize.
@ CMDERR_INVALID_USERNAME
Invalid username for BearWare.UserAccount.
@ CMDERR_USER_NOT_FOUND
User not found.
@ CMDERR_AUDIOCODEC_BITRATE_LIMIT_EXCEEDED
The selected BearWare.AudioCodec exceeds what the server allows.
@ INTERR_AUDIOCODEC_INIT_FAILED
Audio codec used by channel failed to initialize. Ensure the settings specified in BearWare....
@ CMDERR_FILE_ALREADY_EXISTS
File already exist.
@ CMDERR_MAX_CHANNEL_USERS_EXCEEDED
Cannot join channel because it has maximum number of users.
@ CMDERR_FILE_NOT_FOUND
File does not exist.
@ INTERR_SNDINPUT_FAILURE
A sound input device failed.
@ CMDERR_NOT_LOGGEDIN
Client instance has not been authenticated.
@ CMDERR_SERVER_BANNED
IP-address has been banned from server.
@ CMDERR_ACCOUNT_NOT_FOUND
Cannot find user account.
@ CMDERR_SYNTAX_ERROR
Command has syntax error. Only used internally.
@ CMDERR_CHANNEL_HAS_USERS
Cannot process command since channel is not empty.
@ CMDERR_FILETRANSFER_NOT_FOUND
File transfer doesn't exists.
@ CMDERR_UNKNOWN_COMMAND
The server doesn't support the issued command.
@ CMDERR_ALREADY_IN_CHANNEL
Cannot join same channel twice.
@ CMDERR_FILESHARING_DISABLED
Server does not allow file transfers.
@ CMDERR_INVALID_ACCOUNT
Invalid username or password for account.
@ CMDERR_MAX_CHANNELS_EXCEEDED
The maximum number of channels has been exceeded.
@ CMDERR_UNKNOWN_AUDIOCODEC
The server does not support the audio codec specified by the client. Introduced in version 4....
@ INTERR_SPEEXDSP_INIT_FAILED
Same as ClientError.INTERR_AUDIOPREPROCESSOR_INIT_FAILED.
@ CMDERR_MAX_LOGINS_PER_IPADDRESS_EXCEEDED
The maximum number of logins allowed per IP-address has been exceeded.
@ CMDERR_NOT_IN_CHANNEL
Cannot leave channel because not in channel.
@ CMDERR_CHANNEL_NOT_FOUND
Channel does not exist.
@ CMDERR_NOT_AUTHORIZED
Command not authorized.
@ CMDERR_LOGINSERVICE_UNAVAILABLE
The login service is currently unavailable.
@ CMDERR_INCORRECT_SERVER_PASSWORD
Invalid server password.
delegate void ServerStats(ServerStatistics serverstatistics)
Delegate for event OnCmdServerStatistics.
delegate void UserUpdate(User user)
Delegate for events OnCmdUserLoggedIn, OnCmdUserLoggedOut, OnCmdUserUpdate, OnCmdUserJoinedChannel an...
UserDesktopInput OnUserDesktopCursor
A user has sent the position of the mouse cursor.
Definition: TeamTalk.cs:8474
UserUpdate OnCmdUserJoinedChannel
A user has joined a channel.
Definition: TeamTalk.cs:8327
CommandProcessing OnCmdProcessing
A command issued by Do* methods is being processed.
Definition: TeamTalk.cs:8214
HotKeyTest OnHotKeyTest
A button was pressed or released on the user's keyboard or mouse.
Definition: TeamTalk.cs:8564
delegate void NewAudioBlock(int nUserID, StreamType nStreamType)
Delegate for event OnUserAudioBlock.
Connection OnConnectionLost
Connection to server has been lost.
Definition: TeamTalk.cs:8177
DesktopTransferUpdate OnDesktopWindowTransfer
Used for tracking when a desktop window has been transmitted to the server.
Definition: TeamTalk.cs:8604
delegate void UserRecordMediaFile(int nUserID, MediaFileInfo mediafileinfo)
Delegate for event OnUserRecordMediaFile.
CommandError OnCmdError
The server rejected a command issued by the local client instance.
Definition: TeamTalk.cs:8230
MaxPayloadUpdate OnConnectionMaxPayloadUpdated
The maximum size of the payload put into UDP packets has been updated.
Definition: TeamTalk.cs:8193
delegate void StreamMediaFile(MediaFileInfo mediafileinfo)
Delegate for event OnStreamMediaFile.
UserUpdate OnCmdUserUpdate
User changed properties.
Definition: TeamTalk.cs:8321
delegate void MyselfLoggedOut()
Delegate for event OnCmdMyselfLoggedOut.
delegate void CommandSuccess(int nCmdID)
Delegate for event CommandSuccess.
delegate void UserVideoFrame(int nUserID, int nStreamID)
A delegate for the event OnUserVideoCapture.
ChannelUpdate OnCmdChannelUpdate
A channel's properties has been updated.
Definition: TeamTalk.cs:8365
delegate void ErrorOccured(ClientErrorMsg clienterrormsg)
Delegate for event OnInternalError.
NewAudioBlock OnUserAudioBlock
A new audio block can be extracted.
Definition: TeamTalk.cs:8504
VoiceActivation OnVoiceActivation
Voice activation has triggered transmission.
Definition: TeamTalk.cs:8523
MyselfLoggedOut OnCmdMyselfLoggedOut
The client instance logged out of a server.
Definition: TeamTalk.cs:8272
MyselfLoggedIn OnCmdMyselfLoggedIn
The client instance successfully logged on to server.
Definition: TeamTalk.cs:8261
delegate void DesktopTransferUpdate(int nSessionID, int nBytesRemain)
Delegate for event OnDesktopWindowTransfer().
delegate void VoiceActivation(bool bVoiceActive)
Delegate for event OnVoiceActivation.
delegate void ServerUpdate(ServerProperties serverproperties)
Delegate for event OnCmdServerUpdate.
delegate void UserTextMessage(TextMessage textmessage)
Delegate for events OnCmdUserTextMessage.
HotKeyToggle OnHotKeyToggle
A hotkey has been acticated or deactivated.
Definition: TeamTalk.cs:8540
delegate void MyselfKicked(User user)
Delegate for event OnCmdMyselfKicked.
LocalMediaFile OnLocalMediaFile
Media file is being played locally.
Definition: TeamTalk.cs:8622
delegate void MaxPayloadUpdate(int nPayloadSize)
Delegate for event OnConnectionMaxPayloadUpdated().
UserTextMessage OnCmdUserTextMessage
A user has sent a text-message.
Definition: TeamTalk.cs:8346
delegate void ChannelUpdate(Channel channel)
Delegate for OnCmdChannelNew, OnCmdChannelUpdate and OnCmdChannelRemove.
delegate void HotKeyToggle(int nHotKeyID, bool bActive)
Delegate for event OnHotKeyToggle.
AudioInput OnAudioInput
Audio input progress as result of TeamTalkBase.InsertAudioBlock()
Definition: TeamTalk.cs:8631
Connection OnConnectionSuccess
Connected successfully to the server.
Definition: TeamTalk.cs:8161
UserUpdate OnCmdUserLoggedOut
A user logged out of the server.
Definition: TeamTalk.cs:8315
delegate void UserStreamUpdate(User user, int nStreamID)
Delegate for events OnUserFirstVoiceStreamPacket.
ErrorOccured OnInternalError
A internal error occured.
Definition: TeamTalk.cs:8513
CommandSuccess OnCmdSuccess
The server successfully processed a command issued by the local client instance.
Definition: TeamTalk.cs:8244
StreamMediaFile OnStreamMediaFile
Media file being streamed to a channel is processing.
Definition: TeamTalk.cs:8613
delegate void UserDesktopInput(int nSrcUserID, DesktopInput desktopinput)
Delegate for event OnUserDesktopCursor().
delegate void HotKeyTest(int nVkCode, bool bActive)
Delegate for event OnHotKeyTest.
MyselfKicked OnCmdMyselfKicked
The client instance was kicked from a channel.
Definition: TeamTalk.cs:8285
UserVideoFrame OnUserMediaFileVideo
A new video frame was received from a user.
Definition: TeamTalk.cs:8444
UserVideoFrame OnUserVideoCapture
A new video frame was received from a user.
Definition: TeamTalk.cs:8438
ChannelUpdate OnCmdChannelNew
A new channel has been created.
Definition: TeamTalk.cs:8359
delegate void FileTransferUpdate(FileTransfer filetransfer)
Delegate for event OnFileTransfer.
ListUserAccount OnCmdUserAccount
A new user account has been listed by the server. Event handler for ClientEvent.CLIENTEVENT_CMD_USERA...
Definition: TeamTalk.cs:8411
UserStreamUpdate OnUserFirstVoiceStreamPacket
The first voice packet of a new voice stream has been received.
Definition: TeamTalk.cs:8424
FileUpdate OnCmdFileNew
A new file is added to a channel.
Definition: TeamTalk.cs:8398
delegate void NewDesktopWindow(int nUserID, int nStreamID)
Delegate for event OnUserDesktopWindow.
delegate void CommandProcessing(int nCmdID, bool bActive)
Delegate for event OnCmdProcessing.
ListBannedUser OnCmdBannedUser
A new banned user has been listed by the server. Event handler for ClientEvent.CLIENTEVENT_CMD_BANNED...
Definition: TeamTalk.cs:8418
delegate void AudioInput(AudioInputProgress aip)
Delegate for event OnAudioInput.
ServerStats OnCmdServerStatistics
Server statistics available.
Definition: TeamTalk.cs:8389
UserUpdate OnUserStateChange
A user's state has been updated.
Definition: TeamTalk.cs:8429
delegate void ListBannedUser(BannedUser banneduser)
A delegate for event OnCmdUserAccount.
UserRecordMediaFile OnUserRecordMediaFile
An media file recording has changed status.
Definition: TeamTalk.cs:8490
delegate void LocalMediaFile(MediaFileInfo mediafileinfo)
Delegate for event OnLocalMediaFile.
delegate void CommandError(int nCmdID, ClientErrorMsg clienterrormsg)
Delegate for event OnCmdError.
delegate void FileUpdate(RemoteFile remotefile)
A delegate for events OnCmdFileNew and OnCmdFileRemove.
ClientEvent
TeamTalk client event messages.
Definition: TeamTalk.cs:3265
delegate void ListUserAccount(UserAccount useraccount)
A delegate for event OnCmdUserAccount.
NewDesktopWindow OnUserDesktopWindow
A new or updated desktop window has been received from a user.
Definition: TeamTalk.cs:8464
UserUpdate OnCmdUserLoggedIn
A new user logged on to the server.
Definition: TeamTalk.cs:8305
FileUpdate OnCmdFileRemove
A file has been removed from a channel.
Definition: TeamTalk.cs:8404
ServerUpdate OnCmdServerUpdate
Server has updated its settings (server name, MOTD, etc.)
Definition: TeamTalk.cs:8380
UserUpdate OnCmdUserLeftChannel
User has left a channel.
Definition: TeamTalk.cs:8333
FileTransferUpdate OnFileTransfer
A file transfer is processing.
Definition: TeamTalk.cs:8582
Connection OnConnectionFailed
Failed to connect to server.
Definition: TeamTalk.cs:8169
delegate void Connection()
Delegate for events OnConnectionSuccess, OnConnectionFailed and OnConnectionLost.
UserDesktopInput OnUserDesktopInput
Desktop input (mouse or keyboard input) has been received from a user.
Definition: TeamTalk.cs:8481
ChannelUpdate OnCmdChannelRemove
A channel has been removed. Event handler for ClientEvent.CLIENTEVENT_CMD_CHANNEL_REMOVE.
Definition: TeamTalk.cs:8370
delegate void MyselfLoggedIn(int nMyUserID, UserAccount useraccount)
Delegate for event OnCmdMyselfLoggedIn.
@ CLIENTEVENT_CMD_FILE_REMOVE
A file has been removed from a channel.
@ CLIENTEVENT_CMD_CHANNEL_UPDATE
A channel's properties has been updated.
@ CLIENTEVENT_USER_DESKTOPCURSOR
A user has sent the position of the mouse cursor.
@ CLIENTEVENT_STREAM_MEDIAFILE
Media file being streamed to a channel is processing.
@ CLIENTEVENT_CMD_SUCCESS
The server successfully processed a command issued by the local client instance.
@ CLIENTEVENT_CMD_MYSELF_KICKED
The client instance was kicked from a channel.
@ CLIENTEVENT_USER_STATECHANGE
A user state has changed.
@ CLIENTEVENT_CMD_MYSELF_LOGGEDOUT
The client instance logged out of the server.
@ CLIENTEVENT_FILETRANSFER
A file transfer is processing.
@ CLIENTEVENT_CMD_USER_JOINED
A user has joined a channel.
@ CLIENTEVENT_HOTKEY
A hotkey has been acticated or deactivated.
@ CLIENTEVENT_CMD_USER_UPDATE
User changed properties.
@ CLIENTEVENT_LOCAL_MEDIAFILE
Media file played locally is procesing.
@ CLIENTEVENT_HOTKEY_TEST
A button was pressed or released on the user's keyboard or mouse.
@ CLIENTEVENT_USER_AUDIOBLOCK
A new audio block can be extracted.
@ CLIENTEVENT_CON_MAX_PAYLOAD_UPDATED
The maximum size of the payload put into UDP packets has been updated.
@ CLIENTEVENT_USER_FIRSTVOICESTREAMPACKET
The first voice packet of a new voice stream has been received.
@ CLIENTEVENT_CMD_SERVER_UPDATE
Server has updated its settings (server name, MOTD, etc.)
@ CLIENTEVENT_USER_MEDIAFILE_VIDEO
A new video frame from a video media file was received from a user.
@ CLIENTEVENT_CON_LOST
Connection to server has been lost.
@ CLIENTEVENT_CMD_FILE_NEW
A new file is added to a channel.
@ CLIENTEVENT_USER_DESKTOPINPUT
Desktop input (mouse or keyboard input) has been received from a user.
@ CLIENTEVENT_CMD_MYSELF_LOGGEDIN
The client instance successfully logged on to server.
@ CLIENTEVENT_CON_SUCCESS
Connected successfully to the server.
@ CLIENTEVENT_USER_RECORD_MEDIAFILE
A media file recording has changed status.
@ CLIENTEVENT_USER_DESKTOPWINDOW
A new or updated desktop window has been received from a user.
@ CLIENTEVENT_CMD_ERROR
The server rejected a command issued by the local client instance.
@ CLIENTEVENT_AUDIOINPUT
Progress is audio being injected as StreamType.STREAMTYPE_VOICE.
@ CLIENTEVENT_CMD_USER_LEFT
User has left a channel.
@ CLIENTEVENT_CMD_PROCESSING
A command issued by TeamTalkBase.Do* methods is being processed.
@ CLIENTEVENT_CMD_BANNEDUSER
A banned user has been received from the server.
@ CLIENTEVENT_CON_FAILED
Failed to connect to server.
@ CLIENTEVENT_CMD_CHANNEL_NEW
A new channel has been created.
@ CLIENTEVENT_CMD_SERVERSTATISTICS
Server statistics available.
@ CLIENTEVENT_USER_VIDEOCAPTURE
A new video frame from a video capture device was received from a user.
@ CLIENTEVENT_CMD_USERACCOUNT
A user account has been received from the server.
@ CLIENTEVENT_CMD_USER_TEXTMSG
A user has sent a text-message.
@ CLIENTEVENT_CMD_USER_LOGGEDOUT
A client logged out of the server.
@ CLIENTEVENT_INTERNAL_ERROR
An internal error occurred in the client instance.
@ CLIENTEVENT_CMD_USER_LOGGEDIN
A new user logged on to the server.
@ CLIENTEVENT_CMD_CHANNEL_REMOVE
A channel has been removed.
@ CLIENTEVENT_VOICE_ACTIVATION
Voice activation has triggered transmission.
@ CLIENTEVENT_DESKTOPWINDOW_TRANSFER
Used for tracking when a desktop window has been transmitted to the server.
bool HotKey_Register(int nHotKeyID, int[] lpnVKCodes)
Register a global hotkey.
Definition: TeamTalk.cs:8063
bool HotKey_GetKeyString(int nVKCode, ref string szKeyName)
Get a string description of the virtual-key code.
Definition: TeamTalk.cs:8123
int HotKey_IsActive(int nHotKeyID)
Check whether hotkey is active.
Definition: TeamTalk.cs:8081
bool HotKey_Unregister(int nHotKeyID)
Unregister a registered hotkey.
Definition: TeamTalk.cs:8072
bool HotKey_RemoveTestHook()
Remove the test hook again so the OnHotKeyTest event will no longer be notified.
Definition: TeamTalk.cs:8113
bool HotKey_InstallTestHook()
Install a test hook which calls the event OnHotKeyTest whenever a key or mouse button is pressed.
Definition: TeamTalk.cs:8094
bool GetMessage(ref TTMessage pMsg, int nWaitMs)
Poll for events in the client instance.
Definition: TeamTalk.cs:4343
const int TT_CHANNELID_MAX
The highest channel ID. Also used for TT_CLASSROOM_FREEFORALL.
Definition: TeamTalk.cs:4106
const int TT_LOCAL_USERID
User ID passed to TeamTalkBase.EnableAudioBlockEvent() in order to receive BearWare....
Definition: TeamTalk.cs:4162
BearWare.ClientFlag GetFlags()
Get a bitmask describing the client's current state.
Definition: TeamTalk.cs:4388
const int TT_MUXED_USERID
User ID used to identify muxed audio that has been mixed into a single stream.
Definition: TeamTalk.cs:4180
TeamTalkBase(bool poll_based)
Create a new TeamTalk client instance.
Definition: TeamTalk.cs:4227
ClientFlag
Flags used to describe the the client instance current state.
Definition: TeamTalk.cs:3989
bool PumpMessage(ClientEvent nClientEvent, int nIdentifier)
Cause client instance event thread to schedule an update event.
Definition: TeamTalk.cs:4374
const int TT_USERID_MAX
The highest user ID.
Definition: TeamTalk.cs:4102
const int TT_LOCAL_TX_USERID
User ID passed to TeamTalkBase.EnableAudioBlockEvent() in order to receive BearWare....
Definition: TeamTalk.cs:4171
void ProcessMsg(TTMessage msg)
Event handler for BearWare.TTMessage.
Definition: TeamTalk.cs:4419
static string GetVersion()
Get the DLL's version number.
Definition: TeamTalk.cs:4215
ClientFlag Flags
Same as GetFlags().
Definition: TeamTalk.cs:4397
static bool SetLicenseInformation(string szRegName, string szRegKey)
Set license information to disable trial mode.
Definition: TeamTalk.cs:4410
const int TT_STRLEN
The maximum length of all strings used in TeamTalkBase. This value includes the zero terminator,...
Definition: TeamTalk.cs:4099
@ CLIENT_CLOSED
The client instance is in closed state, i.e. no operations has been performed on it.
@ CLIENT_VIDEOCAPTURE_READY
If set the client instance's video device has been initialized, i.e. TeamTalkBase....
@ CLIENT_CONNECTION
Helper for ClientFlag.CLIENT_CONNECTING and ClientFlag.CLIENT_CONNECTED to see if TeamTalkBase....
@ CLIENT_CONNECTED
If set the client instance is connected to a server, i.e. ClientEvent.CLIENTEVENT_CON_SUCCESS event h...
@ CLIENT_SNDINOUTPUT_DUPLEX
If set the client instance is running in sound duplex mode where multiple audio output streams are mi...
@ CLIENT_SNDOUTPUT_READY
If set the client instance's sound output device has been initialized, i.e. TeamTalkBase....
@ CLIENT_CONNECTING
If set the client instance is currently try to connect to a server, i.e. TeamTalkBase....
@ CLIENT_STREAM_VIDEO
If set the client is currently streaming the video of a media file. When streaming a video file the C...
@ CLIENT_MUX_AUDIOFILE
If set the client instance is currently muxing audio streams into a single file. This is enabled by c...
@ CLIENT_SNDOUTPUT_AUTO3DPOSITION
If set the client instance will auto position users in a 180 degree circle using 3D-sound....
@ CLIENT_DESKTOP_ACTIVE
If set the client instance current have an active desktop session, i.e. TeamTalkBase....
@ CLIENT_SNDINPUT_READY
If set the client instance's sound input device has been initialized, i.e. TeamTalkBase....
@ CLIENT_STREAM_AUDIO
If set the client is currently streaming the audio of a media file. When streaming a video file the C...
@ CLIENT_SNDINPUT_VOICEACTIVATED
If set the client instance will start transmitting audio if the sound level is above the voice activa...
@ CLIENT_TX_VOICE
If set the client instance is currently transmitting audio.
@ CLIENT_TX_VIDEOCAPTURE
If set the client instance is currently transmitting video.
@ CLIENT_SNDINPUT_VOICEACTIVE
If set GetSoundInputLevel() is higher than the voice activation level. To enable voice transmission i...
@ CLIENT_TX_DESKTOP
If set the client instance is currently transmitting a desktop window. A desktop window update is iss...
@ CLIENT_AUTHORIZED
If set the client instance is logged on to a server, i.e. got ClientEvent.CLIENTEVENT_CMD_MYSELF_LOGG...
@ CLIENT_SNDOUTPUT_MUTE
If set the client instance has muted all users.
bool UpdateStreamingMediaFileToChannel(MediaFilePlayback lpMediaFilePlayback, VideoCodec lpVideoCodec)
Update active media file being streamed to channel.
Definition: TeamTalk.cs:5902
bool StartStreamingMediaFileToChannel(string szMediaFilePath, VideoCodec lpVideoCodec)
Stream media file to channel, e.g. avi-, wav- or MP3-file.
Definition: TeamTalk.cs:5841
VideoFrame AcquireUserMediaVideoFrame(int nUserID, out Bitmap bmp)
Extract a user's media video frame for display.
Definition: TeamTalk.cs:6011
int InitLocalPlayback(string szMediaFilePath, MediaFilePlayback lpMediaFilePlayback)
Play media file using settings from TeamTalkBase instance.
Definition: TeamTalk.cs:5944
bool UpdateLocalPlayback(int nPlaybackSessionID, MediaFilePlayback lpMediaFilePlayback)
Definition: TeamTalk.cs:5960
bool StopLocalPlayback(int nPlaybackSessionID)
Definition: TeamTalk.cs:5974
bool StopStreamingMediaFileToChannel()
Stop streaming media file to channel.
Definition: TeamTalk.cs:5915
bool StartStreamingMediaFileToChannel(string szMediaFilePath, MediaFilePlayback lpMediaFilePlayback, VideoCodec lpVideoCodec)
Stream media file to channel, e.g. avi-, wav- or MP3-file.
Definition: TeamTalk.cs:5877
MediaFileStatus
Status of media file being written to disk.
Definition: TeamTalk.cs:519
static bool GetMediaFileInfo(string szMediaFilePath, ref MediaFileInfo lpMediaFileInfo)
Get the properties of a media file.
Definition: TeamTalk.cs:5986
bool ReleaseUserMediaVideoFrame(VideoFrame lpVideoFrame)
Delete a user's video frame, acquired through TeamTalkBase.AcquireUserMediaVideoFrame(),...
Definition: TeamTalk.cs:6033
const uint TT_MEDIAPLAYBACK_OFFSET_IGNORE
Definition: TeamTalk.cs:4211
AudioFileFormat
Media file formats supported for muxed audio recordings.
Definition: TeamTalk.cs:540
@ MFS_PLAYING
Playing media file with updated uElapsedMSec of BearWare.MediaFileInfo.
@ MFS_FINISHED
Finished processing media file.
@ MFS_STARTED
Started processing media file.
@ MFS_PAUSED
Paused processing of media file.
@ MFS_ERROR
Error while processing media file.
@ MFS_ABORTED
Aborted processing of media file.
@ AFF_MP3_16KBIT_FORMAT
Store in MP3-format.
@ AFF_WAVE_FORMAT
Store in PCM 16-bit wave format.
@ AFF_CHANNELCODEC_FORMAT
Store audio in the same format as the BearWare.Channel's configured audio codec.
@ AFF_NONE
Used to denote nothing selected.
MixerControl
The Windows mixer controls which can be queried by the BearWare.WindowsMixer class.
Definition: TeamTalk.cs:8726
UserRight
The rights users have once they have logged on to the server.
Definition: TeamTalk.cs:1724
bool GetServerUsers(out User[] lpUsers)
Get all the users on the server.
Definition: TeamTalk.cs:7432
bool GetServerProperties(ref ServerProperties lpServerProperties)
Get the server's properties.
Definition: TeamTalk.cs:7418
BanType
Way to ban a user from either login or joining a channel.
Definition: TeamTalk.cs:1956
@ USERRIGHT_TRANSMIT_DESKTOP
User is allowed to forward desktop packets through server.
@ USERRIGHT_MULTI_LOGIN
Allow multiple users to log on to the server with the same BearWare.UserAccount.
@ USERRIGHT_TRANSMIT_VOICE
Users are allowed to forward audio packets through server. TeamTalkBase.EnableVoiceTransmission()
@ USERRIGHT_CREATE_TEMPORARY_CHANNEL
User is allowed to create temporary channels which disappear when last user leaves the channel.
@ USERRIGHT_TRANSMIT_VIDEOCAPTURE
User is allowed to forward video packets through server. TeamTalkBase.StartVideoCaptureTransmission()
@ USERRIGHT_KICK_USERS
User can kick users off the server.
@ USERRIGHT_UPDATE_SERVERPROPERTIES
User can update server properties.
@ USERRIGHT_ALL
User with all rights.
@ USERRIGHT_LOCKED_NICKNAME
User's nick name is locked. TeamTalkBase.DoChangeNickname() cannot be used and TeamTalkBase....
@ USERRIGHT_TRANSMIT_MEDIAFILE
User is allowed to media files to channel.
@ USERRIGHT_BAN_USERS
User can add and remove banned users.
@ USERRIGHT_TRANSMIT_MEDIAFILE_VIDEO
User is allowed to stream video files to channel.
@ USERRIGHT_TEXTMESSAGE_BROADCAST
User can broadcast text message of type TextMsgType.MSGTYPE_BROADCAST to all users.
@ USERRIGHT_TRANSMIT_MEDIAFILE_AUDIO
User is allowed to stream audio files to channel.
@ USERRIGHT_OPERATOR_ENABLE
User can make other users channel operator.
@ USERRIGHT_TRANSMIT_DESKTOPINPUT
User is allowed to forward desktop input packets through server.
@ USERRIGHT_MOVE_USERS
User can move users from one channel to another.
@ USERRIGHT_LOCKED_STATUS
User's status is locked. TeamTalkBase.DoChangeStatus() cannot be used.
@ USERRIGHT_VIEW_ALL_USERS
User can see users in all other channels.
@ USERRIGHT_DOWNLOAD_FILES
User can download files from channels.
@ USERRIGHT_UPLOAD_FILES
User can upload files to channels.
@ USERRIGHT_VIEW_HIDDEN_CHANNELS
User can see hidden channels, ChannelType.CHANNEL_HIDDEN.
@ USERRIGHT_MODIFY_CHANNELS
User is allowed to create permanent channels which are stored in the server's configuration file.
@ USERRIGHT_RECORD_VOICE
User can record voice in all channels. Even channels with ChannelType.CHANNEL_NO_RECORDING.
@ USERRIGHT_NONE
Users who log onto the server has none of the rights below.
@ BANTYPE_NONE
Ban type not set.
@ BANTYPE_CHANNEL
The ban applies to the channel specified in the szChannel of BearWare.BannedUser. Otherwise the ban a...
@ BANTYPE_USERNAME
Ban szUsername specified in BearWare.BannedUser.
@ BANTYPE_IPADDR
Ban szIPAddress specified in BearWare.BannedUser.
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:4671
bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars, AudioFileFormat uAFF)
Store user's audio to disk.
Definition: TeamTalk.cs:7868
bool SetUserMediaStorageDir(int nUserID, string szFolderPath, string szFileNameVars, AudioFileFormat uAFF, int nStopRecordingExtraDelayMSec)
Store user's audio to disk.
Definition: TeamTalk.cs:7898
bool Enable3DSoundPositioning(bool bEnable)
Enable automatically position users using 3D-sound.
Definition: TeamTalk.cs:5153
bool ReleaseUserAudioBlock(AudioBlock lpAudioBlock)
Release the shared memory of an BearWare.AudioBlock.
Definition: TeamTalk.cs:7977
bool SetSoundInputPreprocess(SpeexDSP lpSpeexDSP)
Enable sound preprocessor which should be used for processing audio recorded by the sound input devic...
Definition: TeamTalk.cs:5067
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:7829
bool EnableAudioBlockEvent(int nUserID, StreamType uStreamTypes, AudioFormat lpAudioFormat, bool bEnable)
Same as TeamTalkBase.EnableAudioBlockEvent() but option to specify audio output format.
Definition: TeamTalk.cs:5267
bool CloseSoundDuplexDevices()
Shut down sound devices running in duplex mode.
Definition: TeamTalk.cs:4951
bool AutoPositionUsers()
Automatically position users using 3D-sound.
Definition: TeamTalk.cs:5166
bool SetSoundOutputVolume(int nVolume)
Set master volume.
Definition: TeamTalk.cs:5118
bool GetSoundDeviceEffects(ref SoundDeviceEffects lpSoundDeviceEffect)
Get the audio effects that are currently enabled.
Definition: TeamTalk.cs:4998
int GetSoundInputLevel()
Get the volume level of the current recorded audio.
Definition: TeamTalk.cs:5018
bool SetUserPosition(int nUserID, StreamType nStreamType, float x, float y, float z)
Set the position of a user.
Definition: TeamTalk.cs:7813
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:7743
const int TT_SAMPLERATES_MAX
Definition: TeamTalk.cs:4195
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:7928
static bool GetSoundDevices(out SoundDevice[] lpSoundDevices)
Retrieve list of sound devices for recording and playback.
Definition: TeamTalk.cs:4639
static bool GetDefaultSoundDevicesEx(SoundSystem nSndSystem, ref int lpnInputDeviceID, ref int lpnOutputDeviceID)
Get the default sound devices for the specified sound system.
Definition: TeamTalk.cs:4625
bool GetUserJitterControl(int nUserID, StreamType nStreamType, ref JitterConfig lpJitterConfig)
Get the de-jitter configuration for a user.
Definition: TeamTalk.cs:7791
bool GetSoundInputPreprocess(ref SpeexDSP lpSpeexDSP)
Get the sound preprocessor settings which are currently in use for recorded sound input device (voice...
Definition: TeamTalk.cs:5080
AudioBlock AcquireUserAudioBlock(StreamType uStreamTypes, int nUserID)
Extract the raw audio associated with the event TeamTalkBase.OnUserAudioBlock().
Definition: TeamTalk.cs:7952
bool SetSoundOutputMute(bool bMuteAll)
Set all users mute.
Definition: TeamTalk.cs:5139
bool InitSoundOutputSharedDevice(int nSampleRate, int nChannels, int nFrameSize)
Setup sample rate, channels and frame size of shared sound output device.
Definition: TeamTalk.cs:4859
bool InitSoundDuplexDevices(int nInputDeviceID, int nOutputDeviceID)
Enable duplex mode where multiple audio streams are mixed into a single stream using software.
Definition: TeamTalk.cs:4896
bool CloseSoundOutputDevice()
Shutdown the output sound device.
Definition: TeamTalk.cs:4941
bool InitSoundOutputDevice(int nOutputDeviceID)
Initialize the sound output device (for audio playback).
Definition: TeamTalk.cs:4825
int GetSoundInputGainLevel()
Get voice gain level of outgoing audio.
Definition: TeamTalk.cs:5047
static bool RestartSoundSystem()
Reinitialize sound system (in order to detect new/removed devices).
Definition: TeamTalk.cs:4663
SoundSystem
The supported sound systems.
Definition: TeamTalk.cs:107
bool SetUserVolume(int nUserID, StreamType nStreamType, int nVolume)
Set the volume of a user.
Definition: TeamTalk.cs:7712
SoundDeviceFeature
Features available on a sound device. Checkout uSoundDeviceFeatures on BearWare.SoundDevice.
Definition: TeamTalk.cs:163
int GetSoundOutputVolume()
Get master volume.
Definition: TeamTalk.cs:5128
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:4710
bool SetSoundInputPreprocess(AudioPreprocessor lpAudioPreprocessor)
Enable sound preprocessor which should be used for processing audio recorded by the sound input devic...
Definition: TeamTalk.cs:5095
bool GetSoundInputPreprocess(ref AudioPreprocessor lpAudioPreprocessor)
Get the sound preprocessor settings which are currently in use for recorded sound input device (voice...
Definition: TeamTalk.cs:5107
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:5234
static bool GetDefaultSoundDevices(ref int lpnInputDeviceID, ref int lpnOutputDeviceID)
Get the default sound devices.
Definition: TeamTalk.cs:4616
bool SetUserJitterControl(int nUserID, StreamType nStreamType, JitterConfig lpJitterConfig)
Set the configuration for de-jitter measures for a user.
Definition: TeamTalk.cs:7774
static bool CloseSoundLoopbackTest(IntPtr lpTTSoundLoop)
Stop recorder and playback test.
Definition: TeamTalk.cs:4725
bool SetUserMute(int nUserID, StreamType nStreamType, bool bMute)
Mute a user.
Definition: TeamTalk.cs:7727
bool InitSoundInputDevice(int nInputDeviceID)
Initialize the sound input device (for recording audio).
Definition: TeamTalk.cs:4757
bool SetSoundInputGainLevel(int nLevel)
Set voice gaining of recorded audio.
Definition: TeamTalk.cs:5037
bool CloseSoundInputDevice()
Shutdown the input sound device.
Definition: TeamTalk.cs:4919
bool InitSoundInputSharedDevice(int nSampleRate, int nChannels, int nFrameSize)
Setup sample rate, channels and frame size of shared sound input device.
Definition: TeamTalk.cs:4792
bool SetSoundDeviceEffects(SoundDeviceEffects lpSoundDeviceEffect)
Set up audio effects on a sound device.
Definition: TeamTalk.cs:4990
@ SOUNDSYSTEM_WINMM
Windows legacy audio system. Should be used on Windows Mobile.
@ SOUNDSYSTEM_WASAPI
Windows Audio Session API (WASAPI). Should be used on Windows Vista/7/8/10.
@ SOUNDSYSTEM_DSOUND
DirectSound audio system. Should be used on Windows.
@ SOUNDSYSTEM_AUDIOUNIT
iOS sound API.
@ SOUNDSYSTEM_COREAUDIO
Core Audio. Should be used on MacOS.
@ SOUNDSYSTEM_AUDIOUNIT_IOS
Same as SoundSystem.SOUNDSYSTEM_AUDIOUNIT.
@ SOUNDSYSTEM_NONE
Sound system denoting invalid or not found.
@ SOUNDSYSTEM_ALSA
Advanced Linux Sound Architecture (ALSA). Should be used on Linux.
@ SOUNDSYSTEM_OPENSLES_ANDROID
Android sound API.
@ SOUNDDEVICEFEATURE_AEC
The BearWare.SoundDevice can enable Acoustic Echo Canceler (AEC). Enable AEC use property bEnableAEC ...
@ SOUNDDEVICEFEATURE_DEFAULTCOMDEVICE
The BearWare.SoundDevice is the default communication device. This feature is only supported on Sound...
@ SOUNDDEVICEFEATURE_AGC
The BearWare.SoundDevice can enable Automatic Gain Control (AGC). Enable AGC use property bEnableAGC ...
@ SOUNDDEVICEFEATURE_DUPLEXMODE
The BearWare.SoundDevice can run in duplex mode.
@ SOUNDDEVICEFEATURE_DENOISE
The BearWare.SoundDevice can enable denoising. Enable denoising use property bEnableDenoising on Bear...
@ SOUNDDEVICEFEATURE_3DPOSITION
The BearWare.SoundDevice can position user in 3D.
bool StartRecordingMuxedAudioFile(AudioCodec lpAudioCodec, string szAudioFileName, AudioFileFormat uAFF)
Store all audio conversations with specific BearWare.AudioCodec settings to a single file.
Definition: TeamTalk.cs:5463
int GetVoiceActivationLevel()
Get voice activation level.
Definition: TeamTalk.cs:5386
bool StopRecordingMuxedAudioFile(int nChannelID)
Stop recording conversations from a channel to a single file.
Definition: TeamTalk.cs:5564
bool StopVideoCaptureTransmission()
Stop transmitting from video capture device.
Definition: TeamTalk.cs:5600
StreamType
The types of streams which are available for transmission.
Definition: TeamTalk.cs:45
bool InsertAudioBlock(AudioBlock lpAudioBlock)
Transmit application provided raw audio in BearWare.AudioBlock-structs as StreamType....
Definition: TeamTalk.cs:5306
int GetVoiceActivationStopDelay()
Get the delay of when voice active state should be disabled.
Definition: TeamTalk.cs:5416
bool StopRecordingMuxedAudioFile()
Stop an active muxed audio recording.
Definition: TeamTalk.cs:5553
bool StartVideoCaptureTransmission(VideoCodec lpVideoCodec)
Start transmitting from video capture device.
Definition: TeamTalk.cs:5591
bool EnableVoiceTransmission(bool bEnable)
Start/stop transmitting of voice data from sound input.
Definition: TeamTalk.cs:5328
bool EnableVoiceActivation(bool bEnable)
Enable voice activation.
Definition: TeamTalk.cs:5358
bool StartRecordingMuxedAudioFile(int nChannelID, string szAudioFileName, AudioFileFormat uAFF)
Store audio conversations from a specific channel into a single file.
Definition: TeamTalk.cs:5492
bool SetVoiceActivationStopDelay(int nDelayMSec)
Set the delay of when voice activation should be stopped.
Definition: TeamTalk.cs:5402
bool StartRecordingMuxedStreams(StreamType uStreamTypes, AudioCodec lpAudioCodec, string szAudioFileName, AudioFileFormat uAFF)
Mix multiple BearWare.StreamType into a single audio file.
Definition: TeamTalk.cs:5534
bool SetVoiceActivationLevel(int nLevel)
Set voice activation level.
Definition: TeamTalk.cs:5376
@ STREAMTYPE_LOCALMEDIAPLAYBACK_AUDIO
Stream type for audio of local playback.
@ STREAMTYPE_NONE
No stream.
@ STREAMTYPE_DESKTOP
Desktop window stream type which is a window (or bitmap) being transmitted.
@ STREAMTYPE_CLASSROOM_ALL
Shortcut to allow voice, media files, desktop, webcamera and channel messages.
@ STREAMTYPE_DESKTOPINPUT
Desktop input stream type which is keyboard or mouse input being transmitted.
@ STREAMTYPE_VOICE
Voice stream type which is audio recorded from a sound input device.
@ STREAMTYPE_VIDEOCAPTURE
Video capture stream type which is video recorded from a webcam.
@ STREAMTYPE_CHANNELMSG
Channel text messages as stream type.
@ STREAMTYPE_MEDIAFILE
Shortcut to allow both audio and video media files.
@ STREAMTYPE_MEDIAFILE_AUDIO
Audio stream type from a media file which is being streamed.
@ STREAMTYPE_MEDIAFILE_VIDEO
Video stream type from a media file which is being streamed.
const int TT_CHANNELS_OPERATOR_MAX
Definition: TeamTalk.cs:4186
bool GetUserStatistics(int nUserID, ref UserStatistics lpUserStatistics)
Get statistics for data and packet reception from a user.
Definition: TeamTalk.cs:7680
BearWare.UserRight GetMyUserRights()
Convenience method for TeamTalkBase.GetMyUserAccount()
Definition: TeamTalk.cs:7641
UserType
The types of users supported.
Definition: TeamTalk.cs:2000
int GetMyUserID()
Get the local client instance's user ID.
Definition: TeamTalk.cs:7590
bool GetMyUserAccount(ref UserAccount lpUserAccount)
Get the local client instance's BearWare.UserAccount.
Definition: TeamTalk.cs:7605
int UserID
Same as GetMyUserID().
Definition: TeamTalk.cs:7613
int UserData
Same as GetMyUserData().
Definition: TeamTalk.cs:7663
UserType GetMyUserType()
Get the client instance's user type.
Definition: TeamTalk.cs:7625
bool GetUser(int nUserID, ref User lpUser)
Get the user with the specified ID.
Definition: TeamTalk.cs:7671
bool GetUserByUsername(string szUsername, ref User lpUser)
Get the user with the specified username.
Definition: TeamTalk.cs:7692
Subscription
A user by default accepts audio, video and text messages from all users. Using subscribtions can,...
Definition: TeamTalk.cs:2115
UserState
The possible states for a user. Used for BearWare.User's uUserState variable.
Definition: TeamTalk.cs:2181
BearWare.UserRight UserRights
Same as GetMyUserRights().
Definition: TeamTalk.cs:7638
int GetMyUserData()
If an account was used in TeamTalkBase.DoLogin() then this value will return the nUserData from the B...
Definition: TeamTalk.cs:7655
TextMsgType
Text message types.
Definition: TeamTalk.cs:2408
@ USERTYPE_NONE
Used internally to denote an unauthenticated user.
@ USERTYPE_DEFAULT
A default user who can join channels.
@ USERTYPE_ADMIN
A user with administrator privileges.
@ SUBSCRIBE_INTERCEPT_CUSTOM_MSG
Intercept all custom text messages sent by user. Only user-type UserType.USERTYPE_ADMIN can do this.
@ SUBSCRIBE_VOICE
Subscribing to StreamType.STREAMTYPE_VOICE.
@ SUBSCRIBE_DESKTOPINPUT
Subscribing to StreamType.STREAMTYPE_DESKTOPINPUT.
@ SUBSCRIBE_VIDEOCAPTURE
Subscribing to StreamType.STREAMTYPE_VIDEOCAPTURE.
@ SUBSCRIBE_MEDIAFILE
Subscribing to StreamType.STREAMTYPE_MEDIAFILE_VIDEO and StreamType.STREAMTYPE_MEDIAFILE_AUDIO.
@ SUBSCRIBE_INTERCEPT_MEDIAFILE
Intercept all media file data sent by a user. Only user-type UserType.USERTYPE_ADMIN can do this....
@ SUBSCRIBE_BROADCAST_MSG
Subscribing to broadcast text messsages.
@ SUBSCRIBE_INTERCEPT_CHANNEL_MSG
Intercept all channel messages sent by a user. Only user-type UserType.USERTYPE_ADMIN can do this.
@ SUBSCRIBE_DESKTOP
Subscribing to StreamType.STREAMTYPE_DESKTOP.
@ SUBSCRIBE_INTERCEPT_VIDEOCAPTURE
Intercept all video sent by a user. Only user-type UserType.USERTYPE_ADMIN can do this....
@ SUBSCRIBE_INTERCEPT_USER_MSG
Intercept all user text messages sent by a user. Only user-type UserType.USERTYPE_ADMIN can do this.
@ SUBSCRIBE_CUSTOM_MSG
Subscribing to custom user messages.
@ SUBSCRIBE_INTERCEPT_DESKTOP
Intercept all desktop data sent by a user. Only user-type UserType.USERTYPE_ADMIN can do this....
@ SUBSCRIBE_CHANNEL_MSG
Subscribing to channel texxt messages.
@ SUBSCRIBE_USER_MSG
Subscribing to user text messages.
@ SUBSCRIBE_NONE
No subscriptions.
@ SUBSCRIBE_INTERCEPT_VOICE
Intercept all voice sent by a user. Only user-type UserType.USERTYPE_ADMIN can do this....
@ USERSTATE_MUTE_MEDIAFILE
If set the user's media file playback is muted.
@ USERSTATE_MEDIAFILE_AUDIO
If set the user currently streams an audio file. If user is streaming a video file with audio then th...
@ USERSTATE_VIDEOCAPTURE
If set the user currently has an active video stream. If this flag changes the event ClientEvent....
@ USERSTATE_MUTE_VOICE
If set the user's voice is muted.
@ USERSTATE_VOICE
If set the user is currently talking. If this flag changes the event ClientEvent.CLIENTEVENT_USER_STA...
@ USERSTATE_DESKTOP
If set the user currently has an active desktop session. If this flag changes the event ClientEvent....
@ USERSTATE_MEDIAFILE
If set user is streaming a media file. If this flag changes the event ClientEvent....
@ USERSTATE_MEDIAFILE_VIDEO
If set the user currently streams a video file. If this flag changes the event ClientEvent....
@ USERSTATE_NONE
The user is in initial state.
@ MSGTYPE_CUSTOM
A custom user to user text message. Works the same way as TextMsgType TextMsgType....
@ MSGTYPE_USER
A User to user text message. A message of this type can be sent across channels.
@ MSGTYPE_BROADCAST
A broadcast message. Requires UserRight.USERRIGHT_TEXTMESSAGE_BROADCAST.
@ MSGTYPE_CHANNEL
A User to channel text message. Users of type UserType.USERTYPE_DEFAULT can only send this text messa...
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:5671
bool InitVideoCaptureDevice(string szDeviceID, VideoFormat lpVideoFormat)
Initialize a video capture device.
Definition: TeamTalk.cs:5644
bool ReleaseUserVideoCaptureFrame(VideoFrame lpVideoFrame)
Delete a user's video frame, acquired through TeamTalkBase.AcquireUserVideoCaptureFrame(),...
Definition: TeamTalk.cs:5773
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:5714
VideoFrame AcquireUserVideoCaptureFrame(int nUserID, out Bitmap bmp)
Extract a user's video frame for display.
Definition: TeamTalk.cs:5749
static bool GetVideoCaptureDevices(out VideoCaptureDevice[] lpVideoDevices)
Get the list of devices available for video capture.
Definition: TeamTalk.cs:5616
bool CloseVideoCaptureDevice()
Close a video capture device.
Definition: TeamTalk.cs:5653
FourCC
The picture format used by a capture device.
Definition: TeamTalk.cs:599
const int TT_VIDEOFORMATS_MAX
Definition: TeamTalk.cs:4111
@ FOURCC_YUY2
Image format where a 640x480 pixel images takes up 614.400 bytes.
@ FOURCC_NONE
Internal use to denote no supported formats.
@ FOURCC_I420
Prefered image format with the lowest bandwidth usage. A 640x480 pixel image takes up 460....
@ FOURCC_RGB32
The image format with the highest bandwidth usage. A 640x480 pixel images takes up 1....
Properties to prevent server abuse.
Definition: TeamTalk.cs:2020
int nCommandsLimit
Limit number of commands a user can send to the server.
Definition: TeamTalk.cs:2030
int nCommandsIntervalMSec
Commands within given interval.
Definition: TeamTalk.cs:2032
An audio block containing the raw audio from a user who was talking.
Definition: TeamTalk.cs:472
int nSamples
The number of samples in the raw audio array.
Definition: TeamTalk.cs:486
StreamType uStreamTypes
The stream types used to generate the AudioBlock's raw audio.
Definition: TeamTalk.cs:507
int nSampleRate
The sample rate of the raw audio.
Definition: TeamTalk.cs:478
uint uSampleIndex
The index of the first sample in lpRawAudio. Its value will be a multiple of nSamples....
Definition: TeamTalk.cs:494
int nStreamID
The ID of the stream. The stream id changes every time the user enables a new transmission using Team...
Definition: TeamTalk.cs:476
int nChannels
The number of channels used (1 for mono, 2 for stereo).
Definition: TeamTalk.cs:480
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:484
Struct used for specifying which audio codec a channel uses.
Definition: TeamTalk.cs:1566
SpeexVBRCodec speex_vbr
Speex codec settings if nCodec is Codec.SPEEX_VBR_CODEC.
Definition: TeamTalk.cs:1578
SpeexCodec speex
Speex codec settings if nCodec is Codec.SPEEX_CODEC.
Definition: TeamTalk.cs:1574
Codec nCodec
Specifies whether the member speex, speex_vbr or opus holds the codec settings.
Definition: TeamTalk.cs:1570
OpusCodec opus
Opus codec settings if nCodec is OPUS_CODEC.
Definition: TeamTalk.cs:1582
Audio configuration for clients in a channel.
Definition: TeamTalk.cs:1600
AudioConfig(bool set_defaults)
Definition: TeamTalk.cs:1608
int nGainLevel
Reference gain level to be used by all users.
Definition: TeamTalk.cs:1606
bool bEnableAGC
Users should enable automatic gain control.
Definition: TeamTalk.cs:1603
Struct describing the audio format used by a.
Definition: TeamTalk.cs:579
AudioFileFormat nAudioFmt
The audio file format, e.g. wave or MP3.
Definition: TeamTalk.cs:581
int nSampleRate
Sample rate of media file.
Definition: TeamTalk.cs:583
int nChannels
Channels used by media file, mono = 1, stereo = 2.
Definition: TeamTalk.cs:585
The progress of the audio currently being processed as audio input.
Definition: TeamTalk.cs:1695
uint uElapsedMSec
The duration of the audio that has been transmitted.
Definition: TeamTalk.cs:1703
int nStreamID
The stream ID provided in the BearWare.AudioBlock.
Definition: TeamTalk.cs:1697
uint uQueueMSec
The duration of the audio currently queued for transmission.
Definition: TeamTalk.cs:1700
Configure the audio preprocessor specified by nPreprocessor.
Definition: TeamTalk.cs:1470
WebRTCAudioPreprocessor webrtc
Used when nPreprocessor is AudioPreprocessorType.WEBRTC_AUDIOPREPROCESSOR.
Definition: TeamTalk.cs:1482
SpeexDSP speexdsp
Used when nPreprocessor is AudioPreprocessorType.SPEEXDSP_AUDIOPREPROCESSOR.
Definition: TeamTalk.cs:1476
AudioPreprocessorType nPreprocessor
The audio preprocessor to use in the union of audio preprocessors.
Definition: TeamTalk.cs:1473
TTAudioPreprocessor ttpreprocessor
Used when nPreprocessor is AudioPreprocessorType.TEAMTALK_AUDIOPREPROCESSOR.
Definition: TeamTalk.cs:1479
A struct containing the properties of a banned user.
Definition: TeamTalk.cs:1975
string szIPAddress
IP-address of banned user.
Definition: TeamTalk.cs:1978
string szNickname
Nickname of banned user. Read-only property.
Definition: TeamTalk.cs:1987
string szChannelPath
Channel where user was located when banned.
Definition: TeamTalk.cs:1981
string szUsername
Username of banned user.
Definition: TeamTalk.cs:1990
BanType uBanTypes
The type of ban that applies to this banned user.
Definition: TeamTalk.cs:1992
string szBanTime
Date and time when user was banned. Read-only property.
Definition: TeamTalk.cs:1984
A struct containing the properties of a channel.
Definition: TeamTalk.cs:2509
int[] transmitUsersQueue
The users currently queued for voice or media file transmission.
Definition: TeamTalk.cs:2611
void AddTransmitUser(int nUserID, StreamType uStreamType)
Helper function for adding a user and BearWare.StreamType to transmitUsers.
Definition: TeamTalk.cs:2615
int GetTransmitUserCount()
Get the number of users who can currently transmit to the ChannelType.CHANNEL_CLASSROOM.
Definition: TeamTalk.cs:2642
AudioConfig audiocfg
The audio configuration which users who join the channel should use.
Definition: TeamTalk.cs:2548
void RemoveTransmitUser(int nUserID, StreamType uStreamType)
Helper function for removing a StreamType for a user in transmitUsers.
Definition: TeamTalk.cs:2653
bool bPassword
Whether password is required to join channel. Read-only property.
Definition: TeamTalk.cs:2529
string szPassword
Password to join the channel. When extracted through TeamTalkBase.GetChannel() the password will only...
Definition: TeamTalk.cs:2526
long nDiskQuota
Number of bytes available for file storage.
Definition: TeamTalk.cs:2537
int[] transmitUsers
List of users who can transmit in a channel.
Definition: TeamTalk.cs:2605
StreamType GetTransmitStreamTypes(int nUserID)
Helper function for getting the StreamType a user can transmit by querying transmitUsers.
Definition: TeamTalk.cs:2631
string szTopic
Topic of the channel.
Definition: TeamTalk.cs:2521
AudioCodec audiocodec
The audio codec used by users in the channel.
Definition: TeamTalk.cs:2545
int nUserData
User specific data which will be stored on persistent storage on the server if the channel type is Ch...
Definition: TeamTalk.cs:2535
string szOpPassword
Password to become channel operator.
Definition: TeamTalk.cs:2541
int nParentID
Parent channel ID. 0 means no parent channel, i.e. it's the root channel.
Definition: TeamTalk.cs:2512
int nChannelID
The channel's ID. A value from 1 - BearWare.TeamTalkBase.TT_CHANNELID_MAX.
Definition: TeamTalk.cs:2515
ChannelType uChannelType
A bitmask of the type of channel based on BearWare.ChannelType.
Definition: TeamTalk.cs:2531
int nMaxUsers
Max number of users in channel.
Definition: TeamTalk.cs:2543
string szName
Name of the channel.
Definition: TeamTalk.cs:2518
string szErrorMsg
Text message describing the error.
Definition: TeamTalk.cs:3252
int nErrorNo
Error number based on ClientError.
Definition: TeamTalk.cs:3249
Control timers for sending keep alive information to the server.
Definition: TeamTalk.cs:2811
int nUdpConnectTimeoutMSec
The duration before the client instance should give up trying to connect to the server on UDP....
Definition: TeamTalk.cs:2853
int nUdpKeepAliveRTXMSec
Client instance's interval for retransmitting UDP keep alive packets. If server hasn't responded to U...
Definition: TeamTalk.cs:2838
int nUdpConnectRTXMSec
Client instance's interval for retransmitting UDP connect packets. UDP connect packets are only sent ...
Definition: TeamTalk.cs:2845
int nTcpKeepAliveIntervalMSec
Client instance's interval between TeamTalkBase.DoPing() command. Read-only value....
Definition: TeamTalk.cs:2826
int nUdpKeepAliveIntervalMSec
Client instance's interval between sending UDP keep alive packets. The UDP keep alive packets are use...
Definition: TeamTalk.cs:2832
int nConnectionLostMSec
The duration before the TeamTalk instance should consider the client/server connection lost.
Definition: TeamTalk.cs:2822
Statistics of bandwidth usage and ping times in the local client instance.
Definition: TeamTalk.cs:2862
long nVoiceBytesRecv
Voice data received (on UDP).
Definition: TeamTalk.cs:2870
int nSoundInputDeviceDelayMSec
Delay of sound input device until the first audio frame is delivered (in msec).
Definition: TeamTalk.cs:2912
long nVideoCaptureBytesRecv
Video data received (on UDP).
Definition: TeamTalk.cs:2874
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:2894
int nUdpServerSilenceSec
The number of seconds nothing has been received by the client on UDP.
Definition: TeamTalk.cs:2900
long nMediaFileVideoBytesSent
Video from media file data sent (on UDP).
Definition: TeamTalk.cs:2880
long nMediaFileVideoBytesRecv
Video from media file data received (on UDP).
Definition: TeamTalk.cs:2882
long nMediaFileAudioBytesSent
Audio from media file data sent (on UDP).
Definition: TeamTalk.cs:2876
long nVoiceBytesSent
Voice data sent (on UDP).
Definition: TeamTalk.cs:2868
long nUdpBytesSent
Bytes sent on UDP.
Definition: TeamTalk.cs:2864
long nMediaFileAudioBytesRecv
Audio from media file data received (on UDP).
Definition: TeamTalk.cs:2878
long nVideoCaptureBytesSent
Video data sent (on UDP).
Definition: TeamTalk.cs:2872
int nTcpServerSilenceSec
The number of seconds nothing has been received by the client on TCP.
Definition: TeamTalk.cs:2897
long nUdpBytesRecv
Bytes received on UDP.
Definition: TeamTalk.cs:2866
long nDesktopBytesSent
Desktop data sent (on UDP).
Definition: TeamTalk.cs:2884
long nDesktopBytesRecv
Desktop data received (on UDP).
Definition: TeamTalk.cs:2886
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:2890
Constants for BearWare.DesktopInput.
Definition: TeamTalk.cs:849
A struct containing a mouse or keyboard event.
Definition: TeamTalk.cs:811
ushort uMousePosX
The X coordinate of the mouse. If used with WindowsHelper.Execute() and the mouse position should be ...
Definition: TeamTalk.cs:815
uint uKeyCode
The key-code (or mouse button) pressed. If used with TeamTalkBase.DesktopInput_Execute() and no key (...
Definition: TeamTalk.cs:825
DesktopInput(bool set_defaults)
When true initializes the desktop input to ignore mouse and key values.
Definition: TeamTalk.cs:830
ushort uMousePosY
The Y coordinate of the mouse. If used with TeamTalkBase.DesktopInput_Execute() and the mouse positio...
Definition: TeamTalk.cs:819
DesktopKeyState uKeyState
The state of the key (or mouse button) pressed, i.e. if it's up or down.
Definition: TeamTalk.cs:828
A struct containing the properties of a shared desktop window.
Definition: TeamTalk.cs:763
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:779
int nWidth
The width in pixels of the bitmap.
Definition: TeamTalk.cs:765
DesktopProtocol nProtocol
The desktop protocol used for transmitting the desktop window.
Definition: TeamTalk.cs:781
int nBytesPerLine
The number of bytes for each scan-line in the bitmap. Zero means 4-byte aligned.
Definition: TeamTalk.cs:772
IntPtr frameBuffer
A buffer pointing to the bitmap data (often refered to as Scan0).
Definition: TeamTalk.cs:783
int nFrameBufferSize
The size in bytes of the buffer allocate in frameBuffer. Typically nBytesPerLine * nHeight.
Definition: TeamTalk.cs:786
BitmapFormat bmpFormat
The format of the bitmap.
Definition: TeamTalk.cs:769
int nHeight
The height in pixels of the bitmap.
Definition: TeamTalk.cs:767
Configure peer verification for encrypted connection.
Definition: TeamTalk.cs:2753
string szCAFile
Path to Certificate Authority (CA) Certificate in PEM format.
Definition: TeamTalk.cs:2769
bool bVerifyClientOnce
Whether to only verify client's certificate once during initial connection.
Definition: TeamTalk.cs:2791
int nVerifyDepth
Set limit to depth in the certificate chain during the verification procedure.
Definition: TeamTalk.cs:2799
string szCertificateFile
Path to SSL certificate in PEM format.
Definition: TeamTalk.cs:2760
string szPrivateKeyFile
Path to certificate's private key.
Definition: TeamTalk.cs:2763
bool bVerifyPeer
Verify that peer (client or server) uses a certificate that has been generated by the Certificate Aut...
Definition: TeamTalk.cs:2780
string szCADir
Path to directory containing Certificate Authority (CA) Certificates in PEM format.
Definition: TeamTalk.cs:2773
A struct containing the properties of a file transfer.
Definition: TeamTalk.cs:2697
bool bInbound
TRUE if download and FALSE if upload.
Definition: TeamTalk.cs:2715
FileTransferStatus nStatus
Status of file transfer.
Definition: TeamTalk.cs:2699
string szRemoteFileName
The filename in the channel.
Definition: TeamTalk.cs:2709
string szLocalFilePath
The file path on local disk.
Definition: TeamTalk.cs:2706
long nTransferred
The number of bytes transferred so far.
Definition: TeamTalk.cs:2713
long nFileSize
The size of the file being transferred.
Definition: TeamTalk.cs:2711
int nTransferID
The ID identifying the file transfer.
Definition: TeamTalk.cs:2701
int nChannelID
The channel where the file is/will be located.
Definition: TeamTalk.cs:2703
Configuration parameters for the Jitter Buffer.
Definition: TeamTalk.cs:2922
int nMaxAdaptiveDelayMSec
A hard maximum delay on the adaptive delay. Only valid when higher than zero. Default = 0.
Definition: TeamTalk.cs:2929
int nActiveAdaptiveDelayMSec
The current adaptive delay. When used with TeamTalkBase.SetUserJitterControl(), this value is used as...
Definition: TeamTalk.cs:2936
bool bUseAdativeDejitter
Turns adaptive jitter buffering ON/OFF. Default is OFF.
Definition: TeamTalk.cs:2926
int nFixedDelayMSec
The fixed delay in milliseconds. Default = 0.
Definition: TeamTalk.cs:2924
Struct describing the audio and video format used by a media file.
Definition: TeamTalk.cs:1653
uint uElapsedMSec
The elapsed time of the media file in miliseconds.
Definition: TeamTalk.cs:1667
AudioFormat audioFmt
The audio properties of the media file.
Definition: TeamTalk.cs:1661
VideoFormat videoFmt
The video properties of the media file.
Definition: TeamTalk.cs:1663
string szFileName
Name of file.
Definition: TeamTalk.cs:1659
uint uDurationMSec
The duration of the media file in miliseconds.
Definition: TeamTalk.cs:1665
MediaFileStatus nStatus
Status of media file if it's being saved to disk.
Definition: TeamTalk.cs:1656
Properties for initializing or updating a file for media streaming.
Definition: TeamTalk.cs:1679
uint uOffsetMSec
Offset in milliseconds in the media file where to start playback. Pass BearWare.TeamTalkBase....
Definition: TeamTalk.cs:1684
AudioPreprocessor audioPreprocessor
Option to activate audio preprocessor on local media file playback.
Definition: TeamTalk.cs:1688
bool bPaused
Start or pause media file playback.
Definition: TeamTalk.cs:1686
OPUS audio codec settings. For detailed information about the OPUS codec check out http://www....
Definition: TeamTalk.cs:1040
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:1078
bool bFEC
Forward error correction. Corrects errors if there's packetloss.
Definition: TeamTalk.cs:1055
bool bVBR
Enable variable bitrate.
Definition: TeamTalk.cs:1064
int nComplexity
Complexity of encoding (affects CPU usage). Value from 0-10.
Definition: TeamTalk.cs:1052
bool bDTX
Discontinuous transmission. Enables "null" packets during silence.
Definition: TeamTalk.cs:1058
int nSampleRate
The sample rate to use. Sample rate must be 8000, 12000, 16000, 24000 or 48000 Hz.
Definition: TeamTalk.cs:1043
int nApplication
Application of encoded audio, VoIP or music.
Definition: TeamTalk.cs:1049
bool bVBRConstraint
Enable constrained VBR. bVBR must be enabled to enable this.
Definition: TeamTalk.cs:1067
int nTxIntervalMSec
Duration of audio before each transmission. Minimum is 2 msec. Recommended is 40 msec....
Definition: TeamTalk.cs:1074
int nBitRate
Bitrate for encoded audio. Should be between BearWare.OpusConstants.OPUS_MIN_BITRATE and BearWare....
Definition: TeamTalk.cs:1062
int nChannels
Mono = 1 or stereo = 2.
Definition: TeamTalk.cs:1045
OPUS constants for BearWare.OpusCodec.
Definition: TeamTalk.cs:1083
const bool DEFAULT_OPUS_FEC
Definition: TeamTalk.cs:1112
const int DEFAULT_OPUS_COMPLEXITY
Definition: TeamTalk.cs:1111
const bool DEFAULT_OPUS_VBR
Definition: TeamTalk.cs:1114
const bool DEFAULT_OPUS_VBRCONSTRAINT
Definition: TeamTalk.cs:1115
const int DEFAULT_OPUS_APPLICATION
Definition: TeamTalk.cs:1108
const int OPUS_MIN_FRAMESIZE
The minimum frame size for OPUS codec. Checkout nFrameSizeMSec of BearWare.OpusCodec.
Definition: TeamTalk.cs:1099
const int DEFAULT_OPUS_CHANNELS
Definition: TeamTalk.cs:1110
const bool DEFAULT_OPUS_DTX
Definition: TeamTalk.cs:1113
const int OPUS_MAX_BITRATE
The maximum bitrate for OPUS codec. Checkout nBitRate of BearWare.OpusCodec.
Definition: TeamTalk.cs:1095
const int DEFAULT_OPUS_DELAY
Definition: TeamTalk.cs:1117
const int OPUS_REALMAX_FRAMESIZE
The real maximum frame size for OPUS codec. Checkout nFrameSizeMSec of BearWare.OpusCodec....
Definition: TeamTalk.cs:1106
const int OPUS_MAX_FRAMESIZE
The maximum frame size for OPUS codec. Checkout nFrameSizeMSec of BearWare.OpusCodec.
Definition: TeamTalk.cs:1102
const int DEFAULT_OPUS_SAMPLERATE
Definition: TeamTalk.cs:1109
const int OPUS_APPLICATION_AUDIO
Audio encoding is for music. This value should be set as nApplicaton in BearWare.OpusCodec.
Definition: TeamTalk.cs:1089
const int OPUS_MIN_BITRATE
The minimum bitrate for OPUS codec. Checkout nBitRate of BearWare.OpusCodec.
Definition: TeamTalk.cs:1092
const int DEFAULT_OPUS_BITRATE
Definition: TeamTalk.cs:1116
const int OPUS_APPLICATION_VOIP
Audio encoding is for VoIP. This value should be set as nApplicaton in BearWare.OpusCodec.
Definition: TeamTalk.cs:1086
A struct containing the properties of a file in a BearWare.Channel.
Definition: TeamTalk.cs:2723
int nChannelID
The ID of the channel where the file is located.
Definition: TeamTalk.cs:2725
long nFileSize
The size of the file.
Definition: TeamTalk.cs:2732
string szUploadTime
Time when file was uploaded. Date/time is converted local time.
Definition: TeamTalk.cs:2739
string szFileName
The name of the file.
Definition: TeamTalk.cs:2730
int nFileID
The ID identifying the file.
Definition: TeamTalk.cs:2727
string szUsername
Username of the person who uploaded the files.
Definition: TeamTalk.cs:2735
A struct containing the properties of the server's settings.
Definition: TeamTalk.cs:1816
int nMaxMediaFileTxPerSecond
The maximum number of bytes per second which the server will allow for media file packets....
Definition: TeamTalk.cs:1855
int nUserTimeout
The number of seconds before a user who hasn't responded to keepalives will be kicked off the server.
Definition: TeamTalk.cs:1872
bool bAutoSave
Whether the server automatically saves changes.
Definition: TeamTalk.cs:1865
string szServerProtocolVersion
The version of the server's protocol.
Definition: TeamTalk.cs:1878
int nMaxLoginsPerIPAddress
The maximum number of users allowed to log in with the same IP-address. 0 means disabled.
Definition: TeamTalk.cs:1842
string szAccessToken
A randomly generated 256 bit access token created by the server to identify the login session....
Definition: TeamTalk.cs:1892
int nMaxDesktopTxPerSecond
The maximum number of bytes per second which the server will allow for desktop packets....
Definition: TeamTalk.cs:1859
int nUdpPort
The server's UDP port.
Definition: TeamTalk.cs:1869
int nLoginDelayMSec
Number of msec before an IP-address can make another login attempt. If less than this amount then Tea...
Definition: TeamTalk.cs:1887
int nMaxTotalTxPerSecond
The amount of bytes per second which the server will allow for packet forwarding. If this value is ex...
Definition: TeamTalk.cs:1863
string szServerName
The server's name.
Definition: TeamTalk.cs:1819
int nMaxLoginAttempts
The maximum number of logins with wrong password before banning user's IP-address.
Definition: TeamTalk.cs:1839
string szMOTD
The message of the day. Read-only property. Use szMOTDRaw to update this property.
Definition: TeamTalk.cs:1823
string szMOTDRaw
The message of the day including variables. The result of the szMOTDRaw string will be displayed in s...
Definition: TeamTalk.cs:1833
int nMaxUsers
The maximum number of users allowed on the server. A user with admin account can ignore this.
Definition: TeamTalk.cs:1836
int nTcpPort
The server's TCP port.
Definition: TeamTalk.cs:1867
string szServerVersion
The server version.
Definition: TeamTalk.cs:1875
int nMaxVoiceTxPerSecond
The maximum number of bytes per second which the server will allow for voice packets....
Definition: TeamTalk.cs:1846
int nMaxVideoCaptureTxPerSecond
The maximum number of bytes per second which the server will allow for video input packets....
Definition: TeamTalk.cs:1851
A struct containing the server's statistics, i.e. bandwidth usage and user activity.
Definition: TeamTalk.cs:1904
long nMediaFileBytesTX
The number of bytes in media file packets sent from the server to clients.
Definition: TeamTalk.cs:1925
long nVideoCaptureBytesTX
The number of bytes in video packets sent from the server to clients.
Definition: TeamTalk.cs:1919
long nFilesRx
The number of bytes for file transmission received by the server.
Definition: TeamTalk.cs:1944
long nDesktopBytesTX
The number of bytes in desktop packets sent from the server to clients.
Definition: TeamTalk.cs:1931
long nFilesTx
The number of bytes for file transmission transmitted from the server.
Definition: TeamTalk.cs:1941
long nUptimeMSec
The server's uptime in msec.
Definition: TeamTalk.cs:1946
long nVoiceBytesRX
The number of bytes in audio packets received by the server from clients.
Definition: TeamTalk.cs:1916
int nUsersServed
The number of users who have logged on to the server.
Definition: TeamTalk.cs:1936
long nTotalBytesRX
The number of bytes received by the server from clients.
Definition: TeamTalk.cs:1910
long nTotalBytesTX
The number of bytes sent from the server to clients.
Definition: TeamTalk.cs:1907
long nVideoCaptureBytesRX
The number of bytes in video packets received by the server from clients.
Definition: TeamTalk.cs:1922
long nDesktopBytesRX
The number of bytes in desktop packets received by the server from clients.
Definition: TeamTalk.cs:1934
long nVoiceBytesTX
The number of bytes in audio packets sent from the server to clients.
Definition: TeamTalk.cs:1913
long nMediaFileBytesRX
The number of bytes in media file packets received by the server from clients.
Definition: TeamTalk.cs:1928
int nUsersPeak
The highest numbers of users online.
Definition: TeamTalk.cs:1938
A struct which describes the properties of a window which can be shared.
Definition: TeamTalk.cs:9077
IntPtr hWnd
The Windows handle of the window.
Definition: TeamTalk.cs:9079
string szWindowTitle
The title of the window.
Definition: TeamTalk.cs:9090
int nWndX
X coordinate of the window relative to the Windows desktop.
Definition: TeamTalk.cs:9081
int nHeight
The height in pixels of the window.
Definition: TeamTalk.cs:9087
int nWndY
Y coordinate of the window relative to the Windows desktop.
Definition: TeamTalk.cs:9083
int nWidth
The width in pixels of the window.
Definition: TeamTalk.cs:9085
IDs for sound devices.
Definition: TeamTalk.cs:334
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:353
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:348
const int TT_SOUNDDEVICE_ID_TEAMTALK_VIRTUAL
Sound device ID for virtual TeamTalk sound device.
Definition: TeamTalk.cs:362
const uint TT_SOUNDDEVICE_ID_MASK
Extract sound device ID of nDeviceID in BearWare.SoundDevice by and'ing this value.
Definition: TeamTalk.cs:384
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:343
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:378
const int TT_SOUNDDEVICE_ID_REMOTEIO
Sound device ID for iOS AudioUnit subtype Remote I/O Unit.
Definition: TeamTalk.cs:337
Set up audio effects supported by the sound device.
Definition: TeamTalk.cs:279
bool bEnableEchoCancellation
Enable echo cancellation.
Definition: TeamTalk.cs:328
bool bEnableAGC
Enable Automatic Gain Control.
Definition: TeamTalk.cs:295
bool bEnableDenoise
Enable noise suppression.
Definition: TeamTalk.cs:312
A struct containing the properties of a sound device for either playback or recording.
Definition: TeamTalk.cs:207
int nWaveDeviceID
A Windows specific ID to the sound device.
Definition: TeamTalk.cs:241
string szDeviceID
An identifier uniquely identifying the sound device even when new sound devices are being added and r...
Definition: TeamTalk.cs:224
bool bSupports3D
Whether the sound device supports 3D-sound effects.
Definition: TeamTalk.cs:244
SoundDeviceFeature uSoundDeviceFeatures
Additional features available for this sound device. The sound device features can be used to enable ...
Definition: TeamTalk.cs:266
int[] inputSampleRates
Supported sample rates by device for recording. A zero value terminates the list of supported sample ...
Definition: TeamTalk.cs:253
int nDefaultSampleRate
The default sample rate for the sound device.
Definition: TeamTalk.cs:260
int nMaxInputChannels
The maximum number of input channels.
Definition: TeamTalk.cs:246
SoundSystem nSoundSystem
The sound system used by the sound device.
Definition: TeamTalk.cs:215
int nDeviceID
The ID of the sound device. Used for passing to TeamTalkBase.InitSoundInputDevice() and TeamTalkBase....
Definition: TeamTalk.cs:213
string szDeviceName
The name of the sound device.
Definition: TeamTalk.cs:218
int[] outputSampleRates
Supported sample rates by device for playback. A zero value terminates the list of supported sample r...
Definition: TeamTalk.cs:258
int nMaxOutputChannels
The maximum number of output channels.
Definition: TeamTalk.cs:248
An enum encapsulation the minimum, maximum and default sound levels for input and output sound device...
Definition: TeamTalk.cs:391
const int SOUND_VU_MAX
The maximum value of recorded audio.
Definition: TeamTalk.cs:397
const int SOUND_VOLUME_MAX
The maximum volume.
Definition: TeamTalk.cs:411
const int SOUND_GAIN_MIN
The minimum gain level (since it's zero it means silence).
Definition: TeamTalk.cs:453
const int SOUND_VOLUME_MIN
The minimum volume.
Definition: TeamTalk.cs:425
const int SOUND_VU_MIN
The minimum value of recorded audio.
Definition: TeamTalk.cs:403
const int SOUND_GAIN_DEFAULT
The default gain level.
Definition: TeamTalk.cs:444
const int SOUND_GAIN_MAX
The maximum gain level.
Definition: TeamTalk.cs:434
const int SOUND_VOLUME_DEFAULT
The default volume. Use this whenever possible since it requires the least amount of CPU usage.
Definition: TeamTalk.cs:419
Speex audio codec settings for Constant Bitrate mode (CBR).
Definition: TeamTalk.cs:907
int nQuality
A value from 1-10. As of DLL version 4.2 also 0 is supported.
Definition: TeamTalk.cs:915
int nTxIntervalMSec
Milliseconds of audio data before each transmission.
Definition: TeamTalk.cs:926
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:911
bool bStereoPlayback
Playback should be done in stereo. Doing so will disable 3d-positioning.
Definition: TeamTalk.cs:933
Speex constants for BearWare.SpeexCodec and BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:984
const int SPEEX_BANDMODE_UWIDE
Use BearWare.SpeexCodec or BearWare.SpeexVBRCodec as 32 KHz.
Definition: TeamTalk.cs:990
const bool DEFAULT_SPEEX_DTX
Default Speex DTX for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1033
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:1000
const int SPEEX_QUALITY_MAX
The maximum quality for Speex codec.
Definition: TeamTalk.cs:994
const int SPEEX_QUALITY_MIN
The minimum quality for Speex codec.
Definition: TeamTalk.cs:992
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:1006
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:1003
const int DEFAULT_SPEEX_DELAY
Default Speex delay for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1021
const int SPEEX_BANDMODE_NARROW
Use BearWare.SpeexCodec or BearWare.SpeexVBRCodec as 8 KHz.
Definition: TeamTalk.cs:986
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:1009
const int DEFAULT_SPEEX_BITRATE
Default Speex bitrate for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1027
const int SPEEX_BANDMODE_WIDE
Use BearWare.SpeexCodec or BearWare.SpeexVBRCodec as 16 KHz.
Definition: TeamTalk.cs:988
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:1012
const int DEFAULT_SPEEX_MAXBITRATE
Default Speex max bitrate for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1030
const int DEFAULT_SPEEX_BANDMODE
Default Speex bandmode for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1015
const bool DEFAULT_SPEEX_SIMSTEREO
Default Speex stereo playback for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1024
const int DEFAULT_SPEEX_QUALITY
Default Speex quality for BearWare.SpeexCodec or BearWare.SpeexVBRCodec.
Definition: TeamTalk.cs:1018
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:997
Default values for BearWare.SpeexDSP.
Definition: TeamTalk.cs:1487
const int DEFAULT_DENOISE_SUPPRESS
Definition: TeamTalk.cs:1494
const int DEFAULT_ECHO_SUPPRESS_ACTIVE
Definition: TeamTalk.cs:1497
const bool DEFAULT_AGC_ENABLE
Definition: TeamTalk.cs:1488
const int DEFAULT_ECHO_SUPPRESS
Definition: TeamTalk.cs:1496
const int DEFAULT_AGC_DEC_MAXDB
Definition: TeamTalk.cs:1491
const bool DEFAULT_ECHO_ENABLE
Definition: TeamTalk.cs:1495
const bool DEFAULT_DENOISE_ENABLE
Definition: TeamTalk.cs:1493
const int DEFAULT_AGC_INC_MAXDB
Definition: TeamTalk.cs:1490
const int DEFAULT_AGC_GAINMAXDB
Definition: TeamTalk.cs:1492
const int DEFAULT_AGC_GAINLEVEL
Definition: TeamTalk.cs:1489
Audio configuration specifying how recorded audio from sound input device should be preprocessed befo...
Definition: TeamTalk.cs:1139
SpeexDSP(bool set_defaults)
Definition: TeamTalk.cs:1209
int nMaxDecDBSec
Used so volume should not be attenuated too quickly (maximal gain decrease in dB/second)....
Definition: TeamTalk.cs:1163
bool bEnableDenoise
Whether clients who join the channel should automatically enable denoising.
Definition: TeamTalk.cs:1172
bool bEnableAGC
Whether clients who join a BearWare.Channel should enable AGC with the settings specified nGainLevel,...
Definition: TeamTalk.cs:1148
int nMaxIncDBSec
Used so volume should not be amplified too quickly (maximal gain increase in dB/second)....
Definition: TeamTalk.cs:1157
int nGainLevel
A value from 0 to 32768. Default is 8000. Value is ignored if bEnableAGC is FALSE.
Definition: TeamTalk.cs:1152
int nEchoSuppressActive
Set maximum attenuation of the residual echo in dB when near end is active (negative number)....
Definition: TeamTalk.cs:1207
int nEchoSuppress
Set maximum attenuation of the residual echo in dB (negative number). Default is -40....
Definition: TeamTalk.cs:1202
int nMaxGainDB
Ensure volume doesn't become too loud (maximal gain in dB). Default is 30. Value is ignored if bEnabl...
Definition: TeamTalk.cs:1168
bool bEnableEchoCancellation
Speex DSP is used for specifying how recorded audio from a sound input device should be preprocessed ...
Definition: TeamTalk.cs:1197
int nMaxNoiseSuppressDB
Maximum attenuation of the noise in dB. Negative value! Default value is -30. Value is ignored if bEn...
Definition: TeamTalk.cs:1177
Speex audio codec settings for Variable Bitrate mode (VBR).
Definition: TeamTalk.cs:943
int nTxIntervalMSec
Milliseconds of audio data before each transmission.
Definition: TeamTalk.cs:973
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:960
bool bDTX
Enable/disable discontinuous transmission. When enabled Speex will ignore silence,...
Definition: TeamTalk.cs:964
int nQuality
A value from 0-10. If nBitRate is non-zero it will override this value.
Definition: TeamTalk.cs:949
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:946
int nBitRate
The bitrate at which the audio codec should output encoded audio data. Dividing it by 8 gives roughly...
Definition: TeamTalk.cs:956
bool bStereoPlayback
Playback should be done in stereo. Doing so will disable 3d-positioning.
Definition: TeamTalk.cs:979
Use TeamTalk's internal audio preprocessor for gain audio. Same as used for TeamTalkBase....
Definition: TeamTalk.cs:1248
bool bMuteLeftSpeaker
Whether to mute left speaker in stereo playback.
Definition: TeamTalk.cs:1254
bool bMuteRightSpeaker
Whether to mute right speaker in stereo playback.
Definition: TeamTalk.cs:1256
int nGainLevel
Gain level between BearWare.SoundLevel.SOUND_GAIN_MIN and BearWare.SoundLevel.SOUND_GAIN_MAX....
Definition: TeamTalk.cs:1252
A struct containing the properties of an event.
Definition: TeamTalk.cs:3882
uint uReserved
Reserved. To preserve alignment.
Definition: TeamTalk.cs:3890
int nSource
The source of the event depends on wmMsg.
Definition: TeamTalk.cs:3886
ClientEvent nClientEvent
The event's message number.
Definition: TeamTalk.cs:3884
TTType ttType
Specifies which member to access in the union.
Definition: TeamTalk.cs:3888
object DataToObject()
Definition: TeamTalk.cs:3895
A struct containing the properties of a text message sent by a user.
Definition: TeamTalk.cs:2434
int nChannelID
Set to zero if nMsgType is TextMsgType TextMsgType.MSGTYPE_USER or TextMsgType TextMsgType....
Definition: TeamTalk.cs:2446
int nToUserID
Set to zero if channel message.
Definition: TeamTalk.cs:2443
string szMessage
The actual text message. The message can be multi-line (include EOL)
Definition: TeamTalk.cs:2450
int nFromUserID
Will be set automatically on outgoing message.
Definition: TeamTalk.cs:2438
string szFromUsername
The originators username.
Definition: TeamTalk.cs:2441
TextMsgType nMsgType
The type of text message.
Definition: TeamTalk.cs:2436
FileTransfer filetransfer
Definition: TeamTalk.cs:3947
ClientErrorMsg clienterrormsg
Definition: TeamTalk.cs:3941
DesktopInput desktopinput
Definition: TeamTalk.cs:3945
TextMessage textmessage
Definition: TeamTalk.cs:3955
ServerProperties serverproperties
Definition: TeamTalk.cs:3953
UserAccount useraccount
Definition: TeamTalk.cs:3959
MediaFileInfo mediafileinfo
Definition: TeamTalk.cs:3949
RemoteFile remotefile
Definition: TeamTalk.cs:3951
A struct containing the properties of a user account.
Definition: TeamTalk.cs:2045
string szNote
Additional notes about this user.
Definition: TeamTalk.cs:2064
int nUserData
A user data field which can be used for additional information. The nUserData field of the BearWare....
Definition: TeamTalk.cs:2061
string szInitChannel
User should (manually) join this channel after login. If an initial channel is specified in the user'...
Definition: TeamTalk.cs:2070
UserType uUserType
A bitmask of the type of user based on UserType.
Definition: TeamTalk.cs:2053
string szPassword
The account's password.
Definition: TeamTalk.cs:2051
UserRight uUserRights
A bitmask based on UserRight which specifies the rights the user have who logs onto the server....
Definition: TeamTalk.cs:2057
string szLastModified
Timestamp of last modification of user account. Date/time is converted local time.
Definition: TeamTalk.cs:2088
int[] autoOperatorChannels
Channels where this user will automatically become channel operator when joining. The channels must b...
Definition: TeamTalk.cs:2075
AbusePrevention abusePrevent
Properties which can be set to prevent abuse of a server, e.g. limit number of commands issued.
Definition: TeamTalk.cs:2084
string szUsername
The account's username.
Definition: TeamTalk.cs:2048
int nAudioCodecBpsLimit
Bandwidth restriction for audio codecs created by this user. This value will hold the highest bitrate...
Definition: TeamTalk.cs:2079
A struct containing the properties of a user.
Definition: TeamTalk.cs:2226
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:2302
int nStoppedDelayMediaFile
The delay of when a user should no longer be considered playing audio of a media file.
Definition: TeamTalk.cs:2316
int nChannelID
The channel which the user is currently participating in. 0 if none. This value can change as a resul...
Definition: TeamTalk.cs:2260
string szStatusMsg
The user's current status message. Invoke TeamTalkBase.DoChangeStatus() to change this value....
Definition: TeamTalk.cs:2289
int nActiveAdaptiveDelayMSec
The currently active adaptive jitter delay for received voice streams for this user.
Definition: TeamTalk.cs:2352
string szUsername
The szUsername of the user's BearWare.UserAccount. A user account is created by calling TeamTalkBase....
Definition: TeamTalk.cs:2236
int nStoppedDelayVoice
The delay of when a user should no longer be considered as talking.
Definition: TeamTalk.cs:2312
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:2308
bool[] stereoPlaybackMediaFile
Check what speaker a user is outputting to. If index 0 is TRUE then left speaker is playing....
Definition: TeamTalk.cs:2340
Subscription uPeerSubscriptions
A bitmask of what this user subscribes to from local client instance. Invoking TeamTalkBase....
Definition: TeamTalk.cs:2272
string szIPAddress
The user's IP-address. This value is set by the server.
Definition: TeamTalk.cs:2248
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:2230
string szMediaStorageDir
Store audio received from this user to this folder.
Definition: TeamTalk.cs:2296
uint uVersion
The user's client version. This property is set by the server and will not change after login....
Definition: TeamTalk.cs:2254
string szClientName
The name of the client application which the user is using. This is the value passed as szClientName ...
Definition: TeamTalk.cs:2357
int nBufferMSecVoice
The size of the buffer (in msec) to hold voice content.
Definition: TeamTalk.cs:2344
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:2322
UserState uUserState
A bitmask of the user's current state, e.g. talking, muted, etc.
Definition: TeamTalk.cs:2292
UserType uUserType
The uUserType of the user's BearWare.UserAccount. This property is set by the server and will not cha...
Definition: TeamTalk.cs:2245
int nStatusMode
The user's current status mode. Invoke TeamTalkBase.DoChangeStatus() to change this value....
Definition: TeamTalk.cs:2283
string szNickname
The user's nickname. Invoking TeamTalkBase.DoChangeNickname() changes this value. Event ClientEvent....
Definition: TeamTalk.cs:2278
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:2328
bool[] stereoPlaybackVoice
Check what speaker a user is outputting to. If index 0 is TRUE then left speaker is playing....
Definition: TeamTalk.cs:2334
int nUserData
The nUserData of the user's BearWare.UserAccount. This field can be use to denote e....
Definition: TeamTalk.cs:2241
Subscription uLocalSubscriptions
A bitmask of what the local user subscribes to from this user. Invoking TeamTalkBase....
Definition: TeamTalk.cs:2266
int nBufferMSecMediaFile
The size of the buffer (in msec) to hold media file content.
Definition: TeamTalk.cs:2348
Packet reception and data statistics for a user.
Definition: TeamTalk.cs:2366
long nMediaFileVideoPacketsRecv
Number of media file video packets received from user. A video frame can consist of several video pac...
Definition: TeamTalk.cs:2388
long nVoicePacketsLost
Number of voice packets lost from user.
Definition: TeamTalk.cs:2370
long nMediaFileAudioPacketsLost
Number of media file audio packets lost from user.
Definition: TeamTalk.cs:2385
long nVideoCaptureFramesLost
Video frames which couldn't be shown because packets were lost.
Definition: TeamTalk.cs:2378
long nMediaFileVideoFramesLost
Media file video frames which couldn't be shown because packets were lost.
Definition: TeamTalk.cs:2393
long nMediaFileVideoFramesDropped
Number of media file video frames dropped because user application didn't retrieve video frames in ti...
Definition: TeamTalk.cs:2396
long nVideoCaptureFramesDropped
Number of video frames dropped because user application didn't retrieve video frames in time.
Definition: TeamTalk.cs:2381
long nVideoCaptureFramesRecv
Number of video frames received from user.
Definition: TeamTalk.cs:2375
long nMediaFileVideoFramesRecv
Number of media file video frames received from user.
Definition: TeamTalk.cs:2390
long nVoicePacketsRecv
Number of voice packets received from user.
Definition: TeamTalk.cs:2368
long nMediaFileAudioPacketsRecv
Number of media file audio packets received from user.
Definition: TeamTalk.cs:2383
long nVideoCapturePacketsRecv
Number of video packets received from user. A video frame can consist of several video packets.
Definition: TeamTalk.cs:2373
A struct containing the properties of a video capture device.
Definition: TeamTalk.cs:685
string szCaptureAPI
The name of the API used to capture video.
Definition: TeamTalk.cs:705
int nVideoFormatsCount
The number of capture formats available in captureFormats array.
Definition: TeamTalk.cs:711
VideoFormat[] videoFormats
The supported capture formats.
Definition: TeamTalk.cs:708
string szDeviceID
A string identifying the device.
Definition: TeamTalk.cs:688
string szDeviceName
The name of the capture device.
Definition: TeamTalk.cs:691
Struct used for specifying the video codec to use.
Definition: TeamTalk.cs:1632
Codec nCodec
Specifies member holds the codec settings. So far there is only one video codec to choose from,...
Definition: TeamTalk.cs:1637
WebMVP8Codec webm_vp8
Definition: TeamTalk.cs:1639
A struct containing the properties of a video capture format.
Definition: TeamTalk.cs:621
int nFPS_Denominator
The denominator of the video capture device's video format. Divinding nFPS_Numerator with nFPS_Denomi...
Definition: TeamTalk.cs:635
FourCC picFourCC
Picture format for capturing.
Definition: TeamTalk.cs:637
int nHeight
The height in pixels of the video device supported video format.
Definition: TeamTalk.cs:627
int nFPS_Numerator
The numerator of the video capture device's video format. Divinding nFPS_Numerator with nFPS_Denomina...
Definition: TeamTalk.cs:631
int nWidth
The width in pixels of the video device supported video format.
Definition: TeamTalk.cs:624
A RGB32 image where the pixels can be accessed directly in an allocated imageBuffer.
Definition: TeamTalk.cs:649
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:666
int nFrameBufferSize
The size in bytes of the buffer allocate in frameBuffer.
Definition: TeamTalk.cs:671
int nHeight
The height in pixels of the image contained in imageBuffer.
Definition: TeamTalk.cs:655
int nStreamID
A unique identifier for the frames which are part of the same video sequence. If the stream ID change...
Definition: TeamTalk.cs:661
System.IntPtr frameBuffer
A buffer allocated internally by TeamTalkBase.
Definition: TeamTalk.cs:668
int nWidth
The width in pixels of the image contained in frameBuffer.
Definition: TeamTalk.cs:652
const int WEBM_VPX_DL_BEST_QUALITY
nEncodeDeadline value for best encoding.
Definition: TeamTalk.cs:1538
const int WEBM_VPX_DL_REALTIME
nEncodeDeadline value for fastest encoding.
Definition: TeamTalk.cs:1532
const int WEBM_VPX_DL_GOOD_QUALITY
nEncodeDeadline value for good encoding.
Definition: TeamTalk.cs:1535
WebM video codec settings.
Definition: TeamTalk.cs:1506
int nRcTargetBitrate
Same as rc_target_bitrate.
Definition: TeamTalk.cs:1509
uint nEncodeDeadline
Time that should be spent on encoding a frame.
Definition: TeamTalk.cs:1525
int rc_target_bitrate
Target bitrate in kbits/sec. This value must be greater than 0.
Definition: TeamTalk.cs:1516
Configuration of WebRTC's echo canceller. See also TT_SetSoundDeviceEffects()
Definition: TeamTalk.cs:1287
bool bEnable
Enable WebRTC echo canceller. The WebRTC echo canceller requires sound input and output devices are i...
Definition: TeamTalk.cs:1293
Gain level for AGC. Only active when bEnable is true.
Definition: TeamTalk.cs:1339
float fGainDB
Gain level in dB. Range: 0 <= x < 50. Default: 0.
Definition: TeamTalk.cs:1342
Configuration of WebRTC's gain controller 2 for AGC.
Definition: TeamTalk.cs:1331
bool bEnable
Enable WebRTC's fixed digital gain. WebRTC's automatic gain control (AGC)
Definition: TeamTalk.cs:1334
Configuration of WebRTC's level estimater.
Definition: TeamTalk.cs:1369
bool bEnable
Enable level estimater. When enabled TeamTalkBase.GetSoundInputLevel() will return a value based on W...
Definition: TeamTalk.cs:1375
Configuration of WebRTC's noise suppression. See also BearWare.SpeexDSP.
Definition: TeamTalk.cs:1301
int nLevel
Noise suppression level. 0 = Low, 1 = Moderate, 2 = High, 3 = VeryHigh. Default: 1.
Definition: TeamTalk.cs:1306
bool bEnable
Enable WebRTC noise suppression.
Definition: TeamTalk.cs:1303
Configuration of WebRTC pre-amplifier.
Definition: TeamTalk.cs:1274
bool bEnable
Enable pre-amplifier. Replacement for TT_SetSoundInputGainLevel()
Definition: TeamTalk.cs:1277
float fFixedGainFactor
Gain factor. Default: 1.
Definition: TeamTalk.cs:1279
Configuration of WebRTC's voice detection.
Definition: TeamTalk.cs:1313
bool bEnable
Use WebRTC's voice detection to trigger BearWare.TeamTalkBase.OnVoiceActivation.
Definition: TeamTalk.cs:1323
WebRTC's audio preprocessor.
Definition: TeamTalk.cs:1270
GainController2 gaincontroller2
Definition: TeamTalk.cs:1364
WebRTCAudioPreprocessor(bool set_defaults)
Definition: TeamTalk.cs:1379
NoiseSuppression noisesuppression
Definition: TeamTalk.cs:1308
LevelEstimation levelestimation
Definition: TeamTalk.cs:1377
Default values for BearWare.WebRTCAudioPreprocessor.
Definition: TeamTalk.cs:1432
const float DEFAULT_WEBRTC_EXTRA_SAT_MARGIN_DB
Definition: TeamTalk.cs:1441
const float DEFAULT_WEBRTC_MAXGAIN_DBSEC
Definition: TeamTalk.cs:1442
const float DEFAULT_WEBRTC_PREAMPLIFIER_GAINFACTOR
Definition: TeamTalk.cs:1434
const bool DEFAULT_WEBRTC_NOISESUPPRESS_ENABLE
Definition: TeamTalk.cs:1444
const bool DEFAULT_WEBRTC_VAD_ENABLE
Definition: TeamTalk.cs:1435
const bool DEFAULT_WEBRTC_PREAMPLIFIER_ENABLE
Definition: TeamTalk.cs:1433
const bool DEFAULT_WEBRTC_SAT_PROT_ENABLE
Definition: TeamTalk.cs:1439
const bool DEFAULT_WEBRTC_GAINCTL_ENABLE
Definition: TeamTalk.cs:1437
const float WEBRTC_GAINCONTROLLER2_FIXEDGAIN_MAX
Definition: TeamTalk.cs:1447
const float DEFAULT_WEBRTC_GAINDB
Definition: TeamTalk.cs:1438
const bool DEFAULT_WEBRTC_ECHO_CANCEL_ENABLE
Definition: TeamTalk.cs:1446
const bool DEFAULT_WEBRTC_LEVELESTIMATION_ENABLE
Definition: TeamTalk.cs:1436
const float DEFAULT_WEBRTC_INIT_SAT_MARGIN_DB
Definition: TeamTalk.cs:1440
const float DEFAULT_WEBRTC_MAX_OUT_NOISE
Definition: TeamTalk.cs:1443
const int DEFAULT_WEBRTC_NOISESUPPRESS_LEVEL
Definition: TeamTalk.cs:1445